Index: kernel/generic/src/udebug/udebug.c
===================================================================
--- kernel/generic/src/udebug/udebug.c	(revision aa8d0f724e941934ba8a46d05e4ec1c71954987a)
+++ kernel/generic/src/udebug/udebug.c	(revision 1378b2bc1021b18bb8b0e27b71625f9a4bd5182c)
@@ -248,5 +248,5 @@
 
 		goto restart;
-		/* must try again - have to lose stoppability atomically */
+		/* Must try again - have to lose stoppability atomically. */
 	} else {
 		++TASK->udebug.not_stoppable_count;
@@ -322,5 +322,5 @@
 	mutex_lock(&THREAD->udebug.lock);
 
-	/* Must only generate events when in debugging session and have go */
+	/* Must only generate events when in debugging session and is go. */
 	if (THREAD->udebug.debug_active != true ||
 	    THREAD->udebug.stop == true ||
@@ -440,5 +440,5 @@
 	LOG("- check state\n");
 
-	/* Must only generate events when in debugging session */
+	/* Must only generate events when in debugging session. */
 	if (THREAD->udebug.debug_active != true) {
 /*		printf("- debug_active: %s, udebug.stop: %s\n",
@@ -457,5 +457,5 @@
 	IPC_SET_ARG1(call->data, UDEBUG_EVENT_THREAD_E);
 
-	/* Prevent any further debug activity in thread */
+	/* Prevent any further debug activity in thread. */
 	THREAD->udebug.debug_active = false;
 	THREAD->udebug.cur_event = 0;		/* none */
@@ -467,6 +467,6 @@
 	mutex_unlock(&TASK->udebug.lock);
 
-	/* Leave int_lock enabled */
-	/* This event does not sleep - debugging has finished in this thread */
+	/* Leave int_lock enabled. */
+	/* This event does not sleep - debugging has finished in this thread. */
 }
 
@@ -513,11 +513,11 @@
 		interrupts_restore(ipl);
 
-		/* Only process userspace threads */
+		/* Only process userspace threads. */
 		if ((flags & THREAD_FLAG_USPACE) != 0) {
-			/* Prevent any further debug activity in thread */
+			/* Prevent any further debug activity in thread. */
 			t->udebug.debug_active = false;
 			t->udebug.cur_event = 0;	/* none */
 
-			/* Still has go? */
+			/* Is the thread still go? */
 			if (t->udebug.stop == false) {
 				/*
Index: kernel/generic/src/udebug/udebug_ops.c
===================================================================
--- kernel/generic/src/udebug/udebug_ops.c	(revision aa8d0f724e941934ba8a46d05e4ec1c71954987a)
+++ kernel/generic/src/udebug/udebug_ops.c	(revision 1378b2bc1021b18bb8b0e27b71625f9a4bd5182c)
@@ -58,5 +58,5 @@
  * Specifically, verifies that thread t exists, is a userspace thread,
  * and belongs to the current task (TASK). Verifies, that the thread
- * has (or hasn't) go according to having_go (typically false).
+ * is (or is not) go according to being_go (typically false).
  * It also locks t->udebug.lock, making sure that t->udebug.debug_active
  * is true - that the thread is in a valid debugging session.
@@ -71,9 +71,9 @@
  *
  * @param t		Pointer, need not at all be valid.
- * @param having_go	Required thread state.
+ * @param being_go	Required thread state.
  *
  * Returns EOK if all went well, or an error code otherwise.
  */
-static int _thread_op_begin(thread_t *t, bool having_go)
+static int _thread_op_begin(thread_t *t, bool being_go)
 {
 	task_id_t taskid;
@@ -99,5 +99,5 @@
 	spinlock_unlock(&threads_lock);
 
-	/* Verify that 't' is a userspace thread */
+	/* Verify that 't' is a userspace thread. */
 	if ((t->flags & THREAD_FLAG_USPACE) == 0) {
 		/* It's not, deny its existence */
@@ -108,5 +108,5 @@
 	}
 
-	/* Verify debugging state */
+	/* Verify debugging state. */
 	if (t->udebug.debug_active != true) {
 		/* Not in debugging session or undesired GO state */
@@ -125,7 +125,7 @@
 	interrupts_restore(ipl);
 
-	/* Only mutex TASK->udebug.lock left */
+	/* Only mutex TASK->udebug.lock left. */
 	
-	/* Now verify that the thread belongs to the current task */
+	/* Now verify that the thread belongs to the current task. */
 	if (t->task != TASK) {
 		/* No such thread belonging this task*/
@@ -140,16 +140,16 @@
 	mutex_lock(&t->udebug.lock);
 
-	/* The big task mutex is no longer needed */
-	mutex_unlock(&TASK->udebug.lock);
-
-	if (!t->udebug.stop != having_go) {
-		/* Not in debugging session or undesired GO state */
+	/* The big task mutex is no longer needed. */
+	mutex_unlock(&TASK->udebug.lock);
+
+	if (!t->udebug.stop != being_go) {
+		/* Not in debugging session or undesired GO state. */
 		mutex_unlock(&t->udebug.lock);
 		return EINVAL;
 	}
 
-	/* Only t->udebug.lock left */
-
-	return EOK;	/* All went well */
+	/* Only t->udebug.lock left. */
+
+	return EOK;	/* All went well. */
 }
 
@@ -205,5 +205,5 @@
 	}
 	
-	/* Set udebug.debug_active on all of the task's userspace threads */
+	/* Set udebug.debug_active on all of the task's userspace threads. */
 
 	for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
@@ -274,5 +274,5 @@
 /** Give thread GO.
  *
- * Upon recieving a go message, the thread is given GO. Having GO
+ * Upon recieving a go message, the thread is given GO. Being GO
  * means the thread is allowed to execute userspace code (until
  * a debugging event or STOP occurs, at which point the thread loses GO.
@@ -285,5 +285,5 @@
 	int rc;
 
-	/* On success, this will lock t->udebug.lock */
+	/* On success, this will lock t->udebug.lock. */
 	rc = _thread_op_begin(t, false);
 	if (rc != EOK) {
@@ -296,5 +296,5 @@
 
 	/*
-	 * Neither t's lock nor threads_lock may be held during wakeup
+	 * Neither t's lock nor threads_lock may be held during wakeup.
 	 */
 	waitq_wakeup(&t->udebug.go_wq, WAKEUP_FIRST);
@@ -329,9 +329,9 @@
 	}
 
-	/* Take GO away from the thread */
+	/* Take GO away from the thread. */
 	t->udebug.stop = true;
 
 	if (!t->udebug.stoppable) {
-		/* Answer will be sent when the thread becomes stoppable */
+		/* Answer will be sent when the thread becomes stoppable. */
 		_thread_op_end(t);
 		return 0;
@@ -339,9 +339,9 @@
 
 	/*
-	 * Answer GO call
+	 * Answer GO call.
 	 */
 	LOG("udebug_stop - answering go call\n");
 
-	/* Make sure nobody takes this call away from us */
+	/* Make sure nobody takes this call away from us. */
 	call = t->udebug.go_call;
 	t->udebug.go_call = NULL;
@@ -423,5 +423,5 @@
 		spinlock_unlock(&t->lock);
 
-		/* Not interested in kernel threads */
+		/* Not interested in kernel threads. */
 		if ((flags & THREAD_FLAG_USPACE) != 0) {
 			/* Using thread struct pointer as identification hash */
@@ -459,8 +459,8 @@
 	unative_t *arg_buffer;
 
-	/* Prepare a buffer to hold the arguments */
+	/* Prepare a buffer to hold the arguments. */
 	arg_buffer = malloc(6 * sizeof(unative_t), 0);
 
-	/* On success, this will lock t->udebug.lock */
+	/* On success, this will lock t->udebug.lock. */
 	rc = _thread_op_begin(t, false);
 	if (rc != EOK) {
@@ -468,5 +468,5 @@
 	}
 
-	/* Additionally we need to verify that we are inside a syscall */
+	/* Additionally we need to verify that we are inside a syscall. */
 	if (t->udebug.cur_event != UDEBUG_EVENT_SYSCALL_B &&
 	    t->udebug.cur_event != UDEBUG_EVENT_SYSCALL_E) {
@@ -475,5 +475,5 @@
 	}
 
-	/* Copy to a local buffer before releasing the lock */
+	/* Copy to a local buffer before releasing the lock. */
 	memcpy(arg_buffer, t->udebug.syscall_args, 6 * sizeof(unative_t));