[apple/xnu.git] / tests / os_refcnt.c

#include <darwintest.h>
#include <darwintest_utils.h>
#include <stdio.h>
#include <assert.h>
#include <setjmp.h>

#define DEVELOPMENT 1
#define DEBUG 0
#define XNU_KERNEL_PRIVATE 1

#define OS_REFCNT_DEBUG 1
#define STRESS_TESTS 0

void handle_panic(const char *func, char *str, ...);
#define panic(...) handle_panic(__func__, __VA_ARGS__)

#include "../libkern/os/refcnt.h"
#include "../libkern/os/refcnt.c"

T_GLOBAL_META(T_META_RUN_CONCURRENTLY(true));

/* import some of the refcnt internal state for testing */
extern bool ref_debug_enable;
os_refgrp_decl_extern(global_ref_group);

T_GLOBAL_META(
	T_META_NAMESPACE("os_refcnt"),
	T_META_CHECK_LEAKS(false)
	);

T_DECL(os_refcnt, "Basic atomic refcount")
{
	struct os_refcnt rc;
	os_ref_init(&rc, NULL);
	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 1, "refcount correctly initialized");

	os_ref_retain(&rc);
	os_ref_retain(&rc);
	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 3, "retain increased count");

	os_ref_count_t x = os_ref_release(&rc);
	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 2, "release decreased count");
	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");

	os_ref_release_live(&rc);
	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 1, "release_live decreased count");

	x = os_ref_release(&rc);
	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 0, "released");
	T_ASSERT_EQ_UINT(x, 0, "returned released");

	os_ref_init(&rc, NULL);
	x = os_ref_retain_try(&rc);
	T_ASSERT_GT_INT(x, 0, "try retained");

	(void)os_ref_release(&rc);
	(void)os_ref_release(&rc);
	T_QUIET; T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 0, "release");

	x = os_ref_retain_try(&rc);
	T_ASSERT_EQ_INT(x, 0, "try failed");
}

T_DECL(refcnt_raw, "Raw refcount")
{
	os_ref_atomic_t rc;
	os_ref_init_raw(&rc, NULL);
	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 1, "refcount correctly initialized");

	os_ref_retain_raw(&rc, NULL);
	os_ref_retain_raw(&rc, NULL);
	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 3, "retain increased count");

	os_ref_count_t x = os_ref_release_raw(&rc, NULL);
	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 2, "release decreased count");
	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");

	os_ref_release_live_raw(&rc, NULL);
	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 1, "release_live decreased count");

	x = os_ref_release_raw(&rc, NULL);
	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 0, "released");
	T_ASSERT_EQ_UINT(x, 0, "returned released");

	os_ref_init_raw(&rc, NULL);
	x = os_ref_retain_try_raw(&rc, NULL);
	T_ASSERT_GT_INT(x, 0, "try retained");

	(void)os_ref_release_raw(&rc, NULL);
	(void)os_ref_release_raw(&rc, NULL);
	T_QUIET; T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 0, "release");

	x = os_ref_retain_try_raw(&rc, NULL);
	T_ASSERT_EQ_INT(x, 0, "try failed");
}

T_DECL(refcnt_locked, "Locked refcount")
{
	struct os_refcnt rc;
	os_ref_init(&rc, NULL);

	os_ref_retain_locked(&rc);
	os_ref_retain_locked(&rc);
	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 3, "retain increased count");

	os_ref_count_t x = os_ref_release_locked(&rc);
	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 2, "release decreased count");
	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");

	(void)os_ref_release_locked(&rc);
	x = os_ref_release_locked(&rc);
	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 0, "released");
	T_ASSERT_EQ_UINT(x, 0, "returned released");
}

T_DECL(refcnt_raw_locked, "Locked raw refcount")
{
	os_ref_atomic_t rc;
	os_ref_init_raw(&rc, NULL);

	os_ref_retain_locked_raw(&rc, NULL);
	os_ref_retain_locked_raw(&rc, NULL);
	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 3, "retain increased count");

	os_ref_count_t x = os_ref_release_locked_raw(&rc, NULL);
	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 2, "release decreased count");
	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");

	(void)os_ref_release_locked_raw(&rc, NULL);
	x = os_ref_release_locked_raw(&rc, NULL);
	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 0, "released");
	T_ASSERT_EQ_UINT(x, 0, "returned released");
}

T_DECL(refcnt_mask_locked, "Locked bitwise refcount")
{
	const os_ref_count_t b = 12;
	os_ref_atomic_t rc;
	os_ref_count_t reserved = 0xaaa;
	os_ref_init_count_mask(&rc, NULL, 1, reserved, b);

	os_ref_retain_locked_mask(&rc, NULL, b);
	os_ref_retain_locked_mask(&rc, NULL, b);
	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, b), 3, "retain increased count");

	os_ref_count_t x = os_ref_release_locked_mask(&rc, NULL, b);
	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, b), 2, "release decreased count");
	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");
	T_ASSERT_EQ_UINT(rc & ((1U << b) - 1), reserved, "Reserved bits not modified");

	(void)os_ref_release_locked_mask(&rc, NULL, b);
	x = os_ref_release_locked_mask(&rc, NULL, b);
	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, b), 0, "released");
	T_ASSERT_EQ_UINT(x, 0, "returned released");
	T_ASSERT_EQ_UINT(rc & ((1U << b) - 1), reserved, "Reserved bits not modified");
}

static void
do_bitwise_test(const os_ref_count_t bits)
{
	os_ref_atomic_t rc;
	os_ref_count_t reserved = 0xaaaaaaaaU & ((1U << bits) - 1);
	os_ref_init_count_mask(&rc, NULL, 1, reserved, bits);

	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, bits), 1, "[%u bits] refcount initialized", bits);

	os_ref_retain_mask(&rc, NULL, bits);
	os_ref_retain_mask(&rc, NULL, bits);
	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, bits), 3, "retain increased count");

	os_ref_count_t x = os_ref_release_mask(&rc, NULL, bits);
	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");

	os_ref_release_live_mask(&rc, NULL, bits);
	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, bits), 1, "release_live decreased count");

	x = os_ref_release_mask(&rc, NULL, bits);
	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, bits), 0, "released");
	T_ASSERT_EQ_UINT(x, 0, "returned released");

	T_ASSERT_EQ_UINT(rc & ((1U << bits) - 1), reserved, "Reserved bits not modified");

	os_ref_init_count_mask(&rc, NULL, 1, reserved, bits);
	x = os_ref_retain_try_mask(&rc, NULL, bits);
	T_ASSERT_GT_INT(x, 0, "try retained");

	(void)os_ref_release_mask(&rc, NULL, bits);
	(void)os_ref_release_mask(&rc, NULL, bits);
	T_QUIET; T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, bits), 0, "release");

	x = os_ref_retain_try_mask(&rc, NULL, bits);
	T_ASSERT_EQ_INT(x, 0, "try failed");

	T_ASSERT_EQ_UINT(rc & ((1U << bits) - 1), reserved, "Reserved bits not modified");
}

T_DECL(refcnt_bitwise, "Bitwise refcount")
{
	do_bitwise_test(0);
	do_bitwise_test(1);
	do_bitwise_test(8);
	do_bitwise_test(26);

	os_ref_atomic_t rc = 0xaaaaaaaa;

	const os_ref_count_t nbits = 3;
	const os_ref_count_t count = 5;
	const os_ref_count_t bits = 7;
	os_ref_init_count_mask(&rc, NULL, count, bits, nbits);

	os_ref_count_t mask = (1U << nbits) - 1;
	T_ASSERT_EQ_UINT(rc & mask, bits, "bits correctly initialized");
	T_ASSERT_EQ_UINT(rc >> nbits, count, "count correctly initialized");
}

os_refgrp_decl(static, g1, "test group", NULL);
os_refgrp_decl_extern(g1);

T_DECL(refcnt_groups, "Group accounting")
{
#if OS_REFCNT_DEBUG
	ref_debug_enable = true;

	struct os_refcnt rc;
	os_ref_init(&rc, &g1);

	T_ASSERT_EQ_UINT(g1.grp_children, 1, "group attached");
	T_ASSERT_EQ_UINT(global_ref_group.grp_children, 1, "global group attached");
	T_ASSERT_EQ_UINT(g1.grp_count, 1, "group count");
	T_ASSERT_EQ_ULLONG(g1.grp_retain_total, 1ULL, "group retains");
	T_ASSERT_EQ_ULLONG(g1.grp_release_total, 0ULL, "group releases");

	os_ref_retain(&rc);
	os_ref_retain(&rc);
	os_ref_release_live(&rc);
	os_ref_release_live(&rc);

	T_EXPECT_EQ_ULLONG(g1.grp_retain_total, 3ULL, "group retains");
	T_EXPECT_EQ_ULLONG(g1.grp_release_total, 2ULL, "group releases");

	os_ref_count_t x = os_ref_release(&rc);
	T_QUIET; T_ASSERT_EQ_UINT(x, 0, "released");

	T_ASSERT_EQ_UINT(g1.grp_children, 0, "group detatched");
	T_ASSERT_EQ_UINT(g1.grp_count, 0, "group count");
#else
	T_SKIP("Refcount debugging disabled");
#endif
}

enum {
	OSREF_UNDERFLOW    = 1,
	OSREF_OVERFLOW     = 2,
	OSREF_RESURRECTION = 3,
	OSREF_DEALLOC_LIVE = 4,
};

static jmp_buf jb;
static bool expect_panic = false;

void
handle_panic(const char *func, char *__unused str, ...)
{
	int ret = -1;
	if (!expect_panic) {
		T_FAIL("unexpected panic from %s", func);
		T_LOG("corrupt program state, aborting");
		abort();
	}
	expect_panic = false;

	if (strcmp(func, "os_ref_panic_underflow") == 0) {
		ret = OSREF_UNDERFLOW;
	} else if (strcmp(func, "os_ref_panic_overflow") == 0) {
		ret = OSREF_OVERFLOW;
	} else if (strcmp(func, "os_ref_panic_resurrection") == 0) {
		ret = OSREF_RESURRECTION;
	} else if (strcmp(func, "os_ref_panic_live") == 0) {
		ret = OSREF_DEALLOC_LIVE;
	} else {
		T_LOG("unexpected panic from %s", func);
	}

	longjmp(jb, ret);
}

T_DECL(refcnt_underflow, "Underflow")
{
	os_ref_atomic_t rc;
	os_ref_init_raw(&rc, NULL);
	(void)os_ref_release_raw(&rc, NULL);

	int x = setjmp(jb);
	if (x == 0) {
		expect_panic = true;
		(void)os_ref_release_raw(&rc, NULL);
		T_FAIL("underflow not caught");
	} else {
		T_ASSERT_EQ_INT(x, OSREF_UNDERFLOW, "underflow caught");
	}
}

T_DECL(refcnt_overflow, "Overflow")
{
	os_ref_atomic_t rc;
	os_ref_init_count_raw(&rc, NULL, 0x0fffffffU);

	int x = setjmp(jb);
	if (x == 0) {
		expect_panic = true;
		(void)os_ref_retain_raw(&rc, NULL);
		T_FAIL("overflow not caught");
	} else {
		T_ASSERT_EQ_INT(x, OSREF_OVERFLOW, "overflow caught");
	}
}

T_DECL(refcnt_resurrection, "Resurrection")
{
	os_ref_atomic_t rc;
	os_ref_init_raw(&rc, NULL);
	os_ref_count_t n = os_ref_release_raw(&rc, NULL);

	T_QUIET; T_EXPECT_EQ_UINT(n, 0, "reference not released");

	int x = setjmp(jb);
	if (x == 0) {
		expect_panic = true;
		(void)os_ref_retain_raw(&rc, NULL);
		T_FAIL("resurrection not caught");
	} else {
		T_ASSERT_EQ_INT(x, OSREF_RESURRECTION, "resurrection caught");
	}
}

T_DECL(refcnt_dealloc_live, "Dealloc expected live object")
{
	os_ref_atomic_t rc;
	os_ref_init_raw(&rc, NULL);

	expect_panic = true;
	int x = setjmp(jb);
	if (x == 0) {
		expect_panic = true;
		os_ref_release_live_raw(&rc, NULL);
		T_FAIL("dealloc live not caught");
	} else {
		T_ASSERT_EQ_INT(x, OSREF_DEALLOC_LIVE, "dealloc live caught");
	}
}

T_DECL(refcnt_initializer, "Static intializers")
{
	struct os_refcnt rc = OS_REF_INITIALIZER;
	os_ref_atomic_t rca = OS_REF_ATOMIC_INITIALIZER;

	T_ASSERT_EQ_INT(0, os_ref_retain_try(&rc), NULL);
	T_ASSERT_EQ_INT(0, os_ref_get_count_raw(&rca), NULL);
}

#if STRESS_TESTS

static const unsigned long iters = 1024 * 1024 * 32;

static void *
func(void *_rc)
{
	struct os_refcnt *rc = _rc;
	for (unsigned long i = 0; i < iters; i++) {
		os_ref_retain(rc);
		os_ref_release_live(rc);
	}
	return NULL;
}

T_DECL(refcnt_stress, "Stress test")
{
	pthread_t th1, th2;

	struct os_refcnt rc;
	os_ref_init(&rc, NULL);

	T_ASSERT_POSIX_ZERO(pthread_create(&th1, NULL, func, &rc), "pthread_create");
	T_ASSERT_POSIX_ZERO(pthread_create(&th2, NULL, func, &rc), "pthread_create");

	void *r1, *r2;
	T_ASSERT_POSIX_ZERO(pthread_join(th1, &r1), "pthread_join");
	T_ASSERT_POSIX_ZERO(pthread_join(th2, &r2), "pthread_join");

	os_ref_count_t x = os_ref_release(&rc);
	T_ASSERT_EQ_INT(x, 0, "Consistent refcount");
}

#endif
Commit	Line	Data
cb323159 A	1	#include <darwintest.h>
	2	#include <darwintest_utils.h>
	3	#include <stdio.h>
	4	#include <assert.h>
	5	#include <setjmp.h>
	6
	7	#define DEVELOPMENT 1
	8	#define DEBUG 0
	9	#define XNU_KERNEL_PRIVATE 1
	10
	11	#define OS_REFCNT_DEBUG 1
	12	#define STRESS_TESTS 0
	13
	14	void handle_panic(const char func, char str, ...);
	15	#define panic(...) handle_panic(__func__, __VA_ARGS__)
	16
	17	#include "../libkern/os/refcnt.h"
	18	#include "../libkern/os/refcnt.c"
	19
	20	T_GLOBAL_META(T_META_RUN_CONCURRENTLY(true));
	21
	22	/* import some of the refcnt internal state for testing */
	23	extern bool ref_debug_enable;
	24	os_refgrp_decl_extern(global_ref_group);
	25
	26	T_GLOBAL_META(
	27	T_META_NAMESPACE("os_refcnt"),
	28	T_META_CHECK_LEAKS(false)
	29	);
	30
	31	T_DECL(os_refcnt, "Basic atomic refcount")
	32	{
	33	struct os_refcnt rc;
	34	os_ref_init(&rc, NULL);
	35	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 1, "refcount correctly initialized");
	36
	37	os_ref_retain(&rc);
	38	os_ref_retain(&rc);
	39	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 3, "retain increased count");
	40
	41	os_ref_count_t x = os_ref_release(&rc);
	42	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 2, "release decreased count");
	43	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");
	44
	45	os_ref_release_live(&rc);
	46	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 1, "release_live decreased count");
	47
	48	x = os_ref_release(&rc);
	49	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 0, "released");
	50	T_ASSERT_EQ_UINT(x, 0, "returned released");
	51
	52	os_ref_init(&rc, NULL);
	53	x = os_ref_retain_try(&rc);
	54	T_ASSERT_GT_INT(x, 0, "try retained");
	55
	56	(void)os_ref_release(&rc);
	57	(void)os_ref_release(&rc);
	58	T_QUIET; T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 0, "release");
	59
	60	x = os_ref_retain_try(&rc);
	61	T_ASSERT_EQ_INT(x, 0, "try failed");
	62	}
	63
	64	T_DECL(refcnt_raw, "Raw refcount")
65	{
66	os_ref_atomic_t rc;
67	os_ref_init_raw(&rc, NULL);
68	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 1, "refcount correctly initialized");
69
70	os_ref_retain_raw(&rc, NULL);
71	os_ref_retain_raw(&rc, NULL);
72	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 3, "retain increased count");
73
74	os_ref_count_t x = os_ref_release_raw(&rc, NULL);
75	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 2, "release decreased count");
76	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");
77
78	os_ref_release_live_raw(&rc, NULL);
79	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 1, "release_live decreased count");
80
81	x = os_ref_release_raw(&rc, NULL);
82	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 0, "released");
83	T_ASSERT_EQ_UINT(x, 0, "returned released");
84
85	os_ref_init_raw(&rc, NULL);
86	x = os_ref_retain_try_raw(&rc, NULL);
87	T_ASSERT_GT_INT(x, 0, "try retained");
88
89	(void)os_ref_release_raw(&rc, NULL);
90	(void)os_ref_release_raw(&rc, NULL);
91	T_QUIET; T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 0, "release");
92
93	x = os_ref_retain_try_raw(&rc, NULL);
94	T_ASSERT_EQ_INT(x, 0, "try failed");
95	}
96
97	T_DECL(refcnt_locked, "Locked refcount")
98	{
99	struct os_refcnt rc;
100	os_ref_init(&rc, NULL);
101
102	os_ref_retain_locked(&rc);
103	os_ref_retain_locked(&rc);
104	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 3, "retain increased count");
105
106	os_ref_count_t x = os_ref_release_locked(&rc);
107	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 2, "release decreased count");
108	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");
109
110	(void)os_ref_release_locked(&rc);
111	x = os_ref_release_locked(&rc);
112	T_ASSERT_EQ_UINT(os_ref_get_count(&rc), 0, "released");
113	T_ASSERT_EQ_UINT(x, 0, "returned released");
114	}
115
116	T_DECL(refcnt_raw_locked, "Locked raw refcount")
117	{
118	os_ref_atomic_t rc;
119	os_ref_init_raw(&rc, NULL);
120
121	os_ref_retain_locked_raw(&rc, NULL);
122	os_ref_retain_locked_raw(&rc, NULL);
123	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 3, "retain increased count");
124
125	os_ref_count_t x = os_ref_release_locked_raw(&rc, NULL);
126	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 2, "release decreased count");
127	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");
128
129	(void)os_ref_release_locked_raw(&rc, NULL);
130	x = os_ref_release_locked_raw(&rc, NULL);
131	T_ASSERT_EQ_UINT(os_ref_get_count_raw(&rc), 0, "released");
132	T_ASSERT_EQ_UINT(x, 0, "returned released");
133	}
134
135	T_DECL(refcnt_mask_locked, "Locked bitwise refcount")
136	{
137	const os_ref_count_t b = 12;
138	os_ref_atomic_t rc;
139	os_ref_count_t reserved = 0xaaa;
140	os_ref_init_count_mask(&rc, NULL, 1, reserved, b);
141
142	os_ref_retain_locked_mask(&rc, NULL, b);
143	os_ref_retain_locked_mask(&rc, NULL, b);
144	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, b), 3, "retain increased count");
145
146	os_ref_count_t x = os_ref_release_locked_mask(&rc, NULL, b);
147	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, b), 2, "release decreased count");
148	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");
149	T_ASSERT_EQ_UINT(rc & ((1U << b) - 1), reserved, "Reserved bits not modified");
150
151	(void)os_ref_release_locked_mask(&rc, NULL, b);
152	x = os_ref_release_locked_mask(&rc, NULL, b);
153	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, b), 0, "released");
154	T_ASSERT_EQ_UINT(x, 0, "returned released");
155	T_ASSERT_EQ_UINT(rc & ((1U << b) - 1), reserved, "Reserved bits not modified");
156	}
157
158	static void
159	do_bitwise_test(const os_ref_count_t bits)
160	{
161	os_ref_atomic_t rc;
162	os_ref_count_t reserved = 0xaaaaaaaaU & ((1U << bits) - 1);
163	os_ref_init_count_mask(&rc, NULL, 1, reserved, bits);
164
165	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, bits), 1, "[%u bits] refcount initialized", bits);
166
167	os_ref_retain_mask(&rc, NULL, bits);
168	os_ref_retain_mask(&rc, NULL, bits);
169	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, bits), 3, "retain increased count");
170
171	os_ref_count_t x = os_ref_release_mask(&rc, NULL, bits);
172	T_ASSERT_EQ_UINT(x, 2, "release returned correct count");
173
174	os_ref_release_live_mask(&rc, NULL, bits);
175	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, bits), 1, "release_live decreased count");
176
177	x = os_ref_release_mask(&rc, NULL, bits);
178	T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, bits), 0, "released");
179	T_ASSERT_EQ_UINT(x, 0, "returned released");
180
181	T_ASSERT_EQ_UINT(rc & ((1U << bits) - 1), reserved, "Reserved bits not modified");
182
183	os_ref_init_count_mask(&rc, NULL, 1, reserved, bits);
184	x = os_ref_retain_try_mask(&rc, NULL, bits);
185	T_ASSERT_GT_INT(x, 0, "try retained");
186
187	(void)os_ref_release_mask(&rc, NULL, bits);
188	(void)os_ref_release_mask(&rc, NULL, bits);
189	T_QUIET; T_ASSERT_EQ_UINT(os_ref_get_count_mask(&rc, bits), 0, "release");
190
191	x = os_ref_retain_try_mask(&rc, NULL, bits);
192	T_ASSERT_EQ_INT(x, 0, "try failed");
193
194	T_ASSERT_EQ_UINT(rc & ((1U << bits) - 1), reserved, "Reserved bits not modified");
195	}
196
197	T_DECL(refcnt_bitwise, "Bitwise refcount")
198	{
199	do_bitwise_test(0);
200	do_bitwise_test(1);
201	do_bitwise_test(8);
202	do_bitwise_test(26);
203
204	os_ref_atomic_t rc = 0xaaaaaaaa;
205
206	const os_ref_count_t nbits = 3;
207	const os_ref_count_t count = 5;
208	const os_ref_count_t bits = 7;
209	os_ref_init_count_mask(&rc, NULL, count, bits, nbits);
210
211	os_ref_count_t mask = (1U << nbits) - 1;
212	T_ASSERT_EQ_UINT(rc & mask, bits, "bits correctly initialized");
213	T_ASSERT_EQ_UINT(rc >> nbits, count, "count correctly initialized");
214	}
215
216	os_refgrp_decl(static, g1, "test group", NULL);
217	os_refgrp_decl_extern(g1);
218
219	T_DECL(refcnt_groups, "Group accounting")
220	{
221	#if OS_REFCNT_DEBUG
222	ref_debug_enable = true;
223
224	struct os_refcnt rc;
225	os_ref_init(&rc, &g1);
226
227	T_ASSERT_EQ_UINT(g1.grp_children, 1, "group attached");
228	T_ASSERT_EQ_UINT(global_ref_group.grp_children, 1, "global group attached");
229	T_ASSERT_EQ_UINT(g1.grp_count, 1, "group count");
230	T_ASSERT_EQ_ULLONG(g1.grp_retain_total, 1ULL, "group retains");
231	T_ASSERT_EQ_ULLONG(g1.grp_release_total, 0ULL, "group releases");
232
233	os_ref_retain(&rc);
234	os_ref_retain(&rc);
235	os_ref_release_live(&rc);
236	os_ref_release_live(&rc);
237
238	T_EXPECT_EQ_ULLONG(g1.grp_retain_total, 3ULL, "group retains");
239	T_EXPECT_EQ_ULLONG(g1.grp_release_total, 2ULL, "group releases");
240
241	os_ref_count_t x = os_ref_release(&rc);
242	T_QUIET; T_ASSERT_EQ_UINT(x, 0, "released");
243
244	T_ASSERT_EQ_UINT(g1.grp_children, 0, "group detatched");
245	T_ASSERT_EQ_UINT(g1.grp_count, 0, "group count");
246	#else
247	T_SKIP("Refcount debugging disabled");
248	#endif
249	}
250
251	enum {
252	OSREF_UNDERFLOW = 1,
253	OSREF_OVERFLOW = 2,
254	OSREF_RESURRECTION = 3,
255	OSREF_DEALLOC_LIVE = 4,
256	};
257
258	static jmp_buf jb;
259	static bool expect_panic = false;
260
261	void
262	handle_panic(const char func, char __unused str, ...)
263	{
264	int ret = -1;
265	if (!expect_panic) {
266	T_FAIL("unexpected panic from %s", func);
267	T_LOG("corrupt program state, aborting");
268	abort();
269	}
270	expect_panic = false;
271
272	if (strcmp(func, "os_ref_panic_underflow") == 0) {
273	ret = OSREF_UNDERFLOW;
274	} else if (strcmp(func, "os_ref_panic_overflow") == 0) {
275	ret = OSREF_OVERFLOW;
276	} else if (strcmp(func, "os_ref_panic_resurrection") == 0) {
277	ret = OSREF_RESURRECTION;
278	} else if (strcmp(func, "os_ref_panic_live") == 0) {
279	ret = OSREF_DEALLOC_LIVE;
280	} else {
281	T_LOG("unexpected panic from %s", func);
282	}
283
284	longjmp(jb, ret);
285	}
286
287	T_DECL(refcnt_underflow, "Underflow")
288	{
289	os_ref_atomic_t rc;
290	os_ref_init_raw(&rc, NULL);
291	(void)os_ref_release_raw(&rc, NULL);
292
293	int x = setjmp(jb);
294	if (x == 0) {
295	expect_panic = true;
296	(void)os_ref_release_raw(&rc, NULL);
297	T_FAIL("underflow not caught");
298	} else {
299	T_ASSERT_EQ_INT(x, OSREF_UNDERFLOW, "underflow caught");
300	}
301	}
302
303	T_DECL(refcnt_overflow, "Overflow")
304	{
305	os_ref_atomic_t rc;
306	os_ref_init_count_raw(&rc, NULL, 0x0fffffffU);
307
308	int x = setjmp(jb);
309	if (x == 0) {
310	expect_panic = true;
311	(void)os_ref_retain_raw(&rc, NULL);
312	T_FAIL("overflow not caught");
313	} else {
314	T_ASSERT_EQ_INT(x, OSREF_OVERFLOW, "overflow caught");
315	}
316	}
317
318	T_DECL(refcnt_resurrection, "Resurrection")
319	{
320	os_ref_atomic_t rc;
321	os_ref_init_raw(&rc, NULL);
322	os_ref_count_t n = os_ref_release_raw(&rc, NULL);
323
324	T_QUIET; T_EXPECT_EQ_UINT(n, 0, "reference not released");
325
326	int x = setjmp(jb);
327	if (x == 0) {
328	expect_panic = true;
329	(void)os_ref_retain_raw(&rc, NULL);
330	T_FAIL("resurrection not caught");
331	} else {
332	T_ASSERT_EQ_INT(x, OSREF_RESURRECTION, "resurrection caught");
333	}
334	}
335
336	T_DECL(refcnt_dealloc_live, "Dealloc expected live object")
337	{
338	os_ref_atomic_t rc;
339	os_ref_init_raw(&rc, NULL);
340
341	expect_panic = true;
342	int x = setjmp(jb);
343	if (x == 0) {
344	expect_panic = true;
345	os_ref_release_live_raw(&rc, NULL);
346	T_FAIL("dealloc live not caught");
347	} else {
348	T_ASSERT_EQ_INT(x, OSREF_DEALLOC_LIVE, "dealloc live caught");
349	}
350	}
351
352	T_DECL(refcnt_initializer, "Static intializers")
353	{
354	struct os_refcnt rc = OS_REF_INITIALIZER;
355	os_ref_atomic_t rca = OS_REF_ATOMIC_INITIALIZER;
356
357	T_ASSERT_EQ_INT(0, os_ref_retain_try(&rc), NULL);
358	T_ASSERT_EQ_INT(0, os_ref_get_count_raw(&rca), NULL);
359	}
360
361	#if STRESS_TESTS
362
363	static const unsigned long iters = 1024 * 1024 * 32;
364
365	static void *
366	func(void *_rc)
367	{
368	struct os_refcnt *rc = _rc;
369	for (unsigned long i = 0; i < iters; i++) {
370	os_ref_retain(rc);
371	os_ref_release_live(rc);
372	}
373	return NULL;
374	}
375
376	T_DECL(refcnt_stress, "Stress test")
377	{
378	pthread_t th1, th2;
379
380	struct os_refcnt rc;
381	os_ref_init(&rc, NULL);
382
383	T_ASSERT_POSIX_ZERO(pthread_create(&th1, NULL, func, &rc), "pthread_create");
384	T_ASSERT_POSIX_ZERO(pthread_create(&th2, NULL, func, &rc), "pthread_create");
385
386	void r1, r2;
387	T_ASSERT_POSIX_ZERO(pthread_join(th1, &r1), "pthread_join");
388	T_ASSERT_POSIX_ZERO(pthread_join(th2, &r2), "pthread_join");
389
390	os_ref_count_t x = os_ref_release(&rc);
391	T_ASSERT_EQ_INT(x, 0, "Consistent refcount");
392	}
393
394	#endif