Index: kernel/test/cht/cht1.c
===================================================================
--- kernel/test/cht/cht1.c	(revision 1433ecda9b732f3f185f902feb26826ec2496e03)
+++ kernel/test/cht/cht1.c	(revision 902dd4bcbf12a24a5c7153d6f97cf6cd7886c59f)
@@ -95,13 +95,13 @@
 
 
-static const char * do_sanity_test(cht_t *h)
-{
-	if (cht_find_lazy(h, (void*)0))
+static const char *do_sanity_test(cht_t *h)
+{
+	if (cht_find_lazy(h, (void *)0))
 		return "Found lazy in empty table.";
 
-	if (cht_find(h, (void*)0))
+	if (cht_find(h, (void *)0))
 		return "Found in empty table.";
 
-	if (cht_remove_key(h, (void*)0))
+	if (cht_remove_key(h, (void *)0))
 		return "Removed from empty table.";
 
@@ -149,8 +149,8 @@
 		return "Refused unique ins 4, 5.";
 
-	if (cht_find(h, (void*)0))
+	if (cht_find(h, (void *)0))
 		return "Phantom find.";
 
-	cht_link_t *item = cht_find(h, (void*)v[5]->unique_id);
+	cht_link_t *item = cht_find(h, (void *)v[5]->unique_id);
 	if (!item || item != &v[5]->link)
 		return "Missing 5.";
@@ -160,5 +160,5 @@
 		return "Found nonexisting duplicate 5";
 
-	item = cht_find(h, (void*)v[3]->unique_id);
+	item = cht_find(h, (void *)v[3]->unique_id);
 	if (!item || item != &v[3]->link)
 		return "Missing 3.";
@@ -168,6 +168,6 @@
 		return "Found nonexisting duplicate 3, same hash as others.";
 
-	item = cht_find(h, (void*)v[0]->unique_id);
-	((val_t*)item)->mark = true;
+	item = cht_find(h, (void *)v[0]->unique_id);
+	((val_t *)item)->mark = true;
 
 	for (int k = 1; k < 3; ++k) {
@@ -176,5 +176,5 @@
 			return "Did not find an inserted duplicate";
 
-		val_t *val = ((val_t*)item);
+		val_t *val = ((val_t *)item);
 
 		if (val->unique_id != v[0]->unique_id)
@@ -195,16 +195,16 @@
 		return "Found non-existing duplicate.";
 
-	item = cht_find_next(h, cht_find(h, (void*)key[0]));
-
-	((val_t*)item)->mark = true;
+	item = cht_find_next(h, cht_find(h, (void *)key[0]));
+
+	((val_t *)item)->mark = true;
 	if (!cht_remove_item(h, item))
 		return "Failed to remove inserted item";
 
-	item = cht_find(h, (void*)key[0]);
-	if (!item || ((val_t*)item)->mark)
+	item = cht_find(h, (void *)key[0]);
+	if (!item || ((val_t *)item)->mark)
 		return "Did not find proper item.";
 
 	item = cht_find_next(h, item);
-	if (!item || ((val_t*)item)->mark)
+	if (!item || ((val_t *)item)->mark)
 		return "Did not find proper duplicate.";
 
@@ -213,19 +213,19 @@
 		return "Found removed duplicate";
 
-	if (2 != cht_remove_key(h, (void*)key[0]))
+	if (2 != cht_remove_key(h, (void *)key[0]))
 		return "Failed to remove all duplicates";
 
-	if (cht_find(h, (void*)key[0]))
+	if (cht_find(h, (void *)key[0]))
 		return "Found removed key";
 
-	if (!cht_find(h, (void*)key[3]))
+	if (!cht_find(h, (void *)key[3]))
 		return "Removed incorrect key";
 
 	for (size_t k = 0; k < sizeof(v) / sizeof(v[0]); ++k) {
-		cht_remove_key(h, (void*)key[k]);
+		cht_remove_key(h, (void *)key[k]);
 	}
 
 	for (size_t k = 0; k < sizeof(v) / sizeof(v[0]); ++k) {
-		if (cht_find(h, (void*)key[k]))
+		if (cht_find(h, (void *)key[k]))
 			return "Found a key in a cleared table";
 	}
@@ -234,5 +234,5 @@
 }
 
-static const char * sanity_test(void)
+static const char *sanity_test(void)
 {
 	cht_t h;
@@ -279,5 +279,5 @@
 static size_t stress_hash(const cht_link_t *item)
 {
-	return ((stress_t*)item)->key >> 8;
+	return ((stress_t *)item)->key >> 8;
 }
 static size_t stress_key_hash(void *key)
@@ -287,16 +287,16 @@
 static bool stress_equal(const cht_link_t *item1, const cht_link_t *item2)
 {
-	return ((stress_t*)item1)->key == ((stress_t*)item2)->key;
+	return ((stress_t *)item1)->key == ((stress_t *)item2)->key;
 }
 static bool stress_key_equal(void *key, const cht_link_t *item)
 {
-	return ((size_t)key) == ((stress_t*)item)->key;
+	return ((size_t)key) == ((stress_t *)item)->key;
 }
 static void stress_rm_callback(cht_link_t *item)
 {
-	if (((stress_t*)item)->free)
+	if (((stress_t *)item)->free)
 		free(item);
 	else
-		((stress_t*)item)->deleted = true;
+		((stress_t *)item)->deleted = true;
 }
 
@@ -335,5 +335,5 @@
 			size_t key = (i << 8) + work->id;
 
-			if (1 != cht_remove_key(work->h, (void*)key)) {
+			if (1 != cht_remove_key(work->h, (void *)key)) {
 				TPRINTF("Err: Failed to remove inserted item\n");
 				goto failed;
@@ -357,5 +357,5 @@
 	for (size_t i = 0; i < work->wave_elems; ++i) {
 		size_t key = (i << 8) + work->id;
-		cht_remove_key(work->h, (void*)key);
+		cht_remove_key(work->h, (void *)key);
 	}
 }
@@ -392,5 +392,5 @@
 					rcu_read_unlock();
 				} else {
-					void *key = (void*)work->elem[elem_idx].key;
+					void *key = (void *)work->elem[elem_idx].key;
 					if (1 != cht_remove_key(work->h, key)) {
 						TPRINTF("Err: did not rm the key\n");
@@ -406,5 +406,5 @@
 					cht_link_t *dup;
 					if (!cht_insert_unique(work->h, &work->elem[elem_idx].link,
-						&dup)) {
+					    &dup)) {
 						TPRINTF("Err: already inserted\n");
 						work->failed = true;
@@ -420,5 +420,5 @@
 			rcu_read_lock();
 			cht_link_t *item =
-				cht_find(work->h, (void*)work->elem[elem_idx].key);
+			    cht_find(work->h, (void *)work->elem[elem_idx].key);
 			rcu_read_unlock();
 
@@ -444,5 +444,5 @@
 	/* Remove anything we may have inserted. */
 	for (size_t i = 0; i < work->elem_cnt; ++i) {
-		void *key = (void*) work->elem[i].key;
+		void *key = (void *) work->elem[i].key;
 		cht_remove_key(work->h, key);
 	}
@@ -469,6 +469,6 @@
 
 	/* Alloc hash table items. */
-	size_t size = item_cnt * sizeof(stress_t) + work_cnt * sizeof(stress_work_t)
-		+ sizeof(int);
+	size_t size = item_cnt * sizeof(stress_t) + work_cnt * sizeof(stress_work_t) +
+	    sizeof(int);
 
 	TPRINTF("Alloc and init table items. \n");
@@ -482,5 +482,5 @@
 	stress_t *pitem = p + work_cnt * sizeof(stress_work_t);
 	stress_work_t *pwork = p;
-	int *pstop = (int*)(pitem + item_cnt);
+	int *pstop = (int *)(pitem + item_cnt);
 
 	*pstop = 0;
@@ -517,5 +517,5 @@
 
 	TPRINTF("Running %zu ins/del/find stress threads + %zu resizers.\n",
-		op_thread_cnt, resize_thread_cnt);
+	    op_thread_cnt, resize_thread_cnt);
 
 	/* Create and run threads. */
Index: kernel/test/synch/rcu1.c
===================================================================
--- kernel/test/synch/rcu1.c	(revision 1433ecda9b732f3f185f902feb26826ec2496e03)
+++ kernel/test/synch/rcu1.c	(revision 902dd4bcbf12a24a5c7153d6f97cf6cd7886c59f)
@@ -78,12 +78,12 @@
 }
 
-static void run_thread(size_t k, void (*func)(void*), void *arg)
+static void run_thread(size_t k, void (*func)(void *), void *arg)
 {
 	assert(thread[k] == NULL);
 
 	thread[k] = thread_create(func, arg, TASK, THREAD_FLAG_NONE,
-		"test-rcu-thread");
-
-	if(thread[k]) {
+	    "test-rcu-thread");
+
+	if (thread[k]) {
 		/* Distribute evenly. */
 		thread_wire(thread[k], &cpus[k % config.cpu_active]);
@@ -92,5 +92,5 @@
 }
 
-static void run_all(void (*func)(void*))
+static void run_all(void (*func)(void *))
 {
 	size_t thread_cnt = get_thread_cnt();
@@ -127,5 +127,5 @@
 }
 
-static void run_one(void (*func)(void*), void *arg)
+static void run_one(void (*func)(void *), void *arg)
 {
 	assert(one_idx < MAX_THREADS);
@@ -179,5 +179,5 @@
 static bool do_nop_readers(void)
 {
-	size_t seq[MAX_THREADS] = {0};
+	size_t seq[MAX_THREADS] = { 0 };
 	get_seq(100, 100000, get_thread_cnt(), seq);
 
@@ -185,5 +185,5 @@
 
 	for (size_t k = 0; k < get_thread_cnt(); ++k)
-		run_one(nop_reader, (void*)seq[k]);
+		run_one(nop_reader, (void *)seq[k]);
 
 	TPRINTF("\nJoining %zu no-op readers\n", get_thread_cnt());
@@ -220,12 +220,12 @@
 static bool do_long_readers(void)
 {
-	size_t seq[MAX_THREADS] = {0};
+	size_t seq[MAX_THREADS] = { 0 };
 	get_seq(10, 1000 * 1000, get_thread_cnt(), seq);
 
 	TPRINTF("\nRun %zu thr: repeat long reader sections, will preempt, no cbs.\n",
-		get_thread_cnt());
+	    get_thread_cnt());
 
 	for (size_t k = 0; k < get_thread_cnt(); ++k)
-		run_one(long_reader, (void*)seq[k]);
+		run_one(long_reader, (void *)seq[k]);
 
 	TPRINTF("\nJoining %zu readers with long reader sections.\n", get_thread_cnt());
@@ -238,5 +238,5 @@
 
 
-static atomic_t nop_callbacks_cnt = {0};
+static atomic_t nop_callbacks_cnt = { 0 };
 /* Must be even. */
 static const int nop_updater_iters = 10000;
@@ -250,5 +250,5 @@
 static void nop_updater(void *arg)
 {
-	for (int i = 0; i < nop_updater_iters; i += 2){
+	for (int i = 0; i < nop_updater_iters; i += 2) {
 		rcu_item_t *a = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
 		rcu_item_t *b = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
@@ -274,5 +274,5 @@
 
 	TPRINTF("\nRun %zu thr: post %zu no-op callbacks (%zu B used), no readers.\n",
-		get_thread_cnt(), exp_cnt, max_used_mem);
+	    get_thread_cnt(), exp_cnt, max_used_mem);
 
 	run_all(nop_updater);
@@ -303,5 +303,5 @@
 static void one_cb_done(rcu_item_t *item)
 {
-	assert( ((item_w_cookie_t *)item)->cookie == magic_cookie);
+	assert(((item_w_cookie_t *)item)->cookie == magic_cookie);
 	one_cb_is_done = 1;
 	TPRINTF("Callback()\n");
@@ -367,6 +367,6 @@
 static errno_t seq_test_result = EOK;
 
-static atomic_t cur_time = {1};
-static atomic_count_t max_upd_done_time = {0};
+static atomic_t cur_time = { 1 };
+static atomic_count_t max_upd_done_time = { 0 };
 
 static void seq_cb(rcu_item_t *rcu_item)
@@ -392,5 +392,5 @@
 	 */
 #ifndef KARCH_riscv64
-	seq_work_t *work = (seq_work_t*)arg;
+	seq_work_t *work = (seq_work_t *)arg;
 
 	/* Alternate between reader and updater roles. */
@@ -401,5 +401,5 @@
 			atomic_count_t start_time = atomic_postinc(&cur_time);
 
-			for (volatile size_t d = 0; d < 10 * i; ++d ){
+			for (volatile size_t d = 0; d < 10 * i; ++d) {
 				/* no-op */
 			}
@@ -452,5 +452,5 @@
 	const size_t iters = 100;
 	const size_t total_cnt = 1000;
-	size_t read_cnt[MAX_THREADS] = {0};
+	size_t read_cnt[MAX_THREADS] = { 0 };
 	seq_work_t item[MAX_THREADS];
 
@@ -476,6 +476,6 @@
 
 	TPRINTF("\nRun %zu th: check callback completion time in readers. "
-		"%zu callbacks total (max %" PRIu64 " %s used). Be patient.\n",
-		get_thread_cnt(), total_cbs, mem_units, mem_suffix);
+	    "%zu callbacks total (max %" PRIu64 " %s used). Be patient.\n",
+	    get_thread_cnt(), total_cbs, mem_units, mem_suffix);
 
 	for (size_t i = 0; i < get_thread_cnt(); ++i) {
@@ -500,5 +500,5 @@
 static void reader_unlocked(rcu_item_t *item)
 {
-	exited_t *p = (exited_t*)item;
+	exited_t *p = (exited_t *)item;
 	p->exited = true;
 }
@@ -511,5 +511,5 @@
 	rcu_read_unlock();
 
-	rcu_call((rcu_item_t*)arg, reader_unlocked);
+	rcu_call((rcu_item_t *)arg, reader_unlocked);
 
 	rcu_read_lock();
@@ -566,5 +566,5 @@
 static void preempted_reader_prev(void *arg)
 {
-	preempt_t *p = (preempt_t*)arg;
+	preempt_t *p = (preempt_t *)arg;
 	assert(!p->e.exited);
 
@@ -586,5 +586,5 @@
 static void preempted_reader_inside_cur(void *arg)
 {
-	preempt_t *p = (preempt_t*)arg;
+	preempt_t *p = (preempt_t *)arg;
 	assert(!p->e.exited);
 
@@ -611,5 +611,5 @@
 static void preempted_reader_cur(void *arg)
 {
-	preempt_t *p = (preempt_t*)arg;
+	preempt_t *p = (preempt_t *)arg;
 	assert(!p->e.exited);
 
@@ -633,5 +633,5 @@
 static void preempted_reader_next1(void *arg)
 {
-	preempt_t *p = (preempt_t*)arg;
+	preempt_t *p = (preempt_t *)arg;
 	assert(!p->e.exited);
 
@@ -655,5 +655,5 @@
 static void preempted_reader_next2(void *arg)
 {
-	preempt_t *p = (preempt_t*)arg;
+	preempt_t *p = (preempt_t *)arg;
 	assert(!p->e.exited);
 
@@ -684,5 +684,5 @@
 
 
-static bool do_one_reader_preempt(void (*f)(void*), const char *err)
+static bool do_one_reader_preempt(void (*f)(void *), const char *err)
 {
 	preempt_t *p = malloc(sizeof(preempt_t), FRAME_ATOMIC);
@@ -719,21 +719,21 @@
 
 	ok = do_one_reader_preempt(preempted_reader_prev,
-		"Err: preempted_reader_prev()\n");
+	    "Err: preempted_reader_prev()\n");
 	success = success && ok;
 
 	ok = do_one_reader_preempt(preempted_reader_inside_cur,
-		"Err: preempted_reader_inside_cur()\n");
+	    "Err: preempted_reader_inside_cur()\n");
 	success = success && ok;
 
 	ok = do_one_reader_preempt(preempted_reader_cur,
-		"Err: preempted_reader_cur()\n");
+	    "Err: preempted_reader_cur()\n");
 	success = success && ok;
 
 	ok = do_one_reader_preempt(preempted_reader_next1,
-		"Err: preempted_reader_next1()\n");
+	    "Err: preempted_reader_next1()\n");
 	success = success && ok;
 
 	ok = do_one_reader_preempt(preempted_reader_next2,
-		"Err: preempted_reader_next2()\n");
+	    "Err: preempted_reader_next2()\n");
 	success = success && ok;
 
@@ -860,5 +860,5 @@
 static void stress_reader(void *arg)
 {
-	bool *done = (bool*) arg;
+	bool *done = (bool *) arg;
 
 	while (!*done) {
@@ -896,5 +896,5 @@
 
 		/* Print a dot if we make a progress of 1% */
-		if (s->master && 0 == (i % (s->iters/100)))
+		if (s->master && 0 == (i % (s->iters / 100)))
 			TPRINTF(".");
 	}
@@ -921,6 +921,6 @@
 
 	TPRINTF("\nStress: Run %zu nop-readers and %zu updaters. %zu callbacks"
-		" total (max %" PRIu64 " %s used). Be very patient.\n",
-		reader_cnt, updater_cnt, exp_upd_calls, mem_units, mem_suffix);
+	    " total (max %" PRIu64 " %s used). Be very patient.\n",
+	    reader_cnt, updater_cnt, exp_upd_calls, mem_units, mem_suffix);
 
 	for (size_t k = 0; k < reader_cnt; ++k) {
@@ -961,5 +961,5 @@
 		--e->count_down;
 
-		if (0 == (e->count_down % (e->total_cnt/100))) {
+		if (0 == (e->count_down % (e->total_cnt / 100))) {
 			TPRINTF("*");
 		}
@@ -1046,5 +1046,5 @@
 		if (ok) {
 			TPRINTF("\nSubtest %s() ok (GPs: %" PRIu64 ").\n",
-				test_func[i].desc, delta_gps);
+			    test_func[i].desc, delta_gps);
 		} else {
 			TPRINTF("\nFailed: %s(). Pausing for 5 secs.\n", test_func[i].desc);
Index: kernel/test/synch/workq-test-core.h
===================================================================
--- kernel/test/synch/workq-test-core.h	(revision 1433ecda9b732f3f185f902feb26826ec2496e03)
+++ kernel/test/synch/workq-test-core.h	(revision 902dd4bcbf12a24a5c7153d6f97cf6cd7886c59f)
@@ -67,8 +67,8 @@
 {
 	unsigned n = (unsigned)num;
-	return (n != 0) && 0 == (n & (n-1));
-}
-
-static test_work_t * create_child(test_work_t *work)
+	return (n != 0) && 0 == (n & (n - 1));
+}
+
+static test_work_t *create_child(test_work_t *work)
 {
 	test_work_t *child = malloc(sizeof(test_work_t), 0);
@@ -168,5 +168,5 @@
 
 	TPRINTF("waves: %d, count_down: %d, total expected calls: %zu\n",
-		WAVES, COUNT, exp_call_cnt * WAVES);
+	    WAVES, COUNT, exp_call_cnt * WAVES);
 
 
@@ -179,6 +179,6 @@
 
 	for (int i = 0; i < WAVES; ++i) {
-		while (atomic_get(&call_cnt[i]) < exp_call_cnt
-			&& sleep_cnt < max_sleep_cnt) {
+		while (atomic_get(&call_cnt[i]) < exp_call_cnt &&
+		    sleep_cnt < max_sleep_cnt) {
 			TPRINTF(".");
 			thread_usleep(MAIN_POLL_SLEEP_MS * 1000);
@@ -192,9 +192,9 @@
 		if (atomic_get(&call_cnt[i]) == exp_call_cnt) {
 			TPRINTF("Ok: %" PRIua " calls in wave %d, as expected.\n",
-				atomic_get(&call_cnt[i]), i);
+			    atomic_get(&call_cnt[i]), i);
 		} else {
 			success = false;
 			TPRINTF("Error: %" PRIua " calls in wave %d, but %zu expected.\n",
-				atomic_get(&call_cnt[i]), i, exp_call_cnt);
+			    atomic_get(&call_cnt[i]), i, exp_call_cnt);
 		}
 	}