Index: abi/include/abi/ipc/interfaces.h
===================================================================
--- abi/include/abi/ipc/interfaces.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ abi/include/abi/ipc/interfaces.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -80,11 +80,99 @@
 typedef enum {
 	INTERFACE_LOADER =
-	    FOURCC_COMPACT('l', 'o', 'a', 'd') | IFACE_EXCHANGE_PARALLEL,
+	    FOURCC_COMPACT('l', 'o', 'a', 'd') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_LOGGER_WRITER =
+	    FOURCC_COMPACT('l', 'o', 'g', 'w') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_LOGGER_CONTROL =
+	    FOURCC_COMPACT('l', 'o', 'g', 'c') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_CORECFG =
+	    FOURCC_COMPACT('c', 'c', 'f', 'g') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_FS =
+	    FOURCC_COMPACT('f', 's', ' ', ' ') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_VFS =
+	    FOURCC_COMPACT('v', 'f', 's', ' ') | IFACE_EXCHANGE_PARALLEL,
+	INTERFACE_VFS_DRIVER =
+	    FOURCC_COMPACT('v', 'f', 's', 'd') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_VFS_DRIVER_CB =
+	    FOURCC_COMPACT('v', 'f', 's', 'd') | IFACE_EXCHANGE_PARALLEL | IFACE_MOD_CALLBACK,
+	INTERFACE_BLOCK =
+	    FOURCC_COMPACT('b', 'l', 'd', 'v') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_BLOCK_CB =
+	    FOURCC_COMPACT('b', 'l', 'd', 'v') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_CONSOLE =
+	    FOURCC_COMPACT('c', 'o', 'n', 's') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_INPUT =
+	    FOURCC_COMPACT('i', 'n', 'd', 'v') | IFACE_EXCHANGE_ATOMIC,
+	INTERFACE_INPUT_CB =
+	    FOURCC_COMPACT('i', 'n', 'd', 'v') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_OUTPUT =
+	    FOURCC_COMPACT('o', 'u', 'd', 'v') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_COMPOSITOR =
+	    FOURCC_COMPACT('c', 'm', 'p', 's') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_HOUND =
+	    FOURCC_COMPACT('h', 'o', 'u', 'n') | IFACE_EXCHANGE_PARALLEL,
+	INTERFACE_VISUALIZER_CB =
+	    FOURCC_COMPACT('v', 's', 'd', 'v') | IFACE_EXCHANGE_PARALLEL | IFACE_MOD_CALLBACK,
+	INTERFACE_LOC_SUPPLIER =
+	    FOURCC_COMPACT('l', 'o', 'c', 's') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_LOC_CONSUMER =
+	    FOURCC_COMPACT('l', 'o', 'c', 'c') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_LOC_CB =
+	    FOURCC_COMPACT('l', 'o', 'c', ' ') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_DEVMAN_DEVICE =
+	    FOURCC_COMPACT('d', 'v', 'd', 'v') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_DEVMAN_PARENT =
+	    FOURCC_COMPACT('d', 'v', 'p', 't') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_IRC =
+	    FOURCC_COMPACT('i', 'r', 'c', ' ') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_DDF =
+	    FOURCC_COMPACT('d', 'd', 'f', ' ') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_DDF_DEVMAN =
+	    FOURCC_COMPACT('d', 'd', 'f', 'm') | IFACE_EXCHANGE_SERIALIZE,
 	INTERFACE_DDF_CLIENT =
 	    FOURCC_COMPACT('d', 'd', 'f', 'c') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_DDF_DRIVER =
+	    FOURCC_COMPACT('d', 'd', 'f', 'd') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_INET =
+	    FOURCC_COMPACT('i', 'n', 'e', 't') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_INET_CB =
+	    FOURCC_COMPACT('i', 'n', 'e', 't') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_INETCFG =
+	    FOURCC_COMPACT('i', 'c', 'f', 'g') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_INETPING =
+	    FOURCC_COMPACT('i', 'p', 'n', 'g') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_INETPING_CB =
+	    FOURCC_COMPACT('i', 'p', 'n', 'g') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_DHCP =
+	    FOURCC_COMPACT('d', 'h', 'c', 'p') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_DNSR =
+	    FOURCC_COMPACT('d', 'n', 's', 'r') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_IPLINK =
+	    FOURCC_COMPACT('i', 'p', 'l', 'k') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_IPLINK_CB =
+	    FOURCC_COMPACT('i', 'p', 'l', 'k') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_TCP =
+	    FOURCC_COMPACT('t', 'c', 'p', ' ') | IFACE_EXCHANGE_SERIALIZE,
 	INTERFACE_TCP_CB =
 	    FOURCC_COMPACT('t', 'c', 'p', ' ') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_UDP =
+	    FOURCC_COMPACT('u', 'd', 'p', ' ') | IFACE_EXCHANGE_SERIALIZE,
 	INTERFACE_UDP_CB =
-	    FOURCC_COMPACT('u', 'd', 'p', ' ') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK
+	    FOURCC_COMPACT('u', 'd', 'p', ' ') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_CLIPBOARD =
+	    FOURCC_COMPACT('c', 'l', 'i', 'p') | IFACE_EXCHANGE_SERIALIZE,
+	INTERFACE_CHAR_CB =
+	    FOURCC_COMPACT('b', 'l', 'd', 'v') | IFACE_EXCHANGE_PARALLEL | IFACE_MOD_CALLBACK,
+	INTERFACE_AUDIO_PCM_CB =
+	    FOURCC_COMPACT('a', 'p', 'c', 'm') | IFACE_EXCHANGE_PARALLEL | IFACE_MOD_CALLBACK,
+	INTERFACE_NIC_CB =
+	    FOURCC_COMPACT('n', 'i', 'c', ' ') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_USBVIRT_CB =
+	    FOURCC_COMPACT('u', 's', 'b', 'v') | IFACE_EXCHANGE_PARALLEL | IFACE_MOD_CALLBACK,
+	INTERFACE_ADB_CB =
+	    FOURCC_COMPACT('a', 'd', 'b', ' ') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_MOUSE_CB =
+	    FOURCC_COMPACT('m', 'o', 'u', 's') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK,
+	INTERFACE_KBD_CB =
+	    FOURCC_COMPACT('k', 'b', 'd', ' ') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK
 } iface_t;
 
Index: uspace/app/barber/barber.c
===================================================================
--- uspace/app/barber/barber.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/app/barber/barber.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -267,5 +267,5 @@
 			link_initialize(&dev->link);
 			dev->svc_id = svcs[i];
-			dev->sess = loc_service_connect_iface(svcs[i], INTERFACE_DDF_CLIENT, 0);
+			dev->sess = loc_service_connect(svcs[i], INTERFACE_DDF, 0);
 			
 			list_append(&dev->link, &led_devs);
Index: uspace/app/date/date.c
===================================================================
--- uspace/app/date/date.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/app/date/date.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -136,6 +136,5 @@
 
 	/* Connect to the device */
-	async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE,
-	    svc_id, 0);
+	async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF, 0);
 	if (!sess) {
 		printf(NAME ": Cannot connect to the device\n");
Index: uspace/app/mixerctl/mixerctl.c
===================================================================
--- uspace/app/mixerctl/mixerctl.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/app/mixerctl/mixerctl.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -155,6 +155,5 @@
 	}
 
-	async_sess_t *session = loc_service_connect(
-	    EXCHANGE_ATOMIC, mixer_sid, 0);
+	async_sess_t *session = loc_service_connect(mixer_sid, INTERFACE_DDF, 0);
 	if (!session) {
 		printf("Failed connecting mixer service '%s'.\n", service);
Index: uspace/app/mkbd/main.c
===================================================================
--- uspace/app/mkbd/main.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/app/mkbd/main.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -231,6 +231,5 @@
 	}
 	
-	async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE,
-	    dev_handle, 0);
+	async_sess_t *sess = devman_device_connect(dev_handle, 0);
 	if (!sess) {
 		printf(NAME ": failed to connect to the device (handle %"
Index: uspace/app/nic/nic.c
===================================================================
--- uspace/app/nic/nic.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/app/nic/nic.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -99,5 +99,5 @@
 	printf("Using device: %s\n", svc_name);
 
-	sess = loc_service_connect(EXCHANGE_SERIALIZE, nics[i], 0);
+	sess = loc_service_connect(nics[i], INTERFACE_DDF, 0);
 	if (sess == NULL) {
 		printf("Error connecting to service.\n");
@@ -117,10 +117,10 @@
 	int rc;
 
-	sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id, 0);
+	sess = loc_service_connect(svc_id, INTERFACE_DDF, 0);
 	if (sess == NULL) {
 		printf("Error connecting to service.\n");
 		goto error;
 	}
-
+	
 	rc = nic_get_address(sess, &info->address);
 	if (rc != EOK) {
Index: uspace/app/sportdmp/sportdmp.c
===================================================================
--- uspace/app/sportdmp/sportdmp.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/app/sportdmp/sportdmp.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -111,5 +111,5 @@
 
 
-	async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
+	async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
 	    IPC_FLAG_BLOCKING);
 	if (!sess) {
Index: uspace/app/tester/hw/misc/virtchar1.c
===================================================================
--- uspace/app/tester/hw/misc/virtchar1.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/app/tester/hw/misc/virtchar1.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -69,5 +69,5 @@
 	
 	TPRINTF(" Asking for session...\n");
-	async_sess_t *sess = fd_session(EXCHANGE_SERIALIZE, fd);
+	async_sess_t *sess = fd_session(fd, INTERFACE_DDF);
 	if (!sess) {
 		close(fd);
Index: uspace/app/tester/hw/serial/serial1.c
===================================================================
--- uspace/app/tester/hw/serial/serial1.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/app/tester/hw/serial/serial1.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -76,5 +76,5 @@
 		return "Failed getting serial port service ID";
 	
-	async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
+	async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
 	    IPC_FLAG_BLOCKING);
 	if (!sess)
Index: uspace/app/wifi_supplicant/wifi_supplicant.c
===================================================================
--- uspace/app/wifi_supplicant/wifi_supplicant.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/app/wifi_supplicant/wifi_supplicant.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -121,5 +121,5 @@
 	
 	async_sess_t *sess =
-	    loc_service_connect(EXCHANGE_SERIALIZE, wifis[i], 0);
+	    loc_service_connect(wifis[i], INTERFACE_DDF, 0);
 	if (sess == NULL) {
 		printf("Error connecting to service.\n");
Index: uspace/drv/audio/hdaudio/hdaudio.c
===================================================================
--- uspace/drv/audio/hdaudio/hdaudio.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/audio/hdaudio/hdaudio.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -175,6 +175,5 @@
 
 	ddf_msg(LVL_NOTE, "create parent sess");
-	hda->parent_sess = ddf_dev_parent_sess_create(dev,
-	    EXCHANGE_SERIALIZE);
+	hda->parent_sess = ddf_dev_parent_sess_create(dev);
 	if (hda->parent_sess == NULL) {
 		ddf_msg(LVL_ERROR, "Failed connecting parent driver.\n");
Index: uspace/drv/audio/sb16/dsp.c
===================================================================
--- uspace/drv/audio/sb16/dsp.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/audio/sb16/dsp.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -159,5 +159,5 @@
 static inline int setup_dma(sb_dsp_t *dsp, uintptr_t pa, size_t size)
 {
-	async_sess_t *sess = devman_parent_device_connect(EXCHANGE_ATOMIC,
+	async_sess_t *sess = devman_parent_device_connect(
 	    ddf_dev_get_handle(dsp->sb_dev), IPC_FLAG_BLOCKING);
 
@@ -307,5 +307,5 @@
 
 	assert(dsp->buffer.data);
-	async_sess_t *sess = devman_parent_device_connect(EXCHANGE_ATOMIC,
+	async_sess_t *sess = devman_parent_device_connect(
 	    ddf_dev_get_handle(dsp->sb_dev), IPC_FLAG_BLOCKING);
 
Index: uspace/drv/audio/sb16/main.c
===================================================================
--- uspace/drv/audio/sb16/main.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/audio/sb16/main.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -178,5 +178,5 @@
 
 	async_sess_t *parent_sess = devman_parent_device_connect(
-	    EXCHANGE_SERIALIZE, ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
+	    ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
@@ -245,5 +245,5 @@
 {
 	async_sess_t *parent_sess = devman_parent_device_connect(
-	    EXCHANGE_SERIALIZE, ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
+	    ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
Index: uspace/drv/block/ahci/ahci.c
===================================================================
--- uspace/drv/block/ahci/ahci.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/block/ahci/ahci.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -1140,5 +1140,5 @@
 	
 	/* Connect to parent device */
-	ahci->parent_sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
+	ahci->parent_sess = ddf_dev_parent_sess_create(dev);
 	if (ahci->parent_sess == NULL)
 		return NULL;
Index: uspace/drv/block/ata_bd/main.c
===================================================================
--- uspace/drv/block/ata_bd/main.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/block/ata_bd/main.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -68,6 +68,5 @@
 	int rc;
 
-	parent_sess = ddf_dev_parent_sess_create(dev,
-	    EXCHANGE_SERIALIZE);
+	parent_sess = ddf_dev_parent_sess_create(dev);
 	if (parent_sess == NULL)
 		return ENOMEM;
Index: uspace/drv/block/ddisk/ddisk.c
===================================================================
--- uspace/drv/block/ddisk/ddisk.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/block/ddisk/ddisk.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -286,5 +286,5 @@
 	int rc;
 
-	parent_sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
+	parent_sess = ddf_dev_parent_sess_create(dev);
 	if (parent_sess == NULL)
 		return ENOMEM;
Index: uspace/drv/bus/amba/amba.c
===================================================================
--- uspace/drv/bus/amba/amba.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/bus/amba/amba.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -333,5 +333,5 @@
 	
 	bus->dnode = dnode;
-	async_sess_t *sess = ddf_dev_parent_sess_create(dnode, EXCHANGE_SERIALIZE);
+	async_sess_t *sess = ddf_dev_parent_sess_create(dnode);
 	if (sess == NULL) {
 		ddf_msg(LVL_ERROR, "amba_dev_add failed to connect to the "
Index: uspace/drv/bus/isa/isa.c
===================================================================
--- uspace/drv/bus/isa/isa.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/bus/isa/isa.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -616,5 +616,5 @@
 	list_initialize(&isa->functions);
 
-	sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
+	sess = ddf_dev_parent_sess_create(dev);
 	if (sess == NULL) {
 		ddf_msg(LVL_ERROR, "isa_dev_add failed to connect to the "
Index: uspace/drv/bus/pci/pciintel/pci.c
===================================================================
--- uspace/drv/bus/pci/pciintel/pci.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/bus/pci/pciintel/pci.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -664,5 +664,5 @@
 	bus->dnode = dnode;
 	
-	sess = ddf_dev_parent_sess_create(dnode, EXCHANGE_SERIALIZE);
+	sess = ddf_dev_parent_sess_create(dnode);
 	if (sess == NULL) {
 		ddf_msg(LVL_ERROR, "pci_dev_add failed to connect to the "
Index: uspace/drv/bus/usb/ehci/res.c
===================================================================
--- uspace/drv/bus/usb/ehci/res.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/bus/usb/ehci/res.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -81,5 +81,5 @@
 	
 	async_sess_t *parent_sess = devman_parent_device_connect(
-	    EXCHANGE_SERIALIZE, ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
+	    ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
@@ -115,5 +115,5 @@
 {
 	async_sess_t *parent_sess = devman_parent_device_connect(
-	    EXCHANGE_SERIALIZE, ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
+	    ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
@@ -138,5 +138,5 @@
 
 	async_sess_t *parent_sess = devman_parent_device_connect(
-	    EXCHANGE_SERIALIZE, ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
+	    ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
Index: uspace/drv/bus/usb/ohci/res.c
===================================================================
--- uspace/drv/bus/usb/ohci/res.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/bus/usb/ohci/res.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -57,6 +57,6 @@
 
 	async_sess_t *parent_sess =
-	    devman_parent_device_connect(EXCHANGE_SERIALIZE,
-	    ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
+	    devman_parent_device_connect(ddf_dev_get_handle(dev),
+	    IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
@@ -93,6 +93,6 @@
 {
 	async_sess_t *parent_sess =
-	    devman_parent_device_connect(EXCHANGE_SERIALIZE,
-	    ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
+	    devman_parent_device_connect(ddf_dev_get_handle(device),
+	    IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
Index: uspace/drv/bus/usb/uhci/res.c
===================================================================
--- uspace/drv/bus/usb/uhci/res.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/bus/usb/uhci/res.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -55,6 +55,6 @@
 
 	async_sess_t *parent_sess =
-	    devman_parent_device_connect(EXCHANGE_SERIALIZE,
-	    ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
+	    devman_parent_device_connect(ddf_dev_get_handle(dev),
+	    IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
@@ -91,6 +91,6 @@
 {
 	async_sess_t *parent_sess =
-	    devman_parent_device_connect(EXCHANGE_SERIALIZE,
-	    ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
+	    devman_parent_device_connect(ddf_dev_get_handle(device),
+	    IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
@@ -112,5 +112,5 @@
 
 	async_sess_t *parent_sess = devman_parent_device_connect(
-	    EXCHANGE_SERIALIZE, ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
+	    ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
Index: uspace/drv/bus/usb/uhcirh/main.c
===================================================================
--- uspace/drv/bus/usb/uhcirh/main.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/bus/usb/uhcirh/main.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -131,6 +131,6 @@
 {
 	async_sess_t *parent_sess =
-	    devman_parent_device_connect(EXCHANGE_SERIALIZE,
-	    ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
+	    devman_parent_device_connect(ddf_dev_get_handle(dev),
+	    IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
Index: uspace/drv/char/grlib_uart/grlib_uart.c
===================================================================
--- uspace/drv/char/grlib_uart/grlib_uart.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/char/grlib_uart/grlib_uart.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -381,6 +381,5 @@
 	
 	/* Connect to the parent's driver. */
-	async_sess_t *parent_sess = ddf_dev_parent_sess_create(ns->dev,
-	    EXCHANGE_SERIALIZE);
+	async_sess_t *parent_sess = ddf_dev_parent_sess_create(ns->dev);
 	if (parent_sess == NULL) {
 		ddf_msg(LVL_ERROR, "Failed to connect to parent driver of "
Index: uspace/drv/char/i8042/main.c
===================================================================
--- uspace/drv/char/i8042/main.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/char/i8042/main.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -61,6 +61,5 @@
 	assert(dev);
 	
-	async_sess_t *parent_sess = ddf_dev_parent_sess_create(
-	    dev, EXCHANGE_SERIALIZE);
+	async_sess_t *parent_sess = ddf_dev_parent_sess_create(dev);
 	if (parent_sess == NULL)
 		return ENOMEM;
Index: uspace/drv/char/ns8250/ns8250.c
===================================================================
--- uspace/drv/char/ns8250/ns8250.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/char/ns8250/ns8250.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -391,5 +391,5 @@
 	
 	/* Connect to the parent's driver. */
-	parent_sess = ddf_dev_parent_sess_create(ns->dev, EXCHANGE_SERIALIZE);
+	parent_sess = ddf_dev_parent_sess_create(ns->dev);
 	if (parent_sess == NULL) {
 		ddf_msg(LVL_ERROR, "Failed to connect to parent driver of "
Index: uspace/drv/char/pl050/pl050.c
===================================================================
--- uspace/drv/char/pl050/pl050.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/char/pl050/pl050.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -167,6 +167,5 @@
 	pl050->buf_rp = pl050->buf_wp = 0;
 
-	pl050->parent_sess = ddf_dev_parent_sess_create(pl050->dev,
-	    EXCHANGE_SERIALIZE);
+	pl050->parent_sess = ddf_dev_parent_sess_create(pl050->dev);
 	if (pl050->parent_sess == NULL) {
 		ddf_msg(LVL_ERROR, "Failed connecitng parent driver.");
Index: uspace/drv/char/ps2mouse/ps2mouse.c
===================================================================
--- uspace/drv/char/ps2mouse/ps2mouse.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/char/ps2mouse/ps2mouse.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -116,5 +116,5 @@
 {
 	mouse->client_sess = NULL;
-	mouse->parent_sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
+	mouse->parent_sess = ddf_dev_parent_sess_create(dev);
 	if (!mouse->parent_sess)
 		return ENOMEM;
Index: uspace/drv/char/xtkbd/xtkbd.c
===================================================================
--- uspace/drv/char/xtkbd/xtkbd.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/char/xtkbd/xtkbd.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -417,5 +417,5 @@
 	
 	kbd->client_sess = NULL;
-	kbd->parent_sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
+	kbd->parent_sess = ddf_dev_parent_sess_create(dev);
 	
 	if (!kbd->parent_sess) {
Index: uspace/drv/time/cmos-rtc/cmos-rtc.c
===================================================================
--- uspace/drv/time/cmos-rtc/cmos-rtc.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/drv/time/cmos-rtc/cmos-rtc.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -213,5 +213,5 @@
 	/* Connect to the parent's driver */
 
-	parent_sess = ddf_dev_parent_sess_create(rtc->dev, EXCHANGE_SERIALIZE);
+	parent_sess = ddf_dev_parent_sess_create(rtc->dev);
 	if (!parent_sess) {
 		ddf_msg(LVL_ERROR, "Failed to connect to parent driver\
Index: uspace/lib/block/block.c
===================================================================
--- uspace/lib/block/block.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/block/block.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -148,5 +148,5 @@
 	bd_t *bd;
 
-	async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, service_id,
+	async_sess_t *sess = loc_service_connect(service_id, INTERFACE_BLOCK,
 	    IPC_FLAG_BLOCKING);
 	if (!sess) {
Index: uspace/lib/c/generic/async.c
===================================================================
--- uspace/lib/c/generic/async.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/async.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -2105,5 +2105,4 @@
  * @param arg2            User defined argument.
  * @param arg3            User defined argument.
- * @param client_receiver Connection handing routine.
  *
  * @return Zero on success or a negative error code.
@@ -2111,25 +2110,17 @@
  */
 int async_connect_to_me(async_exch_t *exch, sysarg_t arg1, sysarg_t arg2,
-    sysarg_t arg3, async_port_handler_t client_receiver, void *data)
+    sysarg_t arg3)
 {
 	if (exch == NULL)
 		return ENOENT;
 	
-	sysarg_t phone_hash;
+	ipc_call_t answer;
+	aid_t req = async_send_3(exch, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
+	    &answer);
+	
 	sysarg_t rc;
-
-	aid_t req;
-	ipc_call_t answer;
-	req = async_send_3(exch, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
-	    &answer);
 	async_wait_for(req, &rc);
 	if (rc != EOK)
 		return (int) rc;
-
-	phone_hash = IPC_GET_ARG5(answer);
-
-	if (client_receiver != NULL)
-		async_new_connection(answer.in_task_id, phone_hash, 0, NULL,
-		    client_receiver, data);
 	
 	return EOK;
@@ -2261,5 +2252,4 @@
 	int phone = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
 	    0);
-	
 	if (phone < 0) {
 		errno = phone;
Index: uspace/lib/c/generic/bd.c
===================================================================
--- uspace/lib/c/generic/bd.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/bd.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -57,5 +57,8 @@
 	async_exch_t *exch = async_exchange_begin(sess);
 	
-	int rc = async_connect_to_me(exch, 0, 0, 0, bd_cb_conn, bd);
+	port_id_t port;
+	int rc = async_create_callback_port(exch, INTERFACE_BLOCK_CB, 0, 0,
+	    bd_cb_conn, bd, &port);
+	
 	async_exchange_end(exch);
 	
Index: uspace/lib/c/generic/clipboard.c
===================================================================
--- uspace/lib/c/generic/clipboard.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/clipboard.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -61,6 +61,6 @@
 	
 	while (clip_sess == NULL)
-		clip_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-		    SERVICE_CLIPBOARD, 0);
+		clip_sess = service_connect_blocking(SERVICE_CLIPBOARD,
+		    INTERFACE_CLIPBOARD, 0);
 	
 	fibril_mutex_unlock(&clip_mutex);
Index: uspace/lib/c/generic/corecfg.c
===================================================================
--- uspace/lib/c/generic/corecfg.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/corecfg.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -50,5 +50,5 @@
 		return ENOENT;
 
-	corecfg_sess = loc_service_connect(EXCHANGE_SERIALIZE, corecfg_svc,
+	corecfg_sess = loc_service_connect(corecfg_svc, INTERFACE_CORECFG,
 	    IPC_FLAG_BLOCKING);
 	if (corecfg_sess == NULL)
Index: uspace/lib/c/generic/devman.c
===================================================================
--- uspace/lib/c/generic/devman.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/devman.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -77,8 +77,8 @@
  *
  */
-async_exch_t *devman_exchange_begin_blocking(devman_interface_t iface)
+async_exch_t *devman_exchange_begin_blocking(iface_t iface)
 {
 	switch (iface) {
-	case DEVMAN_DRIVER:
+	case INTERFACE_DDF_DRIVER:
 		fibril_mutex_lock(&devman_driver_block_mutex);
 		
@@ -89,6 +89,6 @@
 			if (devman_driver_block_sess == NULL)
 				devman_driver_block_sess =
-				    service_connect_blocking_iface(EXCHANGE_PARALLEL,
-				    DEVMAN_DRIVER, SERVICE_DEVMAN, 0);
+				    service_connect_blocking(SERVICE_DEVMAN,
+				    INTERFACE_DDF_DRIVER, 0);
 		}
 		
@@ -99,5 +99,5 @@
 		
 		return async_exchange_begin(devman_driver_block_sess);
-	case DEVMAN_CLIENT:
+	case INTERFACE_DDF_CLIENT:
 		fibril_mutex_lock(&devman_client_block_mutex);
 		
@@ -108,6 +108,6 @@
 			if (devman_client_block_sess == NULL)
 				devman_client_block_sess =
-				    service_connect_blocking_iface(EXCHANGE_SERIALIZE,
-				    DEVMAN_CLIENT, SERVICE_DEVMAN, 0);
+				    service_connect_blocking(SERVICE_DEVMAN,
+				    INTERFACE_DDF_CLIENT, 0);
 		}
 		
@@ -130,14 +130,14 @@
  *
  */
-async_exch_t *devman_exchange_begin(devman_interface_t iface)
+async_exch_t *devman_exchange_begin(iface_t iface)
 {
 	switch (iface) {
-	case DEVMAN_DRIVER:
+	case INTERFACE_DDF_DRIVER:
 		fibril_mutex_lock(&devman_driver_mutex);
 		
 		if (devman_driver_sess == NULL)
 			devman_driver_sess =
-			    service_connect_iface(EXCHANGE_PARALLEL, DEVMAN_DRIVER,
-			    SERVICE_DEVMAN, 0);
+			    service_connect(SERVICE_DEVMAN,
+			    INTERFACE_DDF_DRIVER, 0);
 		
 		fibril_mutex_unlock(&devman_driver_mutex);
@@ -147,11 +147,11 @@
 		
 		return async_exchange_begin(devman_driver_sess);
-	case DEVMAN_CLIENT:
+	case INTERFACE_DDF_CLIENT:
 		fibril_mutex_lock(&devman_client_mutex);
 		
 		if (devman_client_sess == NULL)
 			devman_client_sess =
-			    service_connect_iface(EXCHANGE_SERIALIZE, DEVMAN_CLIENT,
-			    SERVICE_DEVMAN, 0);
+			    service_connect(SERVICE_DEVMAN,
+			    INTERFACE_DDF_CLIENT, 0);
 		
 		fibril_mutex_unlock(&devman_client_mutex);
@@ -179,5 +179,5 @@
 int devman_driver_register(const char *name)
 {
-	async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
+	async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
 	
 	ipc_call_t answer;
@@ -192,6 +192,6 @@
 	}
 	
-	exch = devman_exchange_begin(DEVMAN_DRIVER);
-	async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
+	exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
+	async_connect_to_me(exch, 0, 0, 0);
 	devman_exchange_end(exch);
 	
@@ -218,5 +218,5 @@
 {
 	int match_count = list_count(&match_ids->ids);
-	async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
+	async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
 	
 	ipc_call_t answer;
@@ -268,5 +268,5 @@
     const char *cat_name)
 {
-	async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
+	async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
 	
 	ipc_call_t answer;
@@ -287,15 +287,14 @@
 }
 
-async_sess_t *devman_device_connect(exch_mgmt_t mgmt, devman_handle_t handle,
-    unsigned int flags)
+async_sess_t *devman_device_connect(devman_handle_t handle, unsigned int flags)
 {
 	async_sess_t *sess;
 	
 	if (flags & IPC_FLAG_BLOCKING)
-		sess = service_connect_blocking_iface(mgmt, DEVMAN_CONNECT_TO_DEVICE,
-		    SERVICE_DEVMAN, handle);
+		sess = service_connect_blocking(SERVICE_DEVMAN,
+		    INTERFACE_DEVMAN_DEVICE, handle);
 	else
-		sess = service_connect_iface(mgmt, DEVMAN_CONNECT_TO_DEVICE,
-		    SERVICE_DEVMAN, handle);
+		sess = service_connect(SERVICE_DEVMAN,
+		    INTERFACE_DEVMAN_DEVICE, handle);
 	
 	return sess;
@@ -314,5 +313,5 @@
 	sysarg_t retval;
 	
-	exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
+	exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
 	retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh);
 	devman_exchange_end(exch);
@@ -323,5 +322,5 @@
 int devman_drv_fun_online(devman_handle_t funh)
 {
-	async_exch_t *exch = devman_exchange_begin(DEVMAN_DRIVER);
+	async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
 	if (exch == NULL)
 		return ENOMEM;
@@ -335,5 +334,5 @@
 int devman_drv_fun_offline(devman_handle_t funh)
 {
-	async_exch_t *exch = devman_exchange_begin(DEVMAN_DRIVER);
+	async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
 	if (exch == NULL)
 		return ENOMEM;
@@ -345,15 +344,15 @@
 }
 
-async_sess_t *devman_parent_device_connect(exch_mgmt_t mgmt,
-    devman_handle_t handle, unsigned int flags)
+async_sess_t *devman_parent_device_connect(devman_handle_t handle,
+    unsigned int flags)
 {
 	async_sess_t *sess;
 	
 	if (flags & IPC_FLAG_BLOCKING)
-		sess = service_connect_blocking_iface(mgmt,
-			    DEVMAN_CONNECT_TO_PARENTS_DEVICE, SERVICE_DEVMAN, handle);
+		sess = service_connect_blocking(SERVICE_DEVMAN,
+		    INTERFACE_DEVMAN_PARENT, handle);
 	else
-		sess = service_connect_iface(mgmt,
-			    DEVMAN_CONNECT_TO_PARENTS_DEVICE, SERVICE_DEVMAN, handle);
+		sess = service_connect_blocking(SERVICE_DEVMAN,
+		    INTERFACE_DEVMAN_PARENT, handle);
 	
 	return sess;
@@ -366,7 +365,7 @@
 	
 	if (flags & IPC_FLAG_BLOCKING)
-		exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
+		exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
 	else {
-		exch = devman_exchange_begin(DEVMAN_CLIENT);
+		exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
 		if (exch == NULL)
 			return ENOMEM;
@@ -409,5 +408,5 @@
 	sysarg_t dretval;
 	
-	exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
+	exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
 	
 	ipc_call_t answer;
@@ -474,5 +473,5 @@
 int devman_fun_online(devman_handle_t funh)
 {
-	async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+	async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
 	if (exch == NULL)
 		return ENOMEM;
@@ -486,5 +485,5 @@
 int devman_fun_offline(devman_handle_t funh)
 {
-	async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+	async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
 	if (exch == NULL)
 		return ENOMEM;
@@ -499,5 +498,5 @@
     devman_handle_t *handle_buf, size_t buf_size, size_t *act_size)
 {
-	async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
+	async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
 
 	ipc_call_t answer;
@@ -578,5 +577,5 @@
 int devman_fun_get_child(devman_handle_t funh, devman_handle_t *devh)
 {
-	async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+	async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
 	if (exch == NULL)
 		return ENOMEM;
@@ -598,5 +597,5 @@
 int devman_dev_get_parent(devman_handle_t devh, devman_handle_t *funh)
 {
-	async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+	async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
 	if (exch == NULL)
 		return ENOMEM;
@@ -611,5 +610,5 @@
 int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle)
 {
-	async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+	async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
 	if (exch == NULL)
 		return ENOMEM;
@@ -639,5 +638,5 @@
 	async_exch_t *exch;
 
-	exch = devman_exchange_begin(DEVMAN_CLIENT);
+	exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
 	if (exch == NULL)
 		return ENOMEM;
@@ -694,5 +693,5 @@
 {
 	sysarg_t state;
-	async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+	async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
 	if (exch == NULL)
 		return ENOMEM;
@@ -711,5 +710,5 @@
 int devman_driver_load(devman_handle_t drvh)
 {
-	async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+	async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
 	if (exch == NULL)
 		return ENOMEM;
Index: uspace/lib/c/generic/dhcp.c
===================================================================
--- uspace/lib/c/generic/dhcp.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/dhcp.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -56,5 +56,5 @@
 		return ENOENT;
 
-	dhcp_sess = loc_service_connect(EXCHANGE_SERIALIZE, dhcp_svc,
+	dhcp_sess = loc_service_connect(dhcp_svc, INTERFACE_DHCP,
 	    IPC_FLAG_BLOCKING);
 	if (dhcp_sess == NULL)
Index: uspace/lib/c/generic/dnsr.c
===================================================================
--- uspace/lib/c/generic/dnsr.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/dnsr.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -52,5 +52,5 @@
 		    IPC_FLAG_BLOCKING);
 		
-		dnsr_sess = loc_service_connect(EXCHANGE_SERIALIZE, dnsr_svc,
+		dnsr_sess = loc_service_connect(dnsr_svc, INTERFACE_DNSR,
 		    IPC_FLAG_BLOCKING);
 	}
Index: uspace/lib/c/generic/inet.c
===================================================================
--- uspace/lib/c/generic/inet.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/inet.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -48,5 +48,9 @@
 	ipc_call_t answer;
 	aid_t req = async_send_0(exch, INET_CALLBACK_CREATE, &answer);
-	int rc = async_connect_to_me(exch, 0, 0, 0, inet_cb_conn, NULL);
+	
+	port_id_t port;
+	int rc = async_create_callback_port(exch, INTERFACE_INET_CB, 0, 0,
+	    inet_cb_conn, NULL, &port);
+	
 	async_exchange_end(exch);
 	
@@ -83,5 +87,5 @@
 		return ENOENT;
 	
-	inet_sess = loc_service_connect(EXCHANGE_SERIALIZE, inet_svc,
+	inet_sess = loc_service_connect(inet_svc, INTERFACE_INET,
 	    IPC_FLAG_BLOCKING);
 	if (inet_sess == NULL)
Index: uspace/lib/c/generic/inet/tcp.c
===================================================================
--- uspace/lib/c/generic/inet/tcp.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/inet/tcp.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -112,5 +112,5 @@
 	}
 
-	tcp->sess = loc_service_connect(EXCHANGE_SERIALIZE, tcp_svcid,
+	tcp->sess = loc_service_connect(tcp_svcid, INTERFACE_TCP,
 	    IPC_FLAG_BLOCKING);
 	if (tcp->sess == NULL) {
Index: uspace/lib/c/generic/inet/udp.c
===================================================================
--- uspace/lib/c/generic/inet/udp.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/inet/udp.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -98,5 +98,5 @@
 	}
 
-	udp->sess = loc_service_connect(EXCHANGE_SERIALIZE, udp_svcid,
+	udp->sess = loc_service_connect(udp_svcid, INTERFACE_UDP,
 	    IPC_FLAG_BLOCKING);
 	if (udp->sess == NULL) {
Index: uspace/lib/c/generic/inetcfg.c
===================================================================
--- uspace/lib/c/generic/inetcfg.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/inetcfg.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -120,10 +120,10 @@
 	assert(inetcfg_sess == NULL);
 	
-	rc = loc_service_get_id(SERVICE_NAME_INETCFG, &inet_svc,
+	rc = loc_service_get_id(SERVICE_NAME_INET, &inet_svc,
 	    IPC_FLAG_BLOCKING);
 	if (rc != EOK)
 		return ENOENT;
 	
-	inetcfg_sess = loc_service_connect(EXCHANGE_SERIALIZE, inet_svc,
+	inetcfg_sess = loc_service_connect(inet_svc, INTERFACE_INETCFG,
 	    IPC_FLAG_BLOCKING);
 	if (inetcfg_sess == NULL)
Index: uspace/lib/c/generic/inetping.c
===================================================================
--- uspace/lib/c/generic/inetping.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/inetping.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -53,10 +53,10 @@
 	inetping_ev_ops = ev_ops;
 
-	rc = loc_service_get_id(SERVICE_NAME_INETPING, &inetping_svc,
+	rc = loc_service_get_id(SERVICE_NAME_INET, &inetping_svc,
 	    IPC_FLAG_BLOCKING);
 	if (rc != EOK)
 		return ENOENT;
 
-	inetping_sess = loc_service_connect(EXCHANGE_SERIALIZE, inetping_svc,
+	inetping_sess = loc_service_connect(inetping_svc, INTERFACE_INETPING,
 	    IPC_FLAG_BLOCKING);
 	if (inetping_sess == NULL)
@@ -65,5 +65,8 @@
 	async_exch_t *exch = async_exchange_begin(inetping_sess);
 
-	rc = async_connect_to_me(exch, 0, 0, 0, inetping_cb_conn, NULL);
+	port_id_t port;
+	rc = async_create_callback_port(exch, INTERFACE_INETPING_CB, 0, 0,
+	    inetping_cb_conn, NULL, &port);
+	
 	async_exchange_end(exch);
 
Index: uspace/lib/c/generic/io/console.c
===================================================================
--- uspace/lib/c/generic/io/console.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/io/console.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -49,5 +49,5 @@
 		return NULL;
 	
-	ctrl->input_sess = fsession(EXCHANGE_SERIALIZE, ifile);
+	ctrl->input_sess = fsession(ifile, INTERFACE_CONSOLE);
 	if (!ctrl->input_sess) {
 		free(ctrl);
@@ -55,5 +55,5 @@
 	}
 	
-	ctrl->output_sess = fsession(EXCHANGE_SERIALIZE, ofile);
+	ctrl->output_sess = fsession(ofile, INTERFACE_CONSOLE);
 	if (!ctrl->output_sess) {
 		free(ctrl);
Index: uspace/lib/c/generic/io/input.c
===================================================================
--- uspace/lib/c/generic/io/input.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/io/input.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -58,5 +58,8 @@
 	async_exch_t *exch = async_exchange_begin(sess);
 
-	int rc = async_connect_to_me(exch, 0, 0, 0, input_cb_conn, input);
+	port_id_t port;
+	int rc = async_create_callback_port(exch, INTERFACE_INPUT_CB, 0, 0,
+	    input_cb_conn, input, &port);
+	
 	async_exchange_end(exch);
 
Index: uspace/lib/c/generic/io/io.c
===================================================================
--- uspace/lib/c/generic/io/io.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/io/io.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -748,9 +748,9 @@
 }
 
-async_sess_t *fsession(exch_mgmt_t mgmt, FILE *stream)
+async_sess_t *fsession(FILE *stream, iface_t iface)
 {
 	if (stream->fd >= 0) {
 		if (stream->sess == NULL)
-			stream->sess = fd_session(mgmt, stream->fd);
+			stream->sess = fd_session(stream->fd, iface);
 		
 		return stream->sess;
Index: uspace/lib/c/generic/io/log.c
===================================================================
--- uspace/lib/c/generic/io/log.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/io/log.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -166,6 +166,6 @@
 		return ENOMEM;
 
-	logger_session = service_connect_blocking_iface(EXCHANGE_SERIALIZE,
-	    LOGGER_INTERFACE_WRITER, SERVICE_LOGGER, 0);
+	logger_session = service_connect_blocking(SERVICE_LOGGER,
+	    INTERFACE_LOGGER_WRITER, 0);
 	if (logger_session == NULL) {
 		return ENOMEM;
Index: uspace/lib/c/generic/io/logctl.c
===================================================================
--- uspace/lib/c/generic/io/logctl.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/io/logctl.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -48,6 +48,6 @@
 
 	if (logger_session == NULL) {
-		logger_session = service_connect_blocking_iface(EXCHANGE_SERIALIZE,
-		    LOGGER_INTERFACE_CONTROL, SERVICE_LOGGER, 0);
+		logger_session = service_connect_blocking(SERVICE_LOGGER,
+		    INTERFACE_LOGGER_CONTROL, 0);
 		if (logger_session == NULL)
 			return ENOMEM;
Index: uspace/lib/c/generic/iplink.c
===================================================================
--- uspace/lib/c/generic/iplink.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/iplink.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -59,6 +59,9 @@
 	
 	async_exch_t *exch = async_exchange_begin(sess);
-	
-	int rc = async_connect_to_me(exch, 0, 0, 0, iplink_cb_conn, iplink);
+
+	port_id_t port;
+	int rc = async_create_callback_port(exch, INTERFACE_IPLINK_CB, 0, 0,
+	    iplink_cb_conn, iplink, &port);
+	
 	async_exchange_end(exch);
 	
Index: uspace/lib/c/generic/irc.c
===================================================================
--- uspace/lib/c/generic/irc.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/irc.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -51,6 +51,5 @@
 	assert(irc_sess == NULL);
 
-	irc_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-	    SERVICE_IRC, 0);
+	irc_sess = service_connect_blocking(SERVICE_IRC, INTERFACE_IRC, 0);
 
 	if (irc_sess == NULL)
Index: uspace/lib/c/generic/loader.c
===================================================================
--- uspace/lib/c/generic/loader.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/loader.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -69,6 +69,5 @@
 	
 	async_sess_t *sess =
-	    service_connect_blocking_iface_extended(SERVICE_LOADER,
-	    INTERFACE_LOADER, 0);
+	    service_connect_blocking(SERVICE_LOADER, INTERFACE_LOADER, 0);
 	if (sess == NULL) {
 		free(ldr);
Index: uspace/lib/c/generic/loc.c
===================================================================
--- uspace/lib/c/generic/loc.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/loc.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -107,9 +107,13 @@
 	if (!loc_callback_created) {
 		async_exch_t *exch =
-		    loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+		    loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 		
 		ipc_call_t answer;
 		aid_t req = async_send_0(exch, LOC_CALLBACK_CREATE, &answer);
-		int rc = async_connect_to_me(exch, 0, 0, 0, loc_cb_conn, NULL);
+		
+		port_id_t port;
+		int rc = async_create_callback_port(exch, INTERFACE_LOC_CB, 0, 0,
+		    loc_cb_conn, NULL, &port);
+		
 		loc_exchange_end(exch);
 		
@@ -135,8 +139,8 @@
  *
  */
-async_exch_t *loc_exchange_begin_blocking(loc_interface_t iface)
+async_exch_t *loc_exchange_begin_blocking(iface_t iface)
 {
 	switch (iface) {
-	case LOC_PORT_SUPPLIER:
+	case INTERFACE_LOC_SUPPLIER:
 		fibril_mutex_lock(&loc_supp_block_mutex);
 		
@@ -147,6 +151,6 @@
 			if (loc_supp_block_sess == NULL)
 				loc_supp_block_sess =
-				    service_connect_blocking_iface(EXCHANGE_SERIALIZE,
-				    LOC_PORT_SUPPLIER, SERVICE_LOC, 0);
+				    service_connect_blocking(SERVICE_LOC,
+				    INTERFACE_LOC_SUPPLIER, 0);
 		}
 		
@@ -157,5 +161,5 @@
 		
 		return async_exchange_begin(loc_supp_block_sess);
-	case LOC_PORT_CONSUMER:
+	case INTERFACE_LOC_CONSUMER:
 		fibril_mutex_lock(&loc_cons_block_mutex);
 		
@@ -166,6 +170,6 @@
 			if (loc_cons_block_sess == NULL)
 				loc_cons_block_sess =
-				    service_connect_blocking_iface(EXCHANGE_SERIALIZE,
-				    LOC_PORT_CONSUMER, SERVICE_LOC, 0);
+				    service_connect_blocking(SERVICE_LOC,
+				    INTERFACE_LOC_CONSUMER, 0);
 		}
 		
@@ -188,14 +192,14 @@
  *
  */
-async_exch_t *loc_exchange_begin(loc_interface_t iface)
+async_exch_t *loc_exchange_begin(iface_t iface)
 {
 	switch (iface) {
-	case LOC_PORT_SUPPLIER:
+	case INTERFACE_LOC_SUPPLIER:
 		fibril_mutex_lock(&loc_supplier_mutex);
 		
 		if (loc_supplier_sess == NULL)
 			loc_supplier_sess =
-			    service_connect_iface(EXCHANGE_SERIALIZE, LOC_PORT_SUPPLIER,
-			    SERVICE_LOC, 0);
+			    service_connect(SERVICE_LOC,
+			    INTERFACE_LOC_SUPPLIER, 0);
 		
 		fibril_mutex_unlock(&loc_supplier_mutex);
@@ -205,11 +209,11 @@
 		
 		return async_exchange_begin(loc_supplier_sess);
-	case LOC_PORT_CONSUMER:
+	case INTERFACE_LOC_CONSUMER:
 		fibril_mutex_lock(&loc_consumer_mutex);
 		
 		if (loc_consumer_sess == NULL)
 			loc_consumer_sess =
-			    service_connect_iface(EXCHANGE_SERIALIZE, LOC_PORT_CONSUMER,
-			    SERVICE_LOC, 0);
+			    service_connect(SERVICE_LOC,
+			    INTERFACE_LOC_CONSUMER, 0);
 		
 		fibril_mutex_unlock(&loc_consumer_mutex);
@@ -237,5 +241,5 @@
 int loc_server_register(const char *name)
 {
-	async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
+	async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
 	
 	ipc_call_t answer;
@@ -250,6 +254,6 @@
 	}
 	
-	exch = loc_exchange_begin(LOC_PORT_SUPPLIER);
-	async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
+	exch = loc_exchange_begin(INTERFACE_LOC_SUPPLIER);
+	async_connect_to_me(exch, 0, 0, 0);
 	loc_exchange_end(exch);
 	
@@ -260,24 +264,14 @@
 /** Register new service.
  *
- * The @p interface is used when forwarding connection to the server.
- * If not 0, the first argument is the interface and the second argument
- * is the service ID.
- *
- * When the interface is zero (default), the first argument is directly
- * the handle (to ensure backward compatibility).
- *
- * @param      fqsn      Fully qualified service name
- * @param[out] sid       Service ID of new service
- * @param      interface Interface when forwarding
- *
- */
-int loc_service_register_with_iface(const char *fqsn,
-    service_id_t *sid, sysarg_t interface)
-{
-	async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
+ * @param      fqsn  Fully qualified service name
+ * @param[out] sid   Service ID of new service
+ *
+ */
+int loc_service_register(const char *fqsn, service_id_t *sid)
+{
+	async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
 	
 	ipc_call_t answer;
-	aid_t req = async_send_2(exch, LOC_SERVICE_REGISTER, interface, 0,
-	    &answer);
+	aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
 	sysarg_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
 	
@@ -304,15 +298,4 @@
 }
 
-/** Register new service.
- *
- * @param fqsn Fully qualified service name
- * @param sid  Output: ID of new service
- *
- */
-int loc_service_register(const char *fqdn, service_id_t *sid)
-{
-	return loc_service_register_with_iface(fqdn, sid, 0);
-}
-
 /** Unregister service.
  *
@@ -324,5 +307,5 @@
 	sysarg_t retval;
 	
-	exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
+	exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
 	retval = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid);
 	loc_exchange_end(exch);
@@ -337,7 +320,7 @@
 	
 	if (flags & IPC_FLAG_BLOCKING)
-		exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+		exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 	else {
-		exch = loc_exchange_begin(LOC_PORT_CONSUMER);
+		exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
 		if (exch == NULL)
 			return errno;
@@ -390,5 +373,5 @@
 	
 	*name = NULL;
-	exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+	exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 	
 	ipc_call_t answer;
@@ -470,7 +453,7 @@
 	
 	if (flags & IPC_FLAG_BLOCKING)
-		exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+		exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 	else {
-		exch = loc_exchange_begin(LOC_PORT_CONSUMER);
+		exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
 		if (exch == NULL)
 			return errno;
@@ -519,7 +502,7 @@
 	
 	if (flags & IPC_FLAG_BLOCKING)
-		exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+		exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 	else {
-		exch = loc_exchange_begin(LOC_PORT_CONSUMER);
+		exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
 		if (exch == NULL)
 			return errno;
@@ -556,5 +539,5 @@
 loc_object_type_t loc_id_probe(service_id_t handle)
 {
-	async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+	async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 	
 	sysarg_t type;
@@ -569,5 +552,5 @@
 }
 
-async_sess_t *loc_service_connect_iface(service_id_t handle, iface_t iface,
+async_sess_t *loc_service_connect(service_id_t handle, iface_t iface,
     unsigned int flags)
 {
@@ -575,29 +558,14 @@
 	
 	if (flags & IPC_FLAG_BLOCKING)
-		sess = service_connect_blocking_iface_extended(SERVICE_LOC, iface, handle);
+		sess = service_connect_blocking(SERVICE_LOC, iface, handle);
 	else
-		sess = service_connect_iface_extended(SERVICE_LOC, iface, handle);
+		sess = service_connect(SERVICE_LOC, iface, handle);
 	
 	return sess;
 }
 
-async_sess_t *loc_service_connect(exch_mgmt_t mgmt, service_id_t handle,
-    unsigned int flags)
-{
-	async_sess_t *sess;
-	
-	if (flags & IPC_FLAG_BLOCKING)
-		sess = service_connect_blocking_iface(mgmt, LOC_CONNECT_TO_SERVICE,
-		    SERVICE_LOC, handle);
-	else
-		sess = service_connect_iface(mgmt, LOC_CONNECT_TO_SERVICE,
-		    SERVICE_LOC, handle);
-	
-	return sess;
-}
-
 int loc_null_create(void)
 {
-	async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+	async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 	
 	sysarg_t null_id;
@@ -614,5 +582,5 @@
 void loc_null_destroy(int null_id)
 {
-	async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+	async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 	async_req_1_0(exch, LOC_NULL_DESTROY, (sysarg_t) null_id);
 	loc_exchange_end(exch);
@@ -640,5 +608,5 @@
 	sysarg_t retval;
 	
-	exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
+	exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
 	retval = async_req_2_0(exch, LOC_SERVICE_ADD_TO_CAT, svc_id, cat_id);
 	loc_exchange_end(exch);
@@ -661,5 +629,5 @@
 size_t loc_count_namespaces(void)
 {
-	async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+	async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 	size_t size = loc_count_namespaces_internal(exch);
 	loc_exchange_end(exch);
@@ -670,5 +638,5 @@
 size_t loc_count_services(service_id_t ns_handle)
 {
-	async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+	async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 	size_t size = loc_count_services_internal(exch, ns_handle);
 	loc_exchange_end(exch);
@@ -681,5 +649,5 @@
 	/* Loop until read is succesful */
 	while (true) {
-		async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+		async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 		size_t count = loc_count_namespaces_internal(exch);
 		loc_exchange_end(exch);
@@ -692,5 +660,5 @@
 			return 0;
 		
-		exch = loc_exchange_begin(LOC_PORT_CONSUMER);
+		exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
 		
 		ipc_call_t answer;
@@ -730,5 +698,5 @@
 	/* Loop until read is succesful */
 	while (true) {
-		async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+		async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 		size_t count = loc_count_services_internal(exch, ns_handle);
 		loc_exchange_end(exch);
@@ -741,5 +709,5 @@
 			return 0;
 		
-		exch = loc_exchange_begin(LOC_PORT_CONSUMER);
+		exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
 		
 		ipc_call_t answer;
@@ -778,5 +746,5 @@
     sysarg_t *id_buf, size_t buf_size, size_t *act_size)
 {
-	async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
+	async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
 
 	ipc_call_t answer;
Index: uspace/lib/c/generic/ns.c
===================================================================
--- uspace/lib/c/generic/ns.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/ns.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -43,5 +43,5 @@
 {
 	async_exch_t *exch = async_exchange_begin(session_ns);
-	int rc = async_connect_to_me(exch, 0, service, 0, NULL, NULL);
+	int rc = async_connect_to_me(exch, 0, service, 0);
 	async_exchange_end(exch);
 	
@@ -49,30 +49,6 @@
 }
 
-async_sess_t *service_connect_iface(exch_mgmt_t mgmt, sysarg_t iface,
-    service_t service, sysarg_t arg3)
-{
-	async_exch_t *exch = async_exchange_begin(session_ns);
-	if (!exch)
-		return NULL;
-	
-	async_sess_t *sess =
-	    async_connect_me_to(mgmt, exch, iface, service, arg3);
-	async_exchange_end(exch);
-	
-	if (!sess)
-		return NULL;
-	
-	/*
-	 * FIXME Ugly hack to work around limitation of implementing
-	 * parallel exchanges using multiple connections. Shift out
-	 * first argument for non-initial connections.
-	 */
-	async_sess_args_set(sess, iface, arg3, 0);
-	
-	return sess;
-}
 
-async_sess_t *service_connect_iface_extended(service_t service, iface_t iface,
-    sysarg_t arg3)
+async_sess_t *service_connect(service_t service, iface_t iface, sysarg_t arg3)
 {
 	async_exch_t *exch = async_exchange_begin(session_ns);
@@ -97,52 +73,6 @@
 }
 
-async_sess_t *service_connect(exch_mgmt_t mgmt, service_t service, sysarg_t arg3)
-{
-	async_exch_t *exch = async_exchange_begin(session_ns);
-	if (!exch)
-		return NULL;
-	
-	async_sess_t *sess =
-	    async_connect_me_to(mgmt, exch, 0, service, arg3);
-	async_exchange_end(exch);
-	
-	if (!sess)
-		return NULL;
-	
-	/*
-	 * FIXME Ugly hack to work around limitation of implementing
-	 * parallel exchanges using multiple connections. Shift out
-	 * first argument for non-initial connections.
-	 */
-	async_sess_args_set(sess, 0, arg3, 0);
-	
-	return sess;
-}
-
-async_sess_t *service_connect_blocking_iface(exch_mgmt_t mgmt, sysarg_t iface,
-    service_t service, sysarg_t arg3)
-{
-	async_exch_t *exch = async_exchange_begin(session_ns);
-	if (!exch)
-		return NULL;
-	async_sess_t *sess =
-	    async_connect_me_to_blocking(mgmt, exch, iface, service, arg3);
-	async_exchange_end(exch);
-	
-	if (!sess)
-		return NULL;
-	
-	/*
-	 * FIXME Ugly hack to work around limitation of implementing
-	 * parallel exchanges using multiple connections. Shift out
-	 * first argument for non-initial connections.
-	 */
-	async_sess_args_set(sess, iface, arg3, 0);
-	
-	return sess;
-}
-
-async_sess_t *service_connect_blocking_iface_extended(service_t service,
-    iface_t iface, sysarg_t arg3)
+async_sess_t *service_connect_blocking(service_t service, iface_t iface,
+    sysarg_t arg3)
 {
 	async_exch_t *exch = async_exchange_begin(session_ns);
@@ -164,59 +94,4 @@
 }
 
-async_sess_t *service_connect_blocking(exch_mgmt_t mgmt, service_t service,
-    sysarg_t arg3)
-{
-	async_exch_t *exch = async_exchange_begin(session_ns);
-	async_sess_t *sess =
-	    async_connect_me_to_blocking(mgmt, exch, 0, service, arg3);
-	async_exchange_end(exch);
-	
-	if (!sess)
-		return NULL;
-	
-	/*
-	 * FIXME Ugly hack to work around limitation of implementing
-	 * parallel exchanges using multiple connections. Shift out
-	 * first argument for non-initial connections.
-	 */
-	async_sess_args_set(sess, 0, arg3, 0);
-	
-	return sess;
-}
-
-/** Create bidirectional connection with a service
- *
- * @param[in] service         Service.
- * @param[in] arg1            First parameter.
- * @param[in] arg2            Second parameter.
- * @param[in] arg3            Third parameter.
- * @param[in] client_receiver Message receiver.
- *
- * @return Session to the service.
- * @return Other error codes as defined by async_connect_to_me().
- *
- */
-async_sess_t *service_bind(service_t service, sysarg_t arg1, sysarg_t arg2,
-    sysarg_t arg3, async_port_handler_t client_receiver)
-{
-	/* Connect to the needed service */
-	async_sess_t *sess =
-	    service_connect_blocking(EXCHANGE_SERIALIZE, service, 0);
-	if (sess != NULL) {
-		/* Request callback connection */
-		async_exch_t *exch = async_exchange_begin(sess);
-		int rc = async_connect_to_me(exch, arg1, arg2, arg3,
-		    client_receiver, NULL);
-		async_exchange_end(exch);
-		
-		if (rc != EOK) {
-			async_hangup(sess);
-			errno = rc;
-			return NULL;
-		}
-	}
-	
-	return sess;
-}
 
 int ns_ping(void)
Index: uspace/lib/c/generic/time.c
===================================================================
--- uspace/lib/c/generic/time.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/time.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -611,6 +611,6 @@
 			goto fallback;
 		
-		clock_conn = loc_service_connect(EXCHANGE_SERIALIZE,
-		    svc_id, IPC_FLAG_BLOCKING);
+		clock_conn = loc_service_connect(svc_id, INTERFACE_DDF,
+		    IPC_FLAG_BLOCKING);
 		if (!clock_conn)
 			goto fallback;
Index: uspace/lib/c/generic/vfs/vfs.c
===================================================================
--- uspace/lib/c/generic/vfs/vfs.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/generic/vfs/vfs.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -75,5 +75,5 @@
 	
 	while (vfs_sess == NULL)
-		vfs_sess = service_connect_blocking(EXCHANGE_PARALLEL, SERVICE_VFS,
+		vfs_sess = service_connect_blocking(SERVICE_VFS, INTERFACE_VFS,
 		    0);
 	
@@ -796,5 +796,5 @@
 }
 
-async_sess_t *fd_session(exch_mgmt_t mgmt, int fildes)
+async_sess_t *fd_session(int fildes, iface_t iface)
 {
 	struct stat stat;
@@ -810,5 +810,5 @@
 	}
 	
-	return loc_service_connect(mgmt, stat.service, 0);
+	return loc_service_connect(stat.service, iface, 0);
 }
 
Index: uspace/lib/c/include/async.h
===================================================================
--- uspace/lib/c/include/async.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/include/async.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -59,8 +59,9 @@
  *
  * @param callid ID of incoming call or 0 if connection initiated from
- *               inside using async_connect_to_me()
+ *               inside using async_create_callback_port()
  * @param call   Incoming call or 0 if connection initiated from inside
- * @param arg    Local argument passed from async_new_connection() or
- *               async_connect_to_me()
+ *               using async_create_callback_port()
+ * @param arg    Local argument.
+ *
  */
 typedef void (*async_port_handler_t)(ipc_callid_t, ipc_call_t *, void *);
@@ -82,4 +83,12 @@
 	EXCHANGE_ATOMIC = 0,
 	
+	/** Exchange management via mutual exclusion
+	 *
+	 * Suitable for any kind of client/server communication,
+	 * but can limit parallelism.
+	 *
+	 */
+	EXCHANGE_SERIALIZE = 1,
+	
 	/** Exchange management via phone cloning
 	 *
@@ -89,13 +98,5 @@
 	 *
 	 */
-	EXCHANGE_PARALLEL = 1,
-	
-	/** Exchange management via mutual exclusion
-	 *
-	 * Suitable for any kind of client/server communication,
-	 * but can limit parallelism.
-	 *
-	 */
-	EXCHANGE_SERIALIZE = 2
+	EXCHANGE_PARALLEL = 2
 } exch_mgmt_t;
 
@@ -358,6 +359,5 @@
 extern async_sess_t *async_connect_kbox(task_id_t);
 
-extern int async_connect_to_me(async_exch_t *, sysarg_t, sysarg_t, sysarg_t,
-    async_port_handler_t, void *);
+extern int async_connect_to_me(async_exch_t *, sysarg_t, sysarg_t, sysarg_t);
 
 extern int async_hangup(async_sess_t *);
Index: uspace/lib/c/include/devman.h
===================================================================
--- uspace/lib/c/include/devman.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/include/devman.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -42,6 +42,6 @@
 #include <stdbool.h>
 
-extern async_exch_t *devman_exchange_begin_blocking(devman_interface_t);
-extern async_exch_t *devman_exchange_begin(devman_interface_t);
+extern async_exch_t *devman_exchange_begin_blocking(iface_t);
+extern async_exch_t *devman_exchange_begin(iface_t);
 extern void devman_exchange_end(async_exch_t *);
 
@@ -53,7 +53,6 @@
 extern int devman_drv_fun_offline(devman_handle_t);
 
-extern async_sess_t *devman_device_connect(exch_mgmt_t, devman_handle_t,
-    unsigned int);
-extern async_sess_t *devman_parent_device_connect(exch_mgmt_t, devman_handle_t,
+extern async_sess_t *devman_device_connect(devman_handle_t, unsigned int);
+extern async_sess_t *devman_parent_device_connect(devman_handle_t,
     unsigned int);
 
Index: uspace/lib/c/include/ipc/devman.h
===================================================================
--- uspace/lib/c/include/ipc/devman.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/include/ipc/devman.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -141,11 +141,4 @@
 
 typedef enum {
-	DEVMAN_DRIVER = 1,
-	DEVMAN_CLIENT,
-	DEVMAN_CONNECT_TO_DEVICE,
-	DEVMAN_CONNECT_TO_PARENTS_DEVICE
-} devman_interface_t;
-
-typedef enum {
 	DEVMAN_DRIVER_REGISTER = IPC_FIRST_USER_METHOD,
 	DEVMAN_ADD_FUNCTION,
Index: pace/lib/c/include/ipc/driver.h
===================================================================
--- uspace/lib/c/include/ipc/driver.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ 	(revision )
@@ -1,50 +1,0 @@
-/*
- * Copyright (c) 2010 Lenka Trochtova 
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * - Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * - Redistributions in binary form must reproduce the above copyright
- *   notice, this list of conditions and the following disclaimer in the
- *   documentation and/or other materials provided with the distribution.
- * - The name of the author may not be used to endorse or promote products
- *   derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/** @addtogroup libdrv
- * @{
- */
-/** @file
- */
-
-#ifndef IPC_DRIVER_H_
-#define IPC_DRIVER_H_
-
-typedef enum {
-	DRIVER_DEVMAN = 1,
-	DRIVER_CLIENT,
-	DRIVER_DRIVER
-} driver_interface_t;
-
-
-#endif
-
-
-/**
- * @}
- */
Index: uspace/lib/c/include/ipc/inet.h
===================================================================
--- uspace/lib/c/include/ipc/inet.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/include/ipc/inet.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -37,16 +37,4 @@
 
 #include <ipc/common.h>
-
-/** Inet ports */
-typedef enum {
-	/** Default port */
-	INET_PORT_DEFAULT = 1,
-	/** Configuration port */
-	INET_PORT_CFG,
-	/** Ping service port */
-	INET_PORT_PING,
-	/** Ping6 service port */
-	INET_PORT_PING6
-} inet_port_t;
 
 /** Requests on Inet default port */
Index: uspace/lib/c/include/ipc/loc.h
===================================================================
--- uspace/lib/c/include/ipc/loc.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/include/ipc/loc.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -76,20 +76,4 @@
 } loc_event_t;
 
-/** Ports provided by location service.
- *
- * Every process that connects to loc must ask one of following
- * ports, otherwise connection will be refused.
- *
- */
-typedef enum {
-	/** Service supplier (server) port */
-	LOC_PORT_SUPPLIER = 1,
-	/** Service consumer (client) port */
-	LOC_PORT_CONSUMER,
-	/** Create new connection to instance of device that
-	    is specified by second argument of call. */
-	LOC_CONNECT_TO_SERVICE
-} loc_interface_t;
-
 typedef struct {
 	service_id_t id;
Index: uspace/lib/c/include/ipc/logger.h
===================================================================
--- uspace/lib/c/include/ipc/logger.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/include/ipc/logger.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -69,11 +69,4 @@
 } logger_writer_request_t;
 
-typedef enum {
-	/** Interface for controlling logger behavior. */
-	LOGGER_INTERFACE_CONTROL,
-	/** Interface for servers writing to the log. */
-	LOGGER_INTERFACE_WRITER
-} logger_interface_t;
-
 #endif
 
Index: uspace/lib/c/include/ipc/services.h
===================================================================
--- uspace/lib/c/include/ipc/services.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/include/ipc/services.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -52,14 +52,11 @@
 } service_t;
 
-#define SERVICE_NAME_CORECFG	"corecfg"
-#define SERVICE_NAME_DHCP       "net/dhcp"
-#define SERVICE_NAME_DNSR       "net/dnsr"
-#define SERVICE_NAME_INET       "net/inet"
-#define SERVICE_NAME_INETCFG    "net/inetcfg"
-#define SERVICE_NAME_INETPING   "net/inetping"
-#define SERVICE_NAME_INETPING6  "net/inetping6"
-#define SERVICE_NAME_NETCONF    "net/netconf"
-#define SERVICE_NAME_UDP	"net/udp"
-#define SERVICE_NAME_TCP	"net/tcp"
+#define SERVICE_NAME_CORECFG  "corecfg"
+#define SERVICE_NAME_DHCP     "net/dhcp"
+#define SERVICE_NAME_DNSR     "net/dnsr"
+#define SERVICE_NAME_INET     "net/inet"
+#define SERVICE_NAME_NETCONF  "net/netconf"
+#define SERVICE_NAME_UDP      "net/udp"
+#define SERVICE_NAME_TCP      "net/tcp"
 
 #endif
Index: uspace/lib/c/include/loc.h
===================================================================
--- uspace/lib/c/include/loc.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/include/loc.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -42,12 +42,10 @@
 typedef void (*loc_cat_change_cb_t)(void);
 
-extern async_exch_t *loc_exchange_begin_blocking(loc_interface_t);
-extern async_exch_t *loc_exchange_begin(loc_interface_t);
+extern async_exch_t *loc_exchange_begin_blocking(iface_t);
+extern async_exch_t *loc_exchange_begin(iface_t);
 extern void loc_exchange_end(async_exch_t *);
 
 extern int loc_server_register(const char *);
 extern int loc_service_register(const char *, service_id_t *);
-extern int loc_service_register_with_iface(const char *, service_id_t *,
-    sysarg_t);
 extern int loc_service_unregister(service_id_t);
 extern int loc_service_add_to_cat(service_id_t, category_id_t);
@@ -65,7 +63,5 @@
 extern loc_object_type_t loc_id_probe(service_id_t);
 
-extern async_sess_t *loc_service_connect_iface(service_id_t, iface_t,
-    unsigned int);
-extern async_sess_t *loc_service_connect(exch_mgmt_t, service_id_t,
+extern async_sess_t *loc_service_connect(service_id_t, iface_t,
     unsigned int);
 
Index: uspace/lib/c/include/ns.h
===================================================================
--- uspace/lib/c/include/ns.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/include/ns.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -42,14 +42,6 @@
 
 extern int service_register(service_t);
-extern async_sess_t *service_connect(exch_mgmt_t, service_t, sysarg_t);
-extern async_sess_t *service_connect_iface_extended(service_t, iface_t, sysarg_t);
-extern async_sess_t *service_connect_iface(exch_mgmt_t, sysarg_t, service_t, sysarg_t);
-extern async_sess_t *service_connect_blocking(exch_mgmt_t, service_t, sysarg_t);
-extern async_sess_t *service_connect_blocking_iface_extended(service_t, iface_t,
-    sysarg_t);
-extern async_sess_t *service_connect_blocking_iface(exch_mgmt_t, sysarg_t, service_t,
-    sysarg_t);
-extern async_sess_t *service_bind(service_t, sysarg_t, sysarg_t, sysarg_t,
-    async_port_handler_t);
+extern async_sess_t *service_connect(service_t, iface_t, sysarg_t);
+extern async_sess_t *service_connect_blocking(service_t, iface_t, sysarg_t);
 
 extern int ns_ping(void);
Index: uspace/lib/c/include/vfs/vfs_sess.h
===================================================================
--- uspace/lib/c/include/vfs/vfs_sess.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/c/include/vfs/vfs_sess.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -39,6 +39,6 @@
 #include <stdio.h>
 
-extern async_sess_t *fd_session(exch_mgmt_t, int);
-extern async_sess_t *fsession(exch_mgmt_t, FILE *);
+extern async_sess_t *fd_session(int, iface_t);
+extern async_sess_t *fsession(FILE *, iface_t);
 
 #endif
Index: uspace/lib/drv/generic/driver.c
===================================================================
--- uspace/lib/drv/generic/driver.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/drv/generic/driver.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -53,6 +53,4 @@
 #include <devman.h>
 
-#include <ipc/driver.h>
-
 #include "dev_iface.h"
 #include "ddf/driver.h"
@@ -130,5 +128,10 @@
 	
 	char *dev_name = NULL;
-	async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
+	int rc = async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
+	if (rc != EOK) {
+		async_answer_0(iid, rc);
+		return;
+	}
+	
 	dev->name = dev_name;
 	
@@ -278,5 +281,6 @@
 }
 
-static void driver_connection_devman(ipc_callid_t iid, ipc_call_t *icall)
+static void driver_connection_devman(ipc_callid_t iid, ipc_call_t *icall,
+    void *arg)
 {
 	/* Accept connection */
@@ -436,45 +440,14 @@
 }
 
-static void driver_connection_driver(ipc_callid_t iid, ipc_call_t *icall)
+static void driver_connection_driver(ipc_callid_t iid, ipc_call_t *icall,
+    void *arg)
 {
 	driver_connection_gen(iid, icall, true);
 }
 
-static void driver_connection_client(ipc_callid_t iid, ipc_call_t *icall)
+static void driver_connection_client(ipc_callid_t iid, ipc_call_t *icall,
+    void *arg)
 {
 	driver_connection_gen(iid, icall, false);
-}
-
-/** Function for handling connections to device driver. */
-static void driver_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
-	sysarg_t conn_type;
-
-	if (iid == 0) {
-		/* Callback connection from devman */
-		/* XXX Use separate handler for this type of connection */
-		conn_type = DRIVER_DEVMAN;
-	} else {
-		conn_type = IPC_GET_ARG1(*icall);
-	}
-
-	/* Select interface */
-	switch (conn_type) {
-	case DRIVER_DEVMAN:
-		/* Handle request from device manager */
-		driver_connection_devman(iid, icall);
-		break;
-	case DRIVER_DRIVER:
-		/* Handle request from drivers of child devices */
-		driver_connection_driver(iid, icall);
-		break;
-	case DRIVER_CLIENT:
-		/* Handle request from client applications */
-		driver_connection_client(iid, icall);
-		break;
-	default:
-		/* No such interface */
-		async_answer_0(iid, ENOENT);
-	}
 }
 
@@ -620,12 +593,13 @@
  * The session will be automatically closed when @a dev is destroyed.
  *
- * @param dev	Device
- * @param mgmt	Exchange management style
- * @return	New session or NULL if session could not be created
- */
-async_sess_t *ddf_dev_parent_sess_create(ddf_dev_t *dev, exch_mgmt_t mgmt)
+ * @param dev Device
+ *
+ * @return New session or NULL if session could not be created
+ *
+ */
+async_sess_t *ddf_dev_parent_sess_create(ddf_dev_t *dev)
 {
 	assert(dev->parent_sess == NULL);
-	dev->parent_sess = devman_parent_device_connect(mgmt, dev->handle,
+	dev->parent_sess = devman_parent_device_connect(dev->handle,
 	    IPC_FLAG_BLOCKING);
 
@@ -955,6 +929,18 @@
 	 * incoming connections.
 	 */
-	async_set_fallback_port_handler(driver_connection, NULL);
-	int rc = devman_driver_register(driver->name);
+	port_id_t port;
+	int rc = async_create_port(INTERFACE_DDF_DRIVER, driver_connection_driver,
+	    NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	rc = async_create_port(INTERFACE_DDF_DEVMAN, driver_connection_devman,
+	    NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	async_set_fallback_port_handler(driver_connection_client, NULL);
+	
+	rc = devman_driver_register(driver->name);
 	if (rc != EOK) {
 		printf("Error: Failed to register driver with device manager "
Index: uspace/lib/drv/generic/remote_ahci.c
===================================================================
--- uspace/lib/drv/generic/remote_ahci.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/drv/generic/remote_ahci.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -72,6 +72,5 @@
 	
 	if ((devn_size > 5) && (str_lcmp(devn, "ahci_", 5) == 0)) {
-		async_sess_t *sess = devman_device_connect(EXCHANGE_PARALLEL,
-		    funh, IPC_FLAG_BLOCKING);
+		async_sess_t *sess = devman_device_connect(funh, IPC_FLAG_BLOCKING);
 		
 		if (sess) {
Index: uspace/lib/drv/generic/remote_audio_pcm.c
===================================================================
--- uspace/lib/drv/generic/remote_audio_pcm.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/drv/generic/remote_audio_pcm.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -146,6 +146,5 @@
 	if (ret != EOK)
 		return NULL;
-	return devman_device_connect(EXCHANGE_SERIALIZE, device_handle,
-	    IPC_FLAG_BLOCKING);
+	return devman_device_connect(device_handle, IPC_FLAG_BLOCKING);
 }
 
@@ -158,5 +157,5 @@
 audio_pcm_sess_t *audio_pcm_open_service(service_id_t id)
 {
-	return loc_service_connect(EXCHANGE_SERIALIZE, id, IPC_FLAG_BLOCKING);
+	return loc_service_connect(id, INTERFACE_DDF, IPC_FLAG_BLOCKING);
 }
 
@@ -322,9 +321,13 @@
 
 	async_exch_t *exch = async_exchange_begin(sess);
+	
 	int ret = async_req_1_0(exch, DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
 	    IPC_M_AUDIO_PCM_REGISTER_EVENTS);
 	if (ret == EOK) {
-		ret = async_connect_to_me(exch, 0, 0, 0, event_callback, arg);
-	}
+		port_id_t port;
+		ret = async_create_callback_port(exch, INTERFACE_AUDIO_PCM_CB, 0, 0,
+		    event_callback, arg, &port);
+	}
+	
 	async_exchange_end(exch);
 	return ret;
Index: uspace/lib/drv/generic/remote_nic.c
===================================================================
--- uspace/lib/drv/generic/remote_nic.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/drv/generic/remote_nic.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -137,5 +137,7 @@
 	    NIC_CALLBACK_CREATE, &answer);
 	
-	rc = async_connect_to_me(exch, 0, 0, 0, cfun, carg);
+	port_id_t port;
+	rc = async_create_callback_port(exch, INTERFACE_NIC_CB, 0, 0,
+	    cfun, carg, &port);
 	if (rc != EOK) {
 		async_forget(req);
Index: uspace/lib/drv/include/ddf/driver.h
===================================================================
--- uspace/lib/drv/include/ddf/driver.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/drv/include/ddf/driver.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -117,5 +117,5 @@
 extern devman_handle_t ddf_dev_get_handle(ddf_dev_t *);
 extern const char *ddf_dev_get_name(ddf_dev_t *);
-extern async_sess_t *ddf_dev_parent_sess_create(ddf_dev_t *, exch_mgmt_t);
+extern async_sess_t *ddf_dev_parent_sess_create(ddf_dev_t *);
 extern async_sess_t *ddf_dev_parent_sess_get(ddf_dev_t *);
 extern ddf_fun_t *ddf_fun_create(ddf_dev_t *, fun_type_t, const char *);
Index: uspace/lib/fs/libfs.c
===================================================================
--- uspace/lib/fs/libfs.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/fs/libfs.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -342,5 +342,7 @@
 	 * Ask VFS for callback connection.
 	 */
-	async_connect_to_me(exch, 0, 0, 0, vfs_connection, NULL);
+	port_id_t port;
+	rc = async_create_callback_port(exch, INTERFACE_VFS_DRIVER_CB, 0, 0,
+	    vfs_connection, NULL, &port);
 	
 	/*
Index: uspace/lib/graph/graph.c
===================================================================
--- uspace/lib/graph/graph.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/graph/graph.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -606,6 +606,6 @@
 {
 	/* Find the visualizer or renderer with the given service ID. */
-	visualizer_t *vs = graph_get_visualizer(IPC_GET_ARG1(*icall));
-	renderer_t *rnd = graph_get_renderer(IPC_GET_ARG1(*icall));
+	visualizer_t *vs = graph_get_visualizer(IPC_GET_ARG2(*icall));
+	renderer_t *rnd = graph_get_renderer(IPC_GET_ARG2(*icall));
 	
 	if (vs != NULL)
Index: uspace/lib/gui/terminal.c
===================================================================
--- uspace/lib/gui/terminal.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/gui/terminal.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -679,5 +679,5 @@
 	
 	list_foreach(terms, link, terminal_t, cur) {
-		if (cur->dsid == (service_id_t) IPC_GET_ARG1(*icall)) {
+		if (cur->dsid == (service_id_t) IPC_GET_ARG2(*icall)) {
 			term = cur;
 			break;
Index: uspace/lib/gui/window.c
===================================================================
--- uspace/lib/gui/window.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/gui/window.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -623,6 +623,6 @@
 	}
 	
-	async_sess_t *reg_sess = loc_service_connect(EXCHANGE_SERIALIZE,
-	    reg_dsid, 0);
+	async_sess_t *reg_sess =
+	    loc_service_connect(reg_dsid, INTERFACE_COMPOSITOR, 0);
 	if (reg_sess == NULL) {
 		free(win);
@@ -639,5 +639,5 @@
 	}
 	
-	win->osess = loc_service_connect(EXCHANGE_SERIALIZE, out_dsid, 0);
+	win->osess = loc_service_connect(out_dsid, INTERFACE_COMPOSITOR, 0);
 	if (win->osess == NULL) {
 		free(win);
@@ -645,5 +645,5 @@
 	}
 	
-	win->isess = loc_service_connect(EXCHANGE_SERIALIZE, in_dsid, 0);
+	win->isess = loc_service_connect(in_dsid, INTERFACE_COMPOSITOR, 0);
 	if (win->isess == NULL) {
 		async_hangup(win->osess);
Index: uspace/lib/hound/src/protocol.c
===================================================================
--- uspace/lib/hound/src/protocol.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/hound/src/protocol.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -97,5 +97,5 @@
 	if (ret != EOK)
 		return NULL;
-	return loc_service_connect(EXCHANGE_PARALLEL, id, IPC_FLAG_BLOCKING);
+	return loc_service_connect(id, INTERFACE_HOUND, IPC_FLAG_BLOCKING);
 }
 
Index: uspace/lib/nic/src/nic_driver.c
===================================================================
--- uspace/lib/nic/src/nic_driver.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/nic/src/nic_driver.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -249,5 +249,5 @@
 	
 	/* Connect to the parent's driver. */
-	parent_sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
+	parent_sess = ddf_dev_parent_sess_create(dev);
 	if (parent_sess == NULL)
 		return EPARTY;
Index: uspace/lib/usb/src/dev.c
===================================================================
--- uspace/lib/usb/src/dev.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/usb/src/dev.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -50,6 +50,5 @@
 {
 	async_sess_t *parent_sess =
-	    devman_parent_device_connect(EXCHANGE_ATOMIC, device_handle,
-	        IPC_FLAG_BLOCKING);
+	    devman_parent_device_connect(device_handle, IPC_FLAG_BLOCKING);
 	if (!parent_sess)
 		return ENOMEM;
Index: uspace/lib/usb/src/hc.c
===================================================================
--- uspace/lib/usb/src/hc.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/usb/src/hc.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -51,6 +51,5 @@
 		assert(connection->hc_sess == NULL);
 		/* Parallel exchange for us */
-		connection->hc_sess = devman_device_connect(EXCHANGE_PARALLEL,
-		        connection->hc_handle, 0);
+		connection->hc_sess = devman_device_connect(connection->hc_handle, 0);
 		if (!connection->hc_sess) {
 			fibril_mutex_unlock(&connection->guard);
Index: uspace/lib/usbvirt/src/device.c
===================================================================
--- uspace/lib/usbvirt/src/device.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/lib/usbvirt/src/device.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -93,5 +93,5 @@
 	
 	async_sess_t *hcd_sess =
-	    devman_device_connect(EXCHANGE_SERIALIZE, handle, 0);
+	    devman_device_connect(handle, 0);
 	if (!hcd_sess)
 		return ENOMEM;
@@ -101,5 +101,9 @@
 	
 	async_exch_t *exch = async_exchange_begin(hcd_sess);
-	rc = async_connect_to_me(exch, 0, 0, 0, callback_connection, NULL);
+	
+	port_id_t port;
+	rc = async_create_callback_port(exch, INTERFACE_USBVIRT_CB, 0, 0,
+	    callback_connection, NULL, &port);
+	
 	async_exchange_end(exch);
 	
Index: uspace/srv/bd/part/guid_part/guid_part.c
===================================================================
--- uspace/srv/bd/part/guid_part/guid_part.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/bd/part/guid_part/guid_part.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -339,7 +339,7 @@
 
 	/* Get the device handle. */
-	dh = IPC_GET_ARG1(*icall);
-
-	/* 
+	dh = IPC_GET_ARG2(*icall);
+
+	/*
 	 * Determine which partition device is the client connecting to.
 	 * A linear search is not terribly fast, but we only do this
Index: uspace/srv/bd/part/mbr_part/mbr_part.c
===================================================================
--- uspace/srv/bd/part/mbr_part/mbr_part.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/bd/part/mbr_part/mbr_part.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -416,7 +416,7 @@
 
 	/* Get the device handle. */
-	dh = IPC_GET_ARG1(*icall);
-
-	/* 
+	dh = IPC_GET_ARG2(*icall);
+
+	/*
 	 * Determine which partition device is the client connecting to.
 	 * A linear search is not terribly fast, but we only do this
Index: uspace/srv/bd/sata_bd/sata_bd.c
===================================================================
--- uspace/srv/bd/sata_bd/sata_bd.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/bd/sata_bd/sata_bd.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -172,5 +172,5 @@
 
 	/* Get the device service ID. */
-	dsid = IPC_GET_ARG1(*icall);
+	dsid = IPC_GET_ARG2(*icall);
 
 	/* Determine which disk device is the client connecting to. */
Index: uspace/srv/devman/client_conn.c
===================================================================
--- uspace/srv/devman/client_conn.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/devman/client_conn.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -726,5 +726,5 @@
 
 /** Function for handling connections from a client to the device manager. */
-void devman_connection_client(ipc_callid_t iid, ipc_call_t *icall)
+void devman_connection_client(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
 	/* Accept connection. */
Index: uspace/srv/devman/client_conn.h
===================================================================
--- uspace/srv/devman/client_conn.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/devman/client_conn.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -36,5 +36,5 @@
 #include "devman.h"
 
-extern void devman_connection_client(ipc_callid_t, ipc_call_t *);
+extern void devman_connection_client(ipc_callid_t, ipc_call_t *, void *);
 
 #endif
Index: uspace/srv/devman/driver.c
===================================================================
--- uspace/srv/devman/driver.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/devman/driver.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -36,5 +36,4 @@
 #include <sys/stat.h>
 #include <io/log.h>
-#include <ipc/driver.h>
 #include <loc.h>
 #include <str_error.h>
@@ -573,11 +572,11 @@
 	
 	if (rc != EOK) {
-		/* TODO handle error */
-	}
-
-	/* Wait for answer from the driver. */
-	async_wait_for(req, &rc);
-
-	switch(rc) {
+		async_forget(req);
+	} else {
+		/* Wait for answer from the driver. */
+		async_wait_for(req, &rc);
+	}
+
+	switch (rc) {
 	case EOK:
 		dev->state = DEVICE_USABLE;
@@ -592,6 +591,4 @@
 	
 	dev->passed_to_driver = true;
-
-	return;
 }
 
Index: uspace/srv/devman/drv_conn.c
===================================================================
--- uspace/srv/devman/drv_conn.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/devman/drv_conn.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -49,5 +49,4 @@
 #include <io/log.h>
 #include <ipc/devman.h>
-#include <ipc/driver.h>
 #include <loc.h>
 
@@ -131,5 +130,5 @@
 	}
 	/* FIXME: Work around problem with callback sessions */
-	async_sess_args_set(driver->sess, DRIVER_DEVMAN, 0, 0);
+	async_sess_args_set(driver->sess, INTERFACE_DDF_DEVMAN, 0, 0);
 	
 	log_msg(LOG_DEFAULT, LVL_NOTE,
@@ -587,5 +586,5 @@
 
 /** Function for handling connections from a driver to the device manager. */
-void devman_connection_driver(ipc_callid_t iid, ipc_call_t *icall)
+void devman_connection_driver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
 	client_t *client;
Index: uspace/srv/devman/drv_conn.h
===================================================================
--- uspace/srv/devman/drv_conn.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/devman/drv_conn.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -37,5 +37,5 @@
 #include "devman.h"
 
-extern void devman_connection_driver(ipc_callid_t, ipc_call_t *);
+extern void devman_connection_driver(ipc_callid_t, ipc_call_t *, void *);
 
 #endif
Index: uspace/srv/devman/loc.c
===================================================================
--- uspace/srv/devman/loc.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/devman/loc.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -59,6 +59,5 @@
 	}
 	
-	loc_service_register_with_iface(loc_pathname,
-	    &fun->service_id, INTERFACE_DDF_CLIENT);
+	loc_service_register(loc_pathname, &fun->service_id);
 	
 	tree_add_loc_function(tree, fun);
Index: uspace/srv/devman/main.c
===================================================================
--- uspace/srv/devman/main.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/devman/main.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -49,5 +49,4 @@
 #include <io/log.h>
 #include <ipc/devman.h>
-#include <ipc/driver.h>
 #include <loc.h>
 
@@ -66,23 +65,23 @@
 dev_tree_t device_tree;
 
-static void devman_forward(ipc_callid_t iid, ipc_call_t *icall,
-    bool drv_to_parent)
+static void devman_connection_device(ipc_callid_t iid, ipc_call_t *icall,
+    void *arg)
 {
 	devman_handle_t handle = IPC_GET_ARG2(*icall);
-	devman_handle_t fwd_h;
-	fun_node_t *fun = NULL;
 	dev_node_t *dev = NULL;
 	
-	fun = find_fun_node(&device_tree, handle);
-	if (fun == NULL)
+	fun_node_t *fun = find_fun_node(&device_tree, handle);
+	if (fun == NULL) {
 		dev = find_dev_node(&device_tree, handle);
-	else {
+	} else {
 		fibril_rwlock_read_lock(&device_tree.rwlock);
+		
 		dev = fun->dev;
 		if (dev != NULL)
 			dev_add_ref(dev);
+		
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
 	}
-
+	
 	/*
 	 * For a valid function to connect to we need a device. The root
@@ -97,6 +96,6 @@
 		goto cleanup;
 	}
-
-	if (fun == NULL && !drv_to_parent) {
+	
+	if (fun == NULL) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, NAME ": devman_forward error - cannot "
 		    "connect to handle %" PRIun ", refers to a device.",
@@ -106,19 +105,8 @@
 	}
 	
-	driver_t *driver = NULL;
-	
 	fibril_rwlock_read_lock(&device_tree.rwlock);
 	
-	if (drv_to_parent) {
-		/* Connect to parent function of a device (or device function). */
-		if (dev->pfun->dev != NULL)
-			driver = dev->pfun->dev->drv;
-		
-		fwd_h = dev->pfun->handle;
-	} else {
-		/* Connect to the specified function */
-		driver = dev->drv;
-		fwd_h = handle;
-	}
+	/* Connect to the specified function */
+	driver_t *driver = dev->drv;
 	
 	fibril_rwlock_read_unlock(&device_tree.rwlock);
@@ -130,10 +118,4 @@
 		goto cleanup;
 	}
-	
-	int method;
-	if (drv_to_parent)
-		method = DRIVER_DRIVER;
-	else
-		method = DRIVER_CLIENT;
 	
 	if (!driver->sess) {
@@ -143,5 +125,5 @@
 		goto cleanup;
 	}
-
+	
 	if (fun != NULL) {
 		log_msg(LOG_DEFAULT, LVL_DEBUG,
@@ -155,5 +137,5 @@
 	
 	async_exch_t *exch = async_exchange_begin(driver->sess);
-	async_forward_fast(iid, exch, method, fwd_h, 0, IPC_FF_NONE);
+	async_forward_fast(iid, exch, INTERFACE_DDF_CLIENT, handle, 0, IPC_FF_NONE);
 	async_exchange_end(exch);
 	
@@ -166,20 +148,95 @@
 }
 
-/** Function for handling connections from a client forwarded by the location
- * service to the device manager. */
-static void devman_connection_loc(ipc_callid_t iid, ipc_call_t *icall)
-{
+static void devman_connection_parent(ipc_callid_t iid, ipc_call_t *icall,
+    void *arg)
+{
+	devman_handle_t handle = IPC_GET_ARG2(*icall);
+	dev_node_t *dev = NULL;
+	
+	fun_node_t *fun = find_fun_node(&device_tree, handle);
+	if (fun == NULL) {
+		dev = find_dev_node(&device_tree, handle);
+	} else {
+		fibril_rwlock_read_lock(&device_tree.rwlock);
+		
+		dev = fun->dev;
+		if (dev != NULL)
+			dev_add_ref(dev);
+		
+		fibril_rwlock_read_unlock(&device_tree.rwlock);
+	}
+	
+	/*
+	 * For a valid function to connect to we need a device. The root
+	 * function, for example, has no device and cannot be connected to.
+	 * This means @c dev needs to be valid regardless whether we are
+	 * connecting to a device or to a function.
+	 */
+	if (dev == NULL) {
+		log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding failed - no device or "
+		    "function with handle %" PRIun " was found.", handle);
+		async_answer_0(iid, ENOENT);
+		goto cleanup;
+	}
+	
+	driver_t *driver = NULL;
+	
+	fibril_rwlock_read_lock(&device_tree.rwlock);
+	
+	/* Connect to parent function of a device (or device function). */
+	if (dev->pfun->dev != NULL)
+		driver = dev->pfun->dev->drv;
+	
+	devman_handle_t fun_handle = dev->pfun->handle;
+	
+	fibril_rwlock_read_unlock(&device_tree.rwlock);
+	
+	if (driver == NULL) {
+		log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - " \
+		    "the device %" PRIun " is not in usable state.", handle);
+		async_answer_0(iid, ENOENT);
+		goto cleanup;
+	}
+	
+	if (!driver->sess) {
+		log_msg(LOG_DEFAULT, LVL_ERROR,
+		    "Could not forward to driver `%s'.", driver->name);
+		async_answer_0(iid, EINVAL);
+		goto cleanup;
+	}
+	
+	if (fun != NULL) {
+		log_msg(LOG_DEFAULT, LVL_DEBUG,
+		    "Forwarding request for `%s' function to driver `%s'.",
+		    fun->pathname, driver->name);
+	} else {
+		log_msg(LOG_DEFAULT, LVL_DEBUG,
+		    "Forwarding request for `%s' device to driver `%s'.",
+		    dev->pfun->pathname, driver->name);
+	}
+	
+	async_exch_t *exch = async_exchange_begin(driver->sess);
+	async_forward_fast(iid, exch, INTERFACE_DDF_DRIVER, fun_handle, 0, IPC_FF_NONE);
+	async_exchange_end(exch);
+	
+cleanup:
+	if (dev != NULL)
+		dev_del_ref(dev);
+	
+	if (fun != NULL)
+		fun_del_ref(fun);
+}
+
+static void devman_forward(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+{
+	iface_t iface = IPC_GET_ARG1(*icall);
 	service_id_t service_id = IPC_GET_ARG2(*icall);
-	fun_node_t *fun;
-	dev_node_t *dev;
-	devman_handle_t handle;
-	driver_t *driver;
-
-	fun = find_loc_tree_function(&device_tree, service_id);
+	
+	fun_node_t *fun = find_loc_tree_function(&device_tree, service_id);
 	
 	fibril_rwlock_read_lock(&device_tree.rwlock);
 	
-	if (fun == NULL || fun->dev == NULL || fun->dev->drv == NULL) {
-		log_msg(LOG_DEFAULT, LVL_WARN, "devman_connection_loc(): function "
+	if ((fun == NULL) || (fun->dev == NULL) || (fun->dev->drv == NULL)) {
+		log_msg(LOG_DEFAULT, LVL_WARN, "devman_forward(): function "
 		    "not found.\n");
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
@@ -188,49 +245,19 @@
 	}
 	
-	dev = fun->dev;
-	driver = dev->drv;
-	handle = fun->handle;
+	dev_node_t *dev = fun->dev;
+	driver_t *driver = dev->drv;
+	devman_handle_t handle = fun->handle;
 	
 	fibril_rwlock_read_unlock(&device_tree.rwlock);
 	
 	async_exch_t *exch = async_exchange_begin(driver->sess);
-	async_forward_fast(iid, exch, DRIVER_CLIENT, handle, 0,
-	    IPC_FF_NONE);
+	async_forward_fast(iid, exch, iface, handle, 0, IPC_FF_NONE);
 	async_exchange_end(exch);
 	
 	log_msg(LOG_DEFAULT, LVL_DEBUG,
-	    "Forwarding loc service request for `%s' function to driver `%s'.",
+	    "Forwarding service request for `%s' function to driver `%s'.",
 	    fun->pathname, driver->name);
-
+	
 	fun_del_ref(fun);
-}
-
-/** Function for handling connections to device manager. */
-static void devman_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
-	/* Select port. */
-	switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
-	case DEVMAN_DRIVER:
-		devman_connection_driver(iid, icall);
-		break;
-	case DEVMAN_CLIENT:
-		devman_connection_client(iid, icall);
-		break;
-	case DEVMAN_CONNECT_TO_DEVICE:
-		/* Connect client to selected device. */
-		devman_forward(iid, icall, false);
-		break;
-	case INTERFACE_DDF_CLIENT:
-		/* Someone connected through loc node. */
-		devman_connection_loc(iid, icall);
-		break;
-	case DEVMAN_CONNECT_TO_PARENTS_DEVICE:
-		/* Connect client to selected device. */
-		devman_forward(iid, icall, true);
-		break;
-	default:
-		/* No such interface */
-		async_answer_0(iid, ENOENT);
-	}
 }
 
@@ -298,5 +325,27 @@
 	async_set_client_data_constructor(devman_client_data_create);
 	async_set_client_data_destructor(devman_client_data_destroy);
-	async_set_fallback_port_handler(devman_connection, NULL);
+	
+	port_id_t port;
+	rc = async_create_port(INTERFACE_DDF_DRIVER,
+	    devman_connection_driver, NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	rc = async_create_port(INTERFACE_DDF_CLIENT,
+	    devman_connection_client, NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	rc = async_create_port(INTERFACE_DEVMAN_DEVICE,
+	    devman_connection_device, NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	rc = async_create_port(INTERFACE_DEVMAN_PARENT,
+	    devman_connection_parent, NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	async_set_fallback_port_handler(devman_forward, NULL);
 	
 	if (!devman_init()) {
Index: uspace/srv/fs/cdfs/cdfs.c
===================================================================
--- uspace/srv/fs/cdfs/cdfs.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/fs/cdfs/cdfs.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -73,6 +73,6 @@
 	}
 	
-	async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-	    SERVICE_VFS, 0);
+	async_sess_t *vfs_sess = service_connect_blocking(SERVICE_VFS,
+	    INTERFACE_VFS_DRIVER, 0);
 	if (!vfs_sess) {
 		printf("%s: Unable to connect to VFS\n", NAME);
Index: uspace/srv/fs/exfat/exfat.c
===================================================================
--- uspace/srv/fs/exfat/exfat.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/fs/exfat/exfat.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -75,6 +75,6 @@
 		goto err;
 
-	async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-	    SERVICE_VFS, 0);
+	async_sess_t *vfs_sess = service_connect_blocking(SERVICE_VFS,
+	    INTERFACE_VFS_DRIVER, 0);
 	if (!vfs_sess) {
 		printf(NAME ": failed to connect to VFS\n");
Index: uspace/srv/fs/ext4fs/ext4fs.c
===================================================================
--- uspace/srv/fs/ext4fs/ext4fs.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/fs/ext4fs/ext4fs.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -65,6 +65,6 @@
 	}
 	
-	async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-	    SERVICE_VFS, 0);
+	async_sess_t *vfs_sess = service_connect_blocking(SERVICE_VFS,
+	    INTERFACE_VFS_DRIVER, 0);
 	if (!vfs_sess) {
 		printf("%s: Failed to connect to VFS\n", NAME);
Index: uspace/srv/fs/fat/fat.c
===================================================================
--- uspace/srv/fs/fat/fat.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/fs/fat/fat.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -75,6 +75,6 @@
 		goto err;
 	
-	async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-	    SERVICE_VFS, 0);
+	async_sess_t *vfs_sess = service_connect_blocking(SERVICE_VFS,
+	    INTERFACE_VFS_DRIVER, 0);
 	if (!vfs_sess) {
 		printf(NAME ": failed to connect to VFS\n");
Index: uspace/srv/fs/locfs/locfs.c
===================================================================
--- uspace/srv/fs/locfs/locfs.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/fs/locfs/locfs.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -77,6 +77,6 @@
 	}
 	
-	async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-	    SERVICE_VFS, 0);
+	async_sess_t *vfs_sess = service_connect_blocking(SERVICE_VFS,
+	    INTERFACE_VFS_DRIVER, 0);
 	if (!vfs_sess) {
 		printf("%s: Unable to connect to VFS\n", NAME);
Index: uspace/srv/fs/locfs/locfs_ops.c
===================================================================
--- uspace/srv/fs/locfs/locfs_ops.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/fs/locfs/locfs_ops.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -264,6 +264,6 @@
 			fibril_mutex_unlock(&services_mutex);
 			
-			async_sess_t *sess = loc_service_connect(
-			    EXCHANGE_SERIALIZE, node->service_id, 0);
+			async_sess_t *sess = loc_service_connect(node->service_id,
+			    INTERFACE_FS, 0);
 			
 			fibril_mutex_lock(&services_mutex);
Index: uspace/srv/fs/mfs/mfs.c
===================================================================
--- uspace/srv/fs/mfs/mfs.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/fs/mfs/mfs.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -73,6 +73,6 @@
 	}
 
-	async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-	    SERVICE_VFS, 0);
+	async_sess_t *vfs_sess = service_connect_blocking(SERVICE_VFS,
+	    INTERFACE_VFS_DRIVER, 0);
 
 	if (!vfs_sess) {
Index: uspace/srv/fs/tmpfs/tmpfs.c
===================================================================
--- uspace/srv/fs/tmpfs/tmpfs.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/fs/tmpfs/tmpfs.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -80,6 +80,6 @@
 	}
 	
-	async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-	    SERVICE_VFS, 0);
+	async_sess_t *vfs_sess = service_connect_blocking(SERVICE_VFS,
+	    INTERFACE_VFS_DRIVER, 0);
 	if (!vfs_sess) {
 		printf(NAME ": Unable to connect to VFS\n");
Index: uspace/srv/fs/udf/udf.c
===================================================================
--- uspace/srv/fs/udf/udf.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/fs/udf/udf.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -74,5 +74,5 @@
 	
 	async_sess_t *vfs_sess =
-	    service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_VFS, 0);
+	    service_connect_blocking(SERVICE_VFS, INTERFACE_VFS_DRIVER, 0);
 	if (!vfs_sess) {
 		log_msg(LOG_DEFAULT, LVL_FATAL, "Failed to connect to VFS");
Index: uspace/srv/hid/compositor/compositor.c
===================================================================
--- uspace/srv/hid/compositor/compositor.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hid/compositor/compositor.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -896,5 +896,5 @@
 	ipc_call_t call;
 	ipc_callid_t callid;
-	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*icall);
+	service_id_t service_id = (service_id_t) IPC_GET_ARG2(*icall);
 
 	/* Allocate resources for new window and register it to the location service. */
@@ -1175,5 +1175,5 @@
 	async_sess_t *sess;
 
-	sess = loc_service_connect(EXCHANGE_SERIALIZE, sid, 0);
+	sess = loc_service_connect(sid, INTERFACE_DDF, 0);
 	if (sess == NULL) {
 		printf("%s: Unable to connect to visualizer %s\n", NAME, svc);
@@ -1182,5 +1182,9 @@
 
 	async_exch_t *exch = async_exchange_begin(sess);
-	rc = async_connect_to_me(exch, sid, 0, 0, vsl_notifications, NULL);
+	
+	port_id_t port;
+	rc = async_create_callback_port(exch, INTERFACE_VISUALIZER_CB, 0, 0,
+	    vsl_notifications, NULL, &port);
+	
 	async_exchange_end(exch);
 
@@ -2145,5 +2149,5 @@
 	}
 
-	sess = loc_service_connect(EXCHANGE_ATOMIC, dsid, 0);
+	sess = loc_service_connect(dsid, INTERFACE_INPUT, 0);
 	if (sess == NULL) {
 		printf("%s: Unable to connect to input service %s\n", NAME,
Index: uspace/srv/hid/console/console.c
===================================================================
--- uspace/srv/hid/console/console.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hid/console/console.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -508,5 +508,5 @@
 	
 	for (size_t i = 0; i < CONSOLE_COUNT; i++) {
-		if (consoles[i].dsid == (service_id_t) IPC_GET_ARG1(*icall)) {
+		if (consoles[i].dsid == (service_id_t) IPC_GET_ARG2(*icall)) {
 			cons = &consoles[i];
 			break;
@@ -536,5 +536,5 @@
 	}
 
-	sess = loc_service_connect(EXCHANGE_ATOMIC, dsid, 0);
+	sess = loc_service_connect(dsid, INTERFACE_INPUT, 0);
 	if (sess == NULL) {
 		printf("%s: Unable to connect to input service %s\n", NAME,
@@ -561,5 +561,5 @@
 	int rc = loc_service_get_id(svc, &dsid, 0);
 	if (rc == EOK) {
-		sess = loc_service_connect(EXCHANGE_SERIALIZE, dsid, 0);
+		sess = loc_service_connect(dsid, INTERFACE_OUTPUT, 0);
 		if (sess == NULL) {
 			printf("%s: Unable to connect to output service %s\n",
Index: uspace/srv/hid/input/ctl/kbdev.c
===================================================================
--- uspace/srv/hid/input/ctl/kbdev.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hid/input/ctl/kbdev.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -94,6 +94,6 @@
 static int kbdev_ctl_init(kbd_dev_t *kdev)
 {
-	async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE,
-	    kdev->svc_id, 0);
+	async_sess_t *sess = loc_service_connect(kdev->svc_id,
+	    INTERFACE_DDF, 0);
 	if (sess == NULL) {
 		printf("%s: Failed starting session with '%s.'\n", NAME,
@@ -120,5 +120,8 @@
 	}
 	
-	int rc = async_connect_to_me(exch, 0, 0, 0, kbdev_callback_conn, kbdev);
+	port_id_t port;
+	int rc = async_create_callback_port(exch, INTERFACE_KBD_CB, 0, 0,
+	    kbdev_callback_conn, kbdev, &port);
+	
 	if (rc != EOK) {
 		printf("%s: Failed creating callback connection from '%s'.\n",
Index: uspace/srv/hid/input/input.c
===================================================================
--- uspace/srv/hid/input/input.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hid/input/input.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -745,6 +745,6 @@
 	if (irc_service) {
 		while (irc_sess == NULL)
-			irc_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-			    SERVICE_IRC, 0);
+			irc_sess = service_connect_blocking(SERVICE_IRC,
+			    INTERFACE_IRC, 0);
 	}
 	
Index: uspace/srv/hid/input/port/adb.c
===================================================================
--- uspace/srv/hid/input/port/adb.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hid/input/port/adb.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -69,5 +69,5 @@
 		return rc;
 	
-	dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
+	dev_sess = loc_service_connect(service_id, INTERFACE_DDF, 0);
 	if (dev_sess == NULL) {
 		printf("%s: Failed to connect to device\n", NAME);
@@ -82,5 +82,8 @@
 	}
 	
-	rc = async_connect_to_me(exch, 0, 0, 0, kbd_port_events, NULL);
+	port_id_t port;
+	rc = async_create_callback_port(exch, INTERFACE_ADB_CB, 0, 0,
+	    kbd_port_events, NULL, &port);
+	
 	async_exchange_end(exch);
 	if (rc != EOK) {
Index: uspace/srv/hid/input/port/adb_mouse.c
===================================================================
--- uspace/srv/hid/input/port/adb_mouse.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hid/input/port/adb_mouse.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -84,5 +84,5 @@
 		return rc;
 	
-	dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
+	dev_sess = loc_service_connect(service_id, INTERFACE_DDF, 0);
 	if (dev_sess == NULL) {
 		printf("%s: Failed to connect to device\n", NAME);
@@ -98,5 +98,8 @@
 	
 	/* NB: The callback connection is slotted for removal */
-	rc = async_connect_to_me(exch, 0, 0, 0, mouse_port_events, NULL);
+	port_id_t port;
+	rc = async_create_callback_port(exch, INTERFACE_ADB_CB, 0, 0,
+	    mouse_port_events, NULL, &port);
+	
 	async_exchange_end(exch);
 	if (rc != EOK) {
Index: uspace/srv/hid/input/port/chardev.c
===================================================================
--- uspace/srv/hid/input/port/chardev.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hid/input/port/chardev.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -84,5 +84,5 @@
 	}
 	
-	dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id,
+	dev_sess = loc_service_connect(service_id, INTERFACE_DDF,
 	    IPC_FLAG_BLOCKING);
 	if (dev_sess == NULL) {
@@ -98,6 +98,8 @@
 	}
 	
-	/* NB: The callback connection is slotted for removal */
-	rc = async_connect_to_me(exch, 0, 0, 0, kbd_port_events, NULL);
+	port_id_t port;
+	rc = async_create_callback_port(exch, INTERFACE_CHAR_CB, 0, 0,
+	    kbd_port_events, NULL, &port);
+	
 	async_exchange_end(exch);
 	
Index: uspace/srv/hid/input/proto/mousedev.c
===================================================================
--- uspace/srv/hid/input/proto/mousedev.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hid/input/proto/mousedev.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -118,6 +118,5 @@
 static int mousedev_proto_init(mouse_dev_t *mdev)
 {
-	async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE,
-	    mdev->svc_id, 0);
+	async_sess_t *sess = loc_service_connect(mdev->svc_id, INTERFACE_DDF, 0);
 	if (sess == NULL) {
 		printf("%s: Failed starting session with '%s'\n", NAME,
@@ -143,5 +142,8 @@
 	}
 	
-	int rc = async_connect_to_me(exch, 0, 0, 0, mousedev_callback_conn, mousedev);
+	port_id_t port;
+	int rc = async_create_callback_port(exch, INTERFACE_MOUSE_CB, 0, 0,
+	    mousedev_callback_conn, mousedev, &port);
+	
 	async_exchange_end(exch);
 	async_hangup(sess);
Index: uspace/srv/hid/isdv4_tablet/main.c
===================================================================
--- uspace/srv/hid/isdv4_tablet/main.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hid/isdv4_tablet/main.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -69,8 +69,10 @@
 	async_sess_t *sess =
 	    async_callback_receive(EXCHANGE_SERIALIZE);
+	
 	fibril_mutex_lock(&client_mutex);
-		if (client_sess == NULL) {
-			client_sess = sess;
-		}
+	
+	if (client_sess == NULL)
+		client_sess = sess;
+	
 	fibril_mutex_unlock(&client_mutex);
 
@@ -262,5 +264,5 @@
 	printf(NAME ": Using serial port %s\n", serial_port_name);
 
-	async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
+	async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
 	    IPC_FLAG_BLOCKING);
 	if (!sess) {
Index: uspace/srv/hid/remcons/remcons.c
===================================================================
--- uspace/srv/hid/remcons/remcons.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hid/remcons/remcons.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -217,5 +217,5 @@
 {
 	/* Find the user. */
-	telnet_user_t *user = telnet_user_get_for_client_connection(IPC_GET_ARG1(*icall));
+	telnet_user_t *user = telnet_user_get_for_client_connection(IPC_GET_ARG2(*icall));
 	if (user == NULL) {
 		async_answer_0(iid, ENOENT);
Index: uspace/srv/hw/bus/cuda_adb/cuda_adb.c
===================================================================
--- uspace/srv/hw/bus/cuda_adb/cuda_adb.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/hw/bus/cuda_adb/cuda_adb.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -214,5 +214,5 @@
 
 	/* Get the device handle. */
-	dsid = IPC_GET_ARG1(*icall);
+	dsid = IPC_GET_ARG2(*icall);
 
 	/* Determine which disk device is the client connecting to. */
Index: uspace/srv/locsrv/locsrv.c
===================================================================
--- uspace/srv/locsrv/locsrv.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/locsrv/locsrv.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -467,7 +467,4 @@
 	}
 	
-	/* Set the interface, if any. */
-	service->forward_interface = IPC_GET_ARG1(*icall);
-
 	/* Get fqsn */
 	char *fqsn;
@@ -702,5 +699,5 @@
  *
  */
-static void loc_forward(ipc_callid_t callid, ipc_call_t *call)
+static void loc_forward(ipc_callid_t callid, ipc_call_t *call, void *arg)
 {
 	fibril_mutex_lock(&services_list_mutex);
@@ -709,4 +706,5 @@
 	 * Get ID from request
 	 */
+	iface_t iface = IPC_GET_ARG1(*call);
 	service_id_t id = IPC_GET_ARG2(*call);
 	loc_service_t *svc = loc_service_find_id(id);
@@ -719,11 +717,5 @@
 	
 	async_exch_t *exch = async_exchange_begin(svc->server->sess);
-	
-	if (svc->forward_interface == 0)
-		async_forward_fast(callid, exch, svc->id, 0, 0, IPC_FF_NONE);
-	else
-		async_forward_fast(callid, exch, svc->forward_interface,
-		    svc->id, 0, IPC_FF_NONE);
-	
+	async_forward_fast(callid, exch, iface, svc->id, 0, IPC_FF_NONE);
 	async_exchange_end(exch);
 	
@@ -1376,5 +1368,5 @@
  *
  */
-static void loc_connection_supplier(ipc_callid_t iid, ipc_call_t *icall)
+static void loc_connection_supplier(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
 	/* Accept connection */
@@ -1434,5 +1426,5 @@
  *
  */
-static void loc_connection_consumer(ipc_callid_t iid, ipc_call_t *icall)
+static void loc_connection_consumer(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
 	/* Accept connection */
@@ -1501,27 +1493,4 @@
 }
 
-/** Function for handling connections to location service
- *
- */
-static void loc_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
-	/* Select interface */
-	switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
-	case LOC_PORT_SUPPLIER:
-		loc_connection_supplier(iid, icall);
-		break;
-	case LOC_PORT_CONSUMER:
-		loc_connection_consumer(iid, icall);
-		break;
-	case LOC_CONNECT_TO_SERVICE:
-		/* Connect client to selected service */
-		loc_forward(iid, icall);
-		break;
-	default:
-		/* No such interface */
-		async_answer_0(iid, ENOENT);
-	}
-}
-
 /**
  *
@@ -1536,12 +1505,23 @@
 	}
 	
-	/* Set a handler of incomming connections */
-	async_set_fallback_port_handler(loc_connection, NULL);
-	
-	/* Register location service at naming service */
-	int rc = service_register(SERVICE_LOC);
+	port_id_t port;
+	int rc = async_create_port(INTERFACE_LOC_SUPPLIER,
+	    loc_connection_supplier, NULL, &port);
 	if (rc != EOK)
 		return rc;
 	
+	rc = async_create_port(INTERFACE_LOC_CONSUMER,
+	    loc_connection_consumer, NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	/* Set a handler of incomming connections */
+	async_set_fallback_port_handler(loc_forward, NULL);
+	
+	/* Register location service at naming service */
+	rc = service_register(SERVICE_LOC);
+	if (rc != EOK)
+		return rc;
+	
 	printf("%s: Accepting connections\n", NAME);
 	async_manager();
Index: uspace/srv/locsrv/locsrv.h
===================================================================
--- uspace/srv/locsrv/locsrv.h	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/locsrv/locsrv.h	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -107,7 +107,4 @@
 	/** Supplier of this service */
 	loc_server_t *server;
-	
-	/** Use this interface when forwarding to server. */
-	sysarg_t forward_interface;
 } loc_service_t;
 
Index: uspace/srv/logger/main.c
===================================================================
--- uspace/srv/logger/main.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/logger/main.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -48,19 +48,14 @@
 #include "logger.h"
 
-static void connection_handler(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+static void connection_handler_control(ipc_callid_t iid, ipc_call_t *icall,
+    void *arg)
 {
-	logger_interface_t iface = IPC_GET_ARG1(*icall);
+	logger_connection_handler_control(iid);
+}
 
-	switch (iface) {
-	case LOGGER_INTERFACE_CONTROL:
-		logger_connection_handler_control(iid);
-		break;
-	case LOGGER_INTERFACE_WRITER:
-		logger_connection_handler_writer(iid);
-		break;
-	default:
-		async_answer_0(iid, EINVAL);
-		break;
-	}
+static void connection_handler_writer(ipc_callid_t iid, ipc_call_t *icall,
+    void *arg)
+{
+	logger_connection_handler_writer(iid);
 }
 
@@ -73,8 +68,17 @@
 		parse_level_settings(argv[i]);
 	}
-
-	async_set_fallback_port_handler(connection_handler, NULL);
 	
-	int rc = service_register(SERVICE_LOGGER);
+	port_id_t port;
+	int rc = async_create_port(INTERFACE_LOGGER_CONTROL,
+	    connection_handler_control, NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	rc = async_create_port(INTERFACE_LOGGER_WRITER,
+	    connection_handler_writer, NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	rc = service_register(SERVICE_LOGGER);
 	if (rc != EOK) {
 		printf(NAME ": failed to register: %s.\n", str_error(rc));
Index: uspace/srv/net/ethip/ethip.c
===================================================================
--- uspace/srv/net/ethip/ethip.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/net/ethip/ethip.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -147,5 +147,5 @@
 	service_id_t sid;
 
-	sid = (service_id_t)IPC_GET_ARG1(*icall);
+	sid = (service_id_t) IPC_GET_ARG2(*icall);
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_client_conn(%u)", (unsigned)sid);
 	nic = ethip_nic_find_by_iplink_sid(sid);
Index: uspace/srv/net/ethip/ethip_nic.c
===================================================================
--- uspace/srv/net/ethip/ethip_nic.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/net/ethip/ethip_nic.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -162,5 +162,5 @@
 	}
 	
-	nic->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid, 0);
+	nic->sess = loc_service_connect(sid, INTERFACE_DDF, 0);
 	if (nic->sess == NULL) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting '%s'", nic->svc_name);
Index: uspace/srv/net/inetsrv/inet_link.c
===================================================================
--- uspace/srv/net/inetsrv/inet_link.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/net/inetsrv/inet_link.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -177,5 +177,5 @@
 	}
 
-	ilink->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid, 0);
+	ilink->sess = loc_service_connect(sid, INTERFACE_IPLINK, 0);
 	if (ilink->sess == NULL) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting '%s'", ilink->svc_name);
Index: uspace/srv/net/inetsrv/inetsrv.c
===================================================================
--- uspace/srv/net/inetsrv/inetsrv.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/net/inetsrv/inetsrv.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -77,16 +77,30 @@
 };
 
-static void inet_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
-
 static FIBRIL_MUTEX_INITIALIZE(client_list_lock);
 static LIST_INITIALIZE(client_list);
 
+static void inet_default_conn(ipc_callid_t, ipc_call_t *, void *);
+
 static int inet_init(void)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_init()");
 	
-	async_set_fallback_port_handler(inet_client_conn, NULL);
-	
-	int rc = loc_server_register(NAME);
+	port_id_t port;
+	int rc = async_create_port(INTERFACE_INET,
+	    inet_default_conn, NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	rc = async_create_port(INTERFACE_INETCFG,
+	    inet_cfg_conn, NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	rc = async_create_port(INTERFACE_INETPING,
+	    inetping_conn, NULL, &port);
+	if (rc != EOK)
+		return rc;
+	
+	rc = loc_server_register(NAME);
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server (%d).", rc);
@@ -95,20 +109,5 @@
 	
 	service_id_t sid;
-	rc = loc_service_register_with_iface(SERVICE_NAME_INET, &sid,
-	    INET_PORT_DEFAULT);
-	if (rc != EOK) {
-		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
-		return EEXIST;
-	}
-	
-	rc = loc_service_register_with_iface(SERVICE_NAME_INETCFG, &sid,
-	    INET_PORT_CFG);
-	if (rc != EOK) {
-		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
-		return EEXIST;
-	}
-	
-	rc = loc_service_register_with_iface(SERVICE_NAME_INETPING, &sid,
-	    INET_PORT_PING);
+	rc = loc_service_register(SERVICE_NAME_INET, &sid);
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
@@ -429,26 +428,4 @@
 }
 
-static void inet_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
-	sysarg_t port;
-
-	port = IPC_GET_ARG1(*icall);
-
-	switch (port) {
-	case INET_PORT_DEFAULT:
-		inet_default_conn(iid, icall, arg);
-		break;
-	case INET_PORT_CFG:
-		inet_cfg_conn(iid, icall, arg);
-		break;
-	case INET_PORT_PING:
-		inetping_conn(iid, icall, arg);
-		break;
-	default:
-		async_answer_0(iid, ENOTSUP);
-		break;
-	}
-}
-
 static inet_client_t *inet_client_find(uint8_t proto)
 {
Index: uspace/srv/net/slip/slip.c
===================================================================
--- uspace/srv/net/slip/slip.c	(revision 0dd16778197e5f50b6e77a71d9b8aeb33b2ad863)
+++ uspace/srv/net/slip/slip.c	(revision f9b2cb4cf365498e1fe141b1aa66950fbc3dcb17)
@@ -328,5 +328,5 @@
 	 * char_dev at the same time.
 	 */
-	sess_out = loc_service_connect(EXCHANGE_SERIALIZE, svcid, 0);
+	sess_out = loc_service_connect(svcid, INTERFACE_DDF, 0);
 	if (!sess_out) {
 		log_msg(LOG_DEFAULT, LVL_ERROR,
@@ -337,5 +337,5 @@
 	slip_iplink.arg = sess_out;
 
-	sess_in = loc_service_connect(EXCHANGE_SERIALIZE, svcid, 0);
+	sess_in = loc_service_connect(svcid, INTERFACE_DDF, 0);
 	if (!sess_in) {
 		log_msg(LOG_DEFAULT, LVL_ERROR,
