Index: kernel/generic/include/udebug/udebug.h
===================================================================
--- kernel/generic/include/udebug/udebug.h	(revision 0d21b534cf29b9b695f324a08426ec17d8c12aa5)
+++ kernel/generic/include/udebug/udebug.h	(revision e515b21a3fde67534b9cb58f7237e854904ccba2)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup generic	
+/** @addtogroup generic
  * @{
  */
@@ -83,4 +83,15 @@
 UDEBUG_M_ARGS_READ,
 
+/** Read thread's userspace register state (istate_t).
+ *
+ * - ARG2 - thread identification
+ * - ARG3 - destination address in the caller's address space
+ *
+ * or, on error, retval will be
+ * - ENOENT - thread does not exist
+ * - EBUSY - register state not available
+ */
+UDEBUG_M_REGS_READ,
+
 /** Read the list of the debugged tasks's threads.
  *
@@ -122,5 +133,5 @@
 } udebug_method_t;
 
-				
+
 typedef enum {
 	UDEBUG_EVENT_FINISHED = 1,	/**< Debuging session has finished */
Index: kernel/generic/include/udebug/udebug_ops.h
===================================================================
--- kernel/generic/include/udebug/udebug_ops.h	(revision 0d21b534cf29b9b695f324a08426ec17d8c12aa5)
+++ kernel/generic/include/udebug/udebug_ops.h	(revision e515b21a3fde67534b9cb58f7237e854904ccba2)
@@ -49,4 +49,6 @@
 int udebug_args_read(thread_t *t, void **buffer);
 
+int udebug_regs_read(thread_t *t, void **buffer);
+
 int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer);
 
Index: kernel/generic/src/udebug/udebug_ipc.c
===================================================================
--- kernel/generic/src/udebug/udebug_ipc.c	(revision 0d21b534cf29b9b695f324a08426ec17d8c12aa5)
+++ kernel/generic/src/udebug/udebug_ipc.c	(revision e515b21a3fde67534b9cb58f7237e854904ccba2)
@@ -287,4 +287,45 @@
 	ipc_answer(&TASK->kb.box, call);
 }
+
+/** Receive a REGS_READ call.
+ *
+ * Reads the thread's register state (istate structure).
+ */
+static void udebug_receive_regs_read(call_t *call)
+{
+	thread_t *t;
+	unative_t uspace_addr;
+	unative_t to_copy;
+	void *buffer;
+	int rc;
+
+	t = (thread_t *) IPC_GET_ARG2(call->data);
+
+	rc = udebug_regs_read(t, &buffer);
+	if (rc < 0) {
+		IPC_SET_RETVAL(call->data, rc);
+		ipc_answer(&TASK->kb.box, call);
+		return;
+	}
+
+	/*
+	 * Make use of call->buffer to transfer data to caller's userspace
+	 */
+
+	uspace_addr = IPC_GET_ARG3(call->data);
+	to_copy = sizeof(istate_t);
+
+	IPC_SET_RETVAL(call->data, 0);
+	/* ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
+	   same code in process_answer() can be used 
+	   (no way to distinguish method in answer) */
+	IPC_SET_ARG1(call->data, uspace_addr);
+	IPC_SET_ARG2(call->data, to_copy);
+
+	call->buffer = buffer;
+
+	ipc_answer(&TASK->kb.box, call);
+}
+
 
 /** Process an MEM_READ call.
@@ -374,4 +415,7 @@
 		udebug_receive_args_read(call);
 		break;
+	case UDEBUG_M_REGS_READ:
+		udebug_receive_regs_read(call);
+		break;
 	case UDEBUG_M_MEM_READ:
 		udebug_receive_mem_read(call);
Index: kernel/generic/src/udebug/udebug_ops.c
===================================================================
--- kernel/generic/src/udebug/udebug_ops.c	(revision 0d21b534cf29b9b695f324a08426ec17d8c12aa5)
+++ kernel/generic/src/udebug/udebug_ops.c	(revision e515b21a3fde67534b9cb58f7237e854904ccba2)
@@ -449,5 +449,8 @@
  * this function will fail with an EINVAL error code.
  *
- * @param buffer	The buffer for storing thread hashes.
+ * @param t		Thread where call arguments are to be read.
+ * @param buffer	Place to store pointer to new buffer.
+ * @return		EOK on success, ENOENT if @a t is invalid, EINVAL
+ *			if thread state is not valid for this operation.
  */
 int udebug_args_read(thread_t *t, void **buffer)
@@ -481,4 +484,48 @@
 }
 
+/** Read the register state of the thread.
+ *
+ * The contents of the thread's istate structure are copied to a newly
+ * allocated buffer and a pointer to it is written to @a buffer. The size of
+ * the buffer will be sizeof(istate_t).
+ *
+ * Currently register state cannot be read if the thread is inside a system
+ * call (as opposed to an exception). This is an implementation limit.
+ *
+ * @param t		Thread whose state is to be read.
+ * @param buffer	Place to store pointer to new buffer.
+ * @return		EOK on success, ENOENT if @a t is invalid, EINVAL
+ *			if thread is not in valid state, EBUSY if istate
+ *			is not available.
+ */
+int udebug_regs_read(thread_t *t, void **buffer)
+{
+	istate_t *state, *state_buf;
+	int rc;
+
+	/* Prepare a buffer to hold the data. */
+	state_buf = malloc(sizeof(istate_t), 0);
+
+	/* On success, this will lock t->udebug.lock */
+	rc = _thread_op_begin(t, false);
+	if (rc != EOK) {
+		return rc;
+	}
+
+	state = t->udebug.uspace_state;
+	if (state == NULL) {
+		_thread_op_end(t);
+		return EBUSY;
+	}
+
+	/* Copy to the allocated buffer */
+	memcpy(state_buf, state, sizeof(istate_t));
+
+	_thread_op_end(t);
+
+	*buffer = (void *) state_buf;
+	return 0;
+}
+
 /** Read the memory of the debugged task.
  *