Index: kernel/test/synch/rcu1.c
===================================================================
--- kernel/test/synch/rcu1.c	(revision b7fd2a02e4161f4edd38548e7f8456b8021549be)
+++ kernel/test/synch/rcu1.c	(revision 1b20da07baaa3e3c424f62c927274e676e4295cd)
@@ -82,5 +82,5 @@
 	assert(thread[k] == NULL);
 	
-	thread[k] = thread_create(func, arg, TASK, THREAD_FLAG_NONE, 
+	thread[k] = thread_create(func, arg, TASK, THREAD_FLAG_NONE,
 		"test-rcu-thread");
 		
@@ -223,5 +223,5 @@
 	get_seq(10, 1000 * 1000, get_thread_cnt(), seq);
 	
-	TPRINTF("\nRun %zu thr: repeat long reader sections, will preempt, no cbs.\n", 
+	TPRINTF("\nRun %zu thr: repeat long reader sections, will preempt, no cbs.\n",
 		get_thread_cnt());
 	
@@ -273,5 +273,5 @@
 	size_t max_used_mem = sizeof(rcu_item_t) * exp_cnt;
 	
-	TPRINTF("\nRun %zu thr: post %zu no-op callbacks (%zu B used), no readers.\n", 
+	TPRINTF("\nRun %zu thr: post %zu no-op callbacks (%zu B used), no readers.\n",
 		get_thread_cnt(), exp_cnt, max_used_mem);
 	
@@ -414,5 +414,5 @@
 			rcu_read_unlock();
 			
-			if (seq_test_result != EOK) 
+			if (seq_test_result != EOK)
 				return;
 		}
@@ -476,5 +476,5 @@
 	
 	TPRINTF("\nRun %zu th: check callback completion time in readers. "
-		"%zu callbacks total (max %" PRIu64 " %s used). Be patient.\n", 
+		"%zu callbacks total (max %" PRIu64 " %s used). Be patient.\n",
 		get_thread_cnt(), total_cbs, mem_units, mem_suffix);
 	
@@ -490,5 +490,5 @@
 	} else if (seq_test_result == ERACE) {
 		TPRINTF("\nERROR: race detected!!\n");
-	} 
+	}
 	
 	return seq_test_result == EOK;
@@ -531,5 +531,5 @@
 	p->exited = false;
 	
-	run_one(reader_exit, p);	
+	run_one(reader_exit, p);
 	join_one();
 	
@@ -575,6 +575,6 @@
 	rcu_read_unlock();
 
-	/* 
-	 * Start GP after exiting reader section w/ preemption. 
+	/*
+	 * Start GP after exiting reader section w/ preemption.
 	 * Just check that the callback does not lock up and is not lost.
 	 */
@@ -590,7 +590,7 @@
 	
 	TPRINTF("reader_inside_cur{ ");
-	/* 
-	 * Start a GP and try to finish the reader before 
-	 * the GP ends (including preemption). 
+	/*
+	 * Start a GP and try to finish the reader before
+	 * the GP ends (including preemption).
 	 */
 	rcu_call(&p->e.rcu, preempted_unlocked);
@@ -667,6 +667,6 @@
 	rcu_call(&p->e.rcu, preempted_unlocked);
 
-	/* 
-	 * Preempt twice while GP is running after we've been known 
+	/*
+	 * Preempt twice while GP is running after we've been known
 	 * to hold up the GP just to make sure multiple preemptions
 	 * are properly tracked if a reader is delaying the cur GP.
@@ -695,5 +695,5 @@
 	p->result = EOK;
 	
-	run_one(f, p);	
+	run_one(f, p);
 	join_one();
 	
@@ -718,21 +718,21 @@
 	bool ok = true;
 	
-	ok = do_one_reader_preempt(preempted_reader_prev, 
+	ok = do_one_reader_preempt(preempted_reader_prev,
 		"Err: preempted_reader_prev()\n");
 	success = success && ok;
 	
-	ok = do_one_reader_preempt(preempted_reader_inside_cur, 
+	ok = do_one_reader_preempt(preempted_reader_inside_cur,
 		"Err: preempted_reader_inside_cur()\n");
 	success = success && ok;
 	
-	ok = do_one_reader_preempt(preempted_reader_cur, 
+	ok = do_one_reader_preempt(preempted_reader_cur,
 		"Err: preempted_reader_cur()\n");
 	success = success && ok;
 	
-	ok = do_one_reader_preempt(preempted_reader_next1, 
+	ok = do_one_reader_preempt(preempted_reader_next1,
 		"Err: preempted_reader_next1()\n");
 	success = success && ok;
 
-	ok = do_one_reader_preempt(preempted_reader_next2, 
+	ok = do_one_reader_preempt(preempted_reader_next2,
 		"Err: preempted_reader_next2()\n");
 	success = success && ok;
@@ -788,5 +788,5 @@
 	synch->synch_running = false;
 	
-	run_one(synch_reader, synch);	
+	run_one(synch_reader, synch);
 	
 	/* Wait for the reader to enter its critical section. */
@@ -866,5 +866,5 @@
 		rcu_read_unlock();
 		
-		/* 
+		/*
 		 * Do some work outside of the reader section so we are not always
 		 * preempted in the reader section.
@@ -905,6 +905,6 @@
 	size_t cb_per_thread = 1000 * 1000;
 	bool done = false;
-	stress_t master = { .iters = cb_per_thread, .master = true }; 
-	stress_t worker = { .iters = cb_per_thread, .master = false }; 
+	stress_t master = { .iters = cb_per_thread, .master = true };
+	stress_t worker = { .iters = cb_per_thread, .master = false };
 	
 	size_t thread_cnt = min(MAX_THREADS / 2, config.cpu_active);
@@ -921,5 +921,5 @@
 
 	TPRINTF("\nStress: Run %zu nop-readers and %zu updaters. %zu callbacks"
-		" total (max %" PRIu64 " %s used). Be very patient.\n", 
+		" total (max %" PRIu64 " %s used). Be very patient.\n",
 		reader_cnt, updater_cnt, exp_upd_calls, mem_units, mem_suffix);
 	
@@ -1044,11 +1044,11 @@
 		completed_gps += delta_gps;
 
-		if (ok) {  
-			TPRINTF("\nSubtest %s() ok (GPs: %" PRIu64 ").\n", 
+		if (ok) {
+			TPRINTF("\nSubtest %s() ok (GPs: %" PRIu64 ").\n",
 				test_func[i].desc, delta_gps);
 		} else {
 			TPRINTF("\nFailed: %s(). Pausing for 5 secs.\n", test_func[i].desc);
 			thread_sleep(5);
-		} 
+		}
 	}
 
Index: kernel/test/synch/semaphore2.c
===================================================================
--- kernel/test/synch/semaphore2.c	(revision b7fd2a02e4161f4edd38548e7f8456b8021549be)
+++ kernel/test/synch/semaphore2.c	(revision 1b20da07baaa3e3c424f62c927274e676e4295cd)
@@ -75,5 +75,5 @@
 	}
 	
-	TPRINTF("cpu%u, tid %" PRIu64 " down=\n", CPU->id, THREAD->tid);	
+	TPRINTF("cpu%u, tid %" PRIu64 " down=\n", CPU->id, THREAD->tid);
 	thread_usleep(random(30000));
 	
Index: kernel/test/synch/workq-test-core.h
===================================================================
--- kernel/test/synch/workq-test-core.h	(revision b7fd2a02e4161f4edd38548e7f8456b8021549be)
+++ kernel/test/synch/workq-test-core.h	(revision 1b20da07baaa3e3c424f62c927274e676e4295cd)
@@ -111,7 +111,7 @@
 		--work->count_down;
 
-		/* 
-		 * Enqueue a child if count_down is power-of-2. 
-		 * Leads to exponential growth. 
+		/*
+		 * Enqueue a child if count_down is power-of-2.
+		 * Leads to exponential growth.
 		 */
 		if (is_pow2(work->count_down + 1)) {
@@ -124,5 +124,5 @@
 		
 		if (!core_workq_enqueue(work_item, reproduce)) {
-			if (work->master) 
+			if (work->master)
 				TPRINTF("\nErr: Master work item exiting prematurely!\n");
 
@@ -161,5 +161,5 @@
 	 * k == COUNT_POW
 	 * 2^k == COUNT + 1
-	 * 
+	 *
 	 * We have "k" branching points. Therefore:
 	 * exp_call_cnt == k*2^(k-1) + 2^k == (k + 2) * 2^(k-1)
@@ -167,5 +167,5 @@
 	size_t exp_call_cnt = (COUNT_POW + 2) * (1 << (COUNT_POW - 1));
 	
-	TPRINTF("waves: %d, count_down: %d, total expected calls: %zu\n", 
+	TPRINTF("waves: %d, count_down: %d, total expected calls: %zu\n",
 		WAVES, COUNT, exp_call_cnt * WAVES);
 	
@@ -179,5 +179,5 @@
 	
 	for (int i = 0; i < WAVES; ++i) {
-		while (atomic_get(&call_cnt[i]) < exp_call_cnt 
+		while (atomic_get(&call_cnt[i]) < exp_call_cnt
 			&& sleep_cnt < max_sleep_cnt) {
 			TPRINTF(".");
@@ -197,5 +197,5 @@
 			TPRINTF("Error: %" PRIua " calls in wave %d, but %zu expected.\n",
 				atomic_get(&call_cnt[i]), i, exp_call_cnt);
-		} 
+		}
 	}
 	
Index: kernel/test/synch/workqueue3.c
===================================================================
--- kernel/test/synch/workqueue3.c	(revision b7fd2a02e4161f4edd38548e7f8456b8021549be)
+++ kernel/test/synch/workqueue3.c	(revision 1b20da07baaa3e3c424f62c927274e676e4295cd)
@@ -63,5 +63,5 @@
 		TPRINTF("\nSecond run:\n");
 		err = run_workq_core(exit_early);
-	} 
+	}
 
 	TPRINTF("Done.\n");