Index: uspace/app/devctl/devctl.c
===================================================================
--- uspace/app/devctl/devctl.c	(revision 5df19638ae7b362a07b4f8c7b1647a3adcb53862)
+++ uspace/app/devctl/devctl.c	(revision 0511549e4d68f82dd21b841151e3de85adcf56ee)
@@ -159,7 +159,34 @@
 }
 
+static int drv_list(void)
+{
+	devman_handle_t *drvs;
+	size_t ndrvs;
+	size_t i;
+	int rc;
+
+	rc = devman_get_drivers(&drvs, &ndrvs);
+	if (rc != EOK)
+		return rc;
+
+	printf("Got %d handles\n", ndrvs);
+	for (i = 0; i < ndrvs; i++) {
+		rc = devman_driver_get_name(drvs[i], drv_name, MAX_NAME_LENGTH);
+		if (rc != EOK)
+			continue;
+		printf("%3d %s\n", (int)drvs[i], drv_name);
+	}
+	free(drvs);
+
+	return EOK;
+}
+
 static void print_syntax(void)
 {
-	printf("syntax: devctl [(online|offline) <function>]\n");
+	printf("syntax:\n");
+	printf("\tdevctl\n");
+	printf("\tdevctl online <function>]\n");
+	printf("\tdevctl offline <function>]\n");
+	printf("\tdevctl list-drv\n");
 }
 
@@ -194,4 +221,8 @@
 			return 2;
 		}
+	} else if (str_cmp(argv[1], "list-drv") == 0) {
+		rc = drv_list();
+		if (rc != EOK)
+			return 2;
 	} else {
 		printf(NAME ": Invalid argument '%s'.\n", argv[1]);
Index: uspace/lib/c/generic/devman.c
===================================================================
--- uspace/lib/c/generic/devman.c	(revision 5df19638ae7b362a07b4f8c7b1647a3adcb53862)
+++ uspace/lib/c/generic/devman.c	(revision 0511549e4d68f82dd21b841151e3de85adcf56ee)
@@ -592,4 +592,16 @@
 }
 
+int devman_get_drivers(devman_handle_t **drvs,
+    size_t *count)
+{
+	return devman_get_handles_internal(DEVMAN_GET_DRIVERS, 0, drvs, count);
+}
+
+int devman_driver_get_name(devman_handle_t handle, char *buf, size_t buf_size)
+{
+	return devman_get_str_internal(DEVMAN_DRIVER_GET_NAME, handle, buf,
+	    buf_size);
+}
+
 /** @}
  */
Index: uspace/lib/c/include/devman.h
===================================================================
--- uspace/lib/c/include/devman.h	(revision 5df19638ae7b362a07b4f8c7b1647a3adcb53862)
+++ uspace/lib/c/include/devman.h	(revision 0511549e4d68f82dd21b841151e3de85adcf56ee)
@@ -71,4 +71,6 @@
 extern int devman_add_device_to_category(devman_handle_t, const char *);
 extern int devman_fun_sid_to_handle(service_id_t, devman_handle_t *);
+extern int devman_get_drivers(devman_handle_t **, size_t *);
+extern int devman_driver_get_name(devman_handle_t, char *, size_t);
 
 #endif
Index: uspace/lib/c/include/ipc/devman.h
===================================================================
--- uspace/lib/c/include/ipc/devman.h	(revision 5df19638ae7b362a07b4f8c7b1647a3adcb53862)
+++ uspace/lib/c/include/ipc/devman.h	(revision 0511549e4d68f82dd21b841151e3de85adcf56ee)
@@ -161,5 +161,7 @@
 	DEVMAN_FUN_OFFLINE,
 	DEVMAN_FUN_GET_PATH,
-	DEVMAN_FUN_SID_TO_HANDLE
+	DEVMAN_FUN_SID_TO_HANDLE,
+	DEVMAN_GET_DRIVERS,
+	DEVMAN_DRIVER_GET_NAME
 } client_to_devman_t;
 
Index: uspace/srv/devman/client_conn.c
===================================================================
--- uspace/srv/devman/client_conn.c	(revision 5df19638ae7b362a07b4f8c7b1647a3adcb53862)
+++ uspace/srv/devman/client_conn.c	(revision 0511549e4d68f82dd21b841151e3de85adcf56ee)
@@ -317,5 +317,4 @@
 }
 
-
 /** Get handle for child device of a function. */
 static void devman_fun_get_child(ipc_callid_t iid, ipc_call_t *icall)
@@ -417,4 +416,78 @@
 }
 
+/** Get list of all registered drivers. */
+static void devman_get_drivers(ipc_callid_t iid, ipc_call_t *icall)
+{
+	ipc_callid_t callid;
+	size_t size;
+	size_t act_size;
+	int rc;
+	
+	if (!async_data_read_receive(&callid, &size)) {
+		async_answer_0(callid, EREFUSED);
+		async_answer_0(iid, EREFUSED);
+		return;
+	}
+	
+	devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
+	if (hdl_buf == NULL) {
+		async_answer_0(callid, ENOMEM);
+		async_answer_0(iid, ENOMEM);
+		return;
+	}
+	
+	rc = driver_get_list(&drivers_list, hdl_buf, size, &act_size);
+	if (rc != EOK) {
+		async_answer_0(callid, rc);
+		async_answer_0(iid, rc);
+		return;
+	}
+	
+	sysarg_t retval = async_data_read_finalize(callid, hdl_buf, size);
+	free(hdl_buf);
+	
+	async_answer_1(iid, retval, act_size);
+}
+
+/** Get driver name. */
+static void devman_driver_get_name(ipc_callid_t iid, ipc_call_t *icall)
+{
+	devman_handle_t handle = IPC_GET_ARG1(*icall);
+
+	driver_t *drv = driver_find(&drivers_list, handle);
+	if (drv == NULL) {
+		async_answer_0(iid, ENOMEM);
+		return;
+	}
+
+	ipc_callid_t data_callid;
+	size_t data_len;
+	if (!async_data_read_receive(&data_callid, &data_len)) {
+		async_answer_0(iid, EINVAL);
+		return;
+	}
+
+	void *buffer = malloc(data_len);
+	if (buffer == NULL) {
+		async_answer_0(data_callid, ENOMEM);
+		async_answer_0(iid, ENOMEM);
+		return;
+	}
+
+	fibril_mutex_lock(&drv->driver_mutex);
+
+	size_t sent_length = str_size(drv->name);
+	if (sent_length > data_len) {
+		sent_length = data_len;
+	}
+
+	async_data_read_finalize(data_callid, drv->name, sent_length);
+	async_answer_0(iid, EOK);
+
+	fibril_mutex_unlock(&drv->driver_mutex);
+
+	free(buffer);
+}
+
 /** Function for handling connections from a client to the device manager. */
 void devman_connection_client(ipc_callid_t iid, ipc_call_t *icall)
@@ -441,4 +514,5 @@
 			break;
 		case DEVMAN_FUN_GET_NAME:
+			printf("devman_fun_get_name\n");
 			devman_fun_get_name(callid, &call);
 			break;
@@ -457,4 +531,11 @@
 		case DEVMAN_FUN_SID_TO_HANDLE:
 			devman_fun_sid_to_handle(callid, &call);
+			break;
+		case DEVMAN_GET_DRIVERS:
+			devman_get_drivers(callid, &call);
+			break;
+		case DEVMAN_DRIVER_GET_NAME:
+			printf("devman_get_driver_name\n");
+			devman_driver_get_name(callid, &call);
 			break;
 		default:
Index: uspace/srv/devman/devman.h
===================================================================
--- uspace/srv/devman/devman.h	(revision 5df19638ae7b362a07b4f8c7b1647a3adcb53862)
+++ uspace/srv/devman/devman.h	(revision 0511549e4d68f82dd21b841151e3de85adcf56ee)
@@ -80,4 +80,6 @@
 	/** Pointers to previous and next drivers in a linked list. */
 	link_t drivers;
+	/** Handle */
+	devman_handle_t handle;
 	
 	/**
@@ -110,4 +112,6 @@
 	/** Fibril mutex for list of drivers. */
 	fibril_mutex_t drivers_mutex;
+	/** Next free handle */
+	devman_handle_t next_handle;
 } driver_list_t;
 
Index: uspace/srv/devman/driver.c
===================================================================
--- uspace/srv/devman/driver.c	(revision 5df19638ae7b362a07b4f8c7b1647a3adcb53862)
+++ uspace/srv/devman/driver.c	(revision 0511549e4d68f82dd21b841151e3de85adcf56ee)
@@ -58,4 +58,5 @@
 	list_initialize(&drv_list->drivers);
 	fibril_mutex_initialize(&drv_list->drivers_mutex);
+	drv_list->next_handle = 1;
 }
 
@@ -81,4 +82,5 @@
 	fibril_mutex_lock(&drivers_list->drivers_mutex);
 	list_prepend(&drv->drivers, &drivers_list->drivers);
+	drv->handle = drivers_list->next_handle++;
 	fibril_mutex_unlock(&drivers_list->drivers_mutex);
 
@@ -299,5 +301,31 @@
 }
 
-/** Find device driver in the list of device drivers.
+/** Find device driver by handle.
+ *
+ * @param drv_list	The list of device drivers
+ * @param handle	Driver handle
+ * @return		The device driver, if it is in the list,
+ *			NULL otherwise.
+ */
+driver_t *driver_find(driver_list_t *drv_list, devman_handle_t handle)
+{
+	driver_t *res = NULL;
+	
+	fibril_mutex_lock(&drv_list->drivers_mutex);
+	
+	list_foreach(drv_list->drivers, drivers, driver_t, drv) {
+		if (drv->handle == handle) {
+			res = drv;
+			break;
+		}
+	}
+	
+	fibril_mutex_unlock(&drv_list->drivers_mutex);
+	
+	return res;
+}
+
+
+/** Find device driver by name.
  *
  * @param drv_list	The list of device drivers.
@@ -306,5 +334,5 @@
  *			list, NULL otherwise.
  */
-driver_t *find_driver(driver_list_t *drv_list, const char *drv_name)
+driver_t *driver_find_by_name(driver_list_t *drv_list, const char *drv_name)
 {
 	driver_t *res = NULL;
@@ -669,4 +697,36 @@
 }
 
+/** Get list of registered drivers. */
+int driver_get_list(driver_list_t *driver_list, devman_handle_t *hdl_buf,
+    size_t buf_size, size_t *act_size)
+{
+	size_t act_cnt;
+	size_t buf_cnt;
+
+	fibril_mutex_lock(&driver_list->drivers_mutex);
+
+	buf_cnt = buf_size / sizeof(devman_handle_t);
+
+	act_cnt = list_count(&driver_list->drivers);
+	*act_size = act_cnt * sizeof(devman_handle_t);
+
+	if (buf_size % sizeof(devman_handle_t) != 0) {
+		fibril_mutex_unlock(&driver_list->drivers_mutex);
+		return EINVAL;
+	}
+
+	size_t pos = 0;
+	list_foreach(driver_list->drivers, drivers, driver_t, drv) {
+		if (pos < buf_cnt) {
+			hdl_buf[pos] = drv->handle;
+		}
+
+		pos++;
+	}
+
+	fibril_mutex_unlock(&driver_list->drivers_mutex);
+	return EOK;
+}
+
 /** @}
  */
Index: uspace/srv/devman/driver.h
===================================================================
--- uspace/srv/devman/driver.h	(revision 5df19638ae7b362a07b4f8c7b1647a3adcb53862)
+++ uspace/srv/devman/driver.h	(revision 0511549e4d68f82dd21b841151e3de85adcf56ee)
@@ -56,5 +56,6 @@
 extern int driver_fun_offline(dev_tree_t *, fun_node_t *);
 
-extern driver_t *find_driver(driver_list_t *, const char *);
+extern driver_t *driver_find(driver_list_t *, devman_handle_t);
+extern driver_t *driver_find_by_name(driver_list_t *, const char *);
 extern void initialize_running_driver(driver_t *, dev_tree_t *);
 
@@ -62,4 +63,5 @@
 extern void clean_driver(driver_t *);
 extern void delete_driver(driver_t *);
+extern int driver_get_list(driver_list_t *, devman_handle_t *, size_t, size_t *);
 
 #endif
Index: uspace/srv/devman/drv_conn.c
===================================================================
--- uspace/srv/devman/drv_conn.c	(revision 5df19638ae7b362a07b4f8c7b1647a3adcb53862)
+++ uspace/srv/devman/drv_conn.c	(revision 0511549e4d68f82dd21b841151e3de85adcf56ee)
@@ -83,5 +83,5 @@
 	
 	/* Find driver structure. */
-	driver = find_driver(&drivers_list, drv_name);
+	driver = driver_find_by_name(&drivers_list, drv_name);
 	if (driver == NULL) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "No driver named `%s' was found.", drv_name);