Index: kernel/test/synch/rcu1.c
===================================================================
--- kernel/test/synch/rcu1.c	(revision 1433ecda9b732f3f185f902feb26826ec2496e03)
+++ kernel/test/synch/rcu1.c	(revision 1cac8753dba1dcd1e470087cba35d1d4f93975a2)
@@ -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 1cac8753dba1dcd1e470087cba35d1d4f93975a2)
@@ -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);
 		}
 	}