Index: kernel/generic/src/synch/futex.c
===================================================================
--- kernel/generic/src/synch/futex.c	(revision 0a4667a7217b35601fca829679372413479e2c30)
+++ kernel/generic/src/synch/futex.c	(revision 3bacee1839e6f355100ab4ea86bb211e9ecf19ed)
@@ -171,5 +171,5 @@
 		/* Invoke the blocking cht_destroy in the background. */
 		workq_global_enqueue_noblock(&task->futexes->destroy_work,
-			destroy_task_cache);
+		    destroy_task_cache);
 	} else {
 		/* We can block. Invoke cht_destroy in this thread. */
@@ -182,5 +182,5 @@
 {
 	struct futex_cache *cache =
-		member_to_inst(work, struct futex_cache, destroy_work);
+	    member_to_inst(work, struct futex_cache, destroy_work);
 
 	/*
@@ -319,6 +319,6 @@
 
 	if (futex_ptr_link) {
-		futex_ptr_t *futex_ptr
-			= member_to_inst(futex_ptr_link, futex_ptr_t, cht_link);
+		futex_ptr_t *futex_ptr =
+		    member_to_inst(futex_ptr_link, futex_ptr_t, cht_link);
 
 		futex = futex_ptr->futex;
@@ -485,5 +485,5 @@
 static size_t task_fut_ht_key_hash(void *key)
 {
-	return *(uintptr_t*)key;
+	return *(uintptr_t *)key;
 }
 
@@ -499,5 +499,5 @@
 {
 	const futex_ptr_t *fut_ptr = member_to_inst(item, futex_ptr_t, cht_link);
-	uintptr_t uaddr = *(uintptr_t*)key;
+	uintptr_t uaddr = *(uintptr_t *)key;
 
 	return fut_ptr->uaddr == uaddr;
Index: kernel/generic/src/synch/workqueue.c
===================================================================
--- kernel/generic/src/synch/workqueue.c	(revision 0a4667a7217b35601fca829679372413479e2c30)
+++ kernel/generic/src/synch/workqueue.c	(revision 3bacee1839e6f355100ab4ea86bb211e9ecf19ed)
@@ -133,5 +133,5 @@
 static void wait_for_workers(struct work_queue *workq);
 static int _workq_enqueue(struct work_queue *workq, work_t *work_item,
-	work_func_t func, bool can_block);
+    work_func_t func, bool can_block);
 static void init_work_item(work_t *work_item, work_func_t func);
 static signal_op_t signal_worker_logic(struct work_queue *workq, bool can_block);
@@ -185,5 +185,5 @@
 
 /** Creates and initializes a work queue. Returns NULL upon failure. */
-struct work_queue * workq_create(const char *name)
+struct work_queue *workq_create(const char *name)
 {
 	struct work_queue *workq = malloc(sizeof(struct work_queue), 0);
@@ -269,5 +269,5 @@
 
 	thread_t *thread = thread_create(worker_thread, workq, TASK,
-		THREAD_FLAG_NONE, workq->name);
+	    THREAD_FLAG_NONE, workq->name);
 
 	if (!thread) {
@@ -428,5 +428,5 @@
  */
 bool workq_enqueue_noblock(struct work_queue *workq, work_t *work_item,
-	work_func_t func)
+    work_func_t func)
 {
 	return _workq_enqueue(workq, work_item, func, false);
@@ -473,5 +473,5 @@
  */
 static int _workq_enqueue(struct work_queue *workq, work_t *work_item,
-	work_func_t func, bool can_block)
+    work_func_t func, bool can_block)
 {
 	assert(!workq_corrupted(workq));
@@ -614,5 +614,5 @@
 
 		size_t remaining_idle =
-			workq->idle_worker_cnt - workq->activate_pending;
+		    workq->idle_worker_cnt - workq->activate_pending;
 
 		/* Idle workers still exist - activate one. */
@@ -628,6 +628,6 @@
 		} else {
 			/* No idle workers remain. Request that a new one be created. */
-			bool need_worker = (active < max_concurrent_workers)
-				&& (workq->cur_worker_cnt < max_worker_cnt);
+			bool need_worker = (active < max_concurrent_workers) &&
+			    (workq->cur_worker_cnt < max_worker_cnt);
 
 			if (need_worker && can_block) {
@@ -780,5 +780,5 @@
 
 	_condvar_wait_timeout_irq_spinlock(&workq->activate_worker,
-		&workq->lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
+	    &workq->lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
 
 	assert(!workq_corrupted(workq));
@@ -855,28 +855,27 @@
 	bool worker_surplus = worker_unnecessary(workq);
 	const char *load_str = worker_surplus ? "decreasing" :
-		(0 < workq->activate_pending) ? "increasing" : "stable";
+	    (0 < workq->activate_pending) ? "increasing" : "stable";
 
 	irq_spinlock_unlock(&workq->lock, true);
 
 	printf(
-		"Configuration: max_worker_cnt=%zu, min_worker_cnt=%zu,\n"
-		" max_concurrent_workers=%zu, max_items_per_worker=%zu\n"
-		"Workers: %zu\n"
-		"Active:  %zu (workers currently processing work)\n"
-		"Blocked: %zu (work functions sleeping/blocked)\n"
-		"Idle:    %zu (idle workers waiting for more work)\n"
-		"Items:   %zu (queued not yet dispatched work)\n"
-		"Stopping: %d\n"
-		"Load: %s\n",
-		max_worker_cnt, min_worker_cnt,
-		max_concurrent_workers, max_items_per_worker,
-		total,
-		active,
-		blocked,
-		idle,
-		items,
-		stopping,
-		load_str
-	);
+	    "Configuration: max_worker_cnt=%zu, min_worker_cnt=%zu,\n"
+	    " max_concurrent_workers=%zu, max_items_per_worker=%zu\n"
+	    "Workers: %zu\n"
+	    "Active:  %zu (workers currently processing work)\n"
+	    "Blocked: %zu (work functions sleeping/blocked)\n"
+	    "Idle:    %zu (idle workers waiting for more work)\n"
+	    "Items:   %zu (queued not yet dispatched work)\n"
+	    "Stopping: %d\n"
+	    "Load: %s\n",
+	    max_worker_cnt, min_worker_cnt,
+	    max_concurrent_workers, max_items_per_worker,
+	    total,
+	    active,
+	    blocked,
+	    idle,
+	    items,
+	    stopping,
+	    load_str);
 }
 
@@ -896,5 +895,5 @@
 	while (list_empty(&info->work_queues) && !stop) {
 		errno_t ret = _condvar_wait_timeout_irq_spinlock(&info->req_cv,
-			&info->lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_INTERRUPTIBLE);
+		    &info->lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_INTERRUPTIBLE);
 
 		stop = (ret == EINTR);
@@ -903,5 +902,5 @@
 	if (!stop) {
 		*pworkq = list_get_instance(list_first(&info->work_queues),
-			struct work_queue, nb_link);
+		    struct work_queue, nb_link);
 
 		assert(!workq_corrupted(*pworkq));
@@ -933,5 +932,5 @@
 
 	nonblock_adder.thread = thread_create(thr_nonblock_add_worker,
-		&nonblock_adder, TASK, THREAD_FLAG_NONE, "kworkq-nb");
+	    &nonblock_adder, TASK, THREAD_FLAG_NONE, "kworkq-nb");
 
 	if (nonblock_adder.thread) {