mpm/mpmd: Move to request_xport()/commit_xport() architecture

This commit combines code from various branches to finally enable both
UDP and Liberio transports.

5 files changed, 386 insertions, 166 deletions

diff --git a/mpm/python/usrp_mpm/liberiotable.py b/mpm/python/usrp_mpm/liberiotable.py
index 8f70c5ebe..6f2454379 100644
--- a/mpm/python/usrp_mpm/liberiotable.py
+++ b/mpm/python/usrp_mpm/liberiotable.py
@@ -19,15 +19,13 @@ class LiberioDispatcherTable(object):
     label -- A label that can be used by udev to find a UIO device
     """
 
-    MTU_OFFSET = 0x80000
-
     def __init__(self, label):
         self.log = get_logger(label)
         self._regs = UIO(label=label, read_only=False)
         self.poke32 = self._regs.poke32
         self.peek32 = self._regs.peek32
 
-    def set_route(self, sid, dma_channel, mtu):
+    def set_route(self, sid, dma_channel):
         """
         Sets up routing in the Liberio dispatcher. From sid, only the
         destination part is important. After this call, any CHDR packet with the
@@ -35,14 +33,10 @@ class LiberioDispatcherTable(object):
 
         sid -- Full SID, but only destination part matters.
         dma_channel -- The DMA channel to which these packets should get routed.
-        mtu -- Max size of bytes per packet. This is important to get right. The
-               DMA implementation will pad packets smaller than MTU up to the
-               mtu value, so making MTU extra large is inefficient. Packets
-               larger than MTU will get chopped up. Even worse.
         """
         self.log.debug(
-            "Routing SID `{sid}' to DMA channel `{chan}', MTU {mtu} bytes.".format(
-                sid=str(sid), chan=dma_channel, mtu=mtu
+            "Routing SID `{sid}' to DMA channel `{chan}'.".format(
+                sid=str(sid), chan=dma_channel
             )
         )
         def poke_and_trace(addr, data):
@@ -51,18 +45,12 @@ class LiberioDispatcherTable(object):
                 addr, data
             ))
             self.poke32(addr, data)
-
         # Poke reg for destination channel
-        # Poke reg for MTU
         try:
             poke_and_trace(
                 0 + 4 * sid.dst_ep,
                 dma_channel,
             )
-            poke_and_trace(
-                self.MTU_OFFSET + 4 * sid.dst_ep,
-                int(mtu / 8),
-            )
         except Exception as ex:
             self.log.error(
                 "Unexpected exception while setting route: %s",
diff --git a/mpm/python/usrp_mpm/mpmtypes.py b/mpm/python/usrp_mpm/mpmtypes.py
index 48f40f47e..a7f94fca8 100644
--- a/mpm/python/usrp_mpm/mpmtypes.py
+++ b/mpm/python/usrp_mpm/mpmtypes.py
@@ -47,22 +47,46 @@ class SharedState(object):
 
 
 class SID(object):
-    def __init__(self, sid=0):
-        self.src_addr = sid >> 24
-        self.src_ep = (sid >> 16) & 0xFF
-        self.dst_addr = (sid >> 8) & 0xFF
-        self.dst_ep = sid & 0xFF
+    """
+    Python representation of a 32-bit SID.
+    """
+    def __init__(self, sid=None):
+        sid = sid or 0
+        if isinstance(sid, str):
+            src, dst = sid.split(">")
+            if src.find(':') != -1:
+                self.src_addr, self.src_ep = \
+                    [int(x, 16) for x in src.split(':', 2)]
+            else:
+                self.src_addr, self.src_ep = \
+                    [int(x, 10) for x in src.split('.', 2)]
+            if dst.find(':') != -1:
+                self.dst_addr, self.dst_ep = \
+                    [int(x, 16) for x in dst.split(':', 2)]
+            else:
+                self.dst_addr, self.dst_ep = \
+                    [int(x, 10) for x in dst.split('.', 2)]
+        else:
+            print(sid)
+            self.src_addr = sid >> 24
+            self.src_ep = (sid >> 16) & 0xFF
+            self.dst_addr = (sid >> 8) & 0xFF
+            self.dst_ep = sid & 0xFF
 
     def set_src_addr(self, new_addr):
-        self.src_addr =  new_addr & 0xFF
+        " Return source address (e.g. 02:30>00:01 -> 2) "
+        self.src_addr = new_addr & 0xFF
 
     def set_dst_addr(self, new_addr):
+        " Return destination address (e.g. 02:30>00:01 -> 0) "
         self.dst_addr = new_addr & 0xFF
 
     def set_src_ep(self, new_addr):
+        " Return source endpoint (e.g. 02:30>00:01 -> 0x30) "
         self.src_ep = new_addr & 0xFF
 
     def set_dst_ep(self, new_addr):
+        " Return destination endpoint (e.g. 02:30>00:01 -> 0) "
         self.dst_ep = new_addr & 0xFF
 
     def reversed(self):
@@ -75,6 +99,7 @@ class SID(object):
         return new_sid
 
     def get(self):
+        " Return SID as 32-bit number "
         return (self.src_addr << 24) | (self.src_ep << 16) | (self.dst_addr << 8) | self.dst_ep
 
     def __repr__(self):
diff --git a/mpm/python/usrp_mpm/periph_manager/base.py b/mpm/python/usrp_mpm/periph_manager/base.py
index 0a3882102..a619247ad 100644
--- a/mpm/python/usrp_mpm/periph_manager/base.py
+++ b/mpm/python/usrp_mpm/periph_manager/base.py
@@ -28,7 +28,6 @@ from six import iteritems, itervalues
 from ..mpmlog import get_logger
 from .udev import get_eeprom_paths
 from .udev import get_spidev_nodes
-from usrp_mpm import net
 from usrp_mpm import dtoverlay
 from usrp_mpm import eeprom
 from usrp_mpm.rpc_server import no_claim, no_rpc
@@ -154,8 +153,6 @@ class PeriphManagerBase(object):
         self._init_dboards(args.override_db_pids)
         self._available_endpoints = list(range(256))
         self._init_args = {}
-        self.log.info("Identifying available network interfaces...")
-        self._chdr_interfaces = self._init_interfaces(self.chdr_interfaces)
 
     def _init_mboard_with_eeprom(self):
         """
@@ -309,23 +306,6 @@ class PeriphManagerBase(object):
             self.dboards.append(db_class(dboard_idx, **dboard_info))
         self.log.info("Found {} daughterboard(s).".format(len(self.dboards)))
 
-    def _init_interfaces(self, possible_ifaces):
-        """
-        Initialize the list of network interfaces
-        """
-        self.log.trace("Testing available interfaces out of `{}'".format(
-            possible_ifaces
-        ))
-        valid_ifaces = net.get_valid_interfaces(possible_ifaces)
-        if len(valid_ifaces):
-            self.log.debug("Found CHDR interfaces: `{}'".format(valid_ifaces))
-        else:
-            self.log.warning("No CHDR interfaces found!")
-        return {
-            x: net.get_iface_info(x)
-            for x in valid_ifaces
-        }
-
     def init(self, args):
         """
         Run the mboard initialization. This is typically done at the beginning
@@ -626,3 +606,71 @@ class PeriphManagerBase(object):
                       "is not implemented.", dboard_idx)
         raise NotImplementedError
 
+    #######################################################################
+    # Transport API
+    #######################################################################
+    def request_xport(
+            self,
+            dst_address,
+            suggested_src_address,
+            xport_type,
+        ):
+        """
+        When setting up a CHDR connection, this is the first call to be
+        made. This function will return a list of dictionaries, each
+        describing a way to open an CHDR connection.
+        All transports requested are bidirectional.
+
+        The callee must maintain a lock on the available CHDR xports. After
+        calling request_xport(), the caller needs to pick one of the
+        dictionaries, possibly amend data (e.g., if the connection is an
+        Ethernet connection, then we need to know the source port, but more
+        details on that in commit_xport()'s documentation).
+        One way to implement a lock is to simply lock a mutex here and
+        unlock it in commit_xport(), even though there are probably more
+        nuanced solutions.
+
+        Arguments:
+        dst_sid -- The destination part of the connection, i.e., which
+                   RFNoC block are we connecting to. Example: 0x0230
+        suggested_src_sid -- The source part of the connection, i.e.,
+                             what's the source address of packets going to
+                             the destination at dst_sid. This is a
+                             suggestion, MPM can override this. Example:
+                             0x0001.
+        xport_type -- One of the following strings: CTRL, ASYNC_MSG,
+                      TX_DATA, RX_DATA. See also xports_type_t in UHD.
+
+        The return value is a list of dictionaries. Every dictionary has
+        the following key/value pairs:
+        - type: Type of transport, e.g., "UDP", "liberio".
+        - ipv4 (UDP only): IPv4 address to connect to.
+        - port (UDP only): IP port to connect to.
+        - rx_mtu: In bytes, the max size RX packets can have (RX means going
+                  from device to UHD)
+        - tx_mtu: In bytes, the max size TX packets can have (TX means going
+                  from UHD to device)
+        """
+        raise NotImplementedError("request_xport() not implemented.")
+
+    def commit_xport(self, xport_info):
+        """
+        When setting up a CHDR connection, this is the second call to be
+        made.
+
+        Arguments:
+        xport_info -- A dictionary (string -> string). The dictionary must
+                      have been originally created by request_xport(), but
+                      additional key/value pairs need to be added.
+
+        All transports need to also provide:
+        - rx_mtu: In bytes, the max number of bytes going from device to UHD
+        - tx_mtu: In bytes, the max number of bytes going from UHD to device
+
+        UDP transports need to also provide:
+        - src_ipv4: IPv4 address the connection is coming from.
+        - src_port: IP port the connection is coming from.
+        """
+        raise NotImplementedError("commit_xport() not implemented.")
+
+
diff --git a/mpm/python/usrp_mpm/periph_manager/n310.py b/mpm/python/usrp_mpm/periph_manager/n310.py
index a011d3559..93772b1ad 100644
--- a/mpm/python/usrp_mpm/periph_manager/n310.py
+++ b/mpm/python/usrp_mpm/periph_manager/n310.py
@@ -22,7 +22,7 @@ from __future__ import print_function
 import os
 import copy
 import shutil
-from six import iteritems
+from six import iteritems, itervalues
 from builtins import object
 from .base import PeriphManagerBase
 from ..net import get_iface_addrs
@@ -31,6 +31,7 @@ from ..net import get_mac_addr
 from ..mpmtypes import SID
 from usrp_mpm.uio import UIO
 from usrp_mpm.rpc_server import no_claim, no_rpc
+from usrp_mpm import net
 from ..sysfs_gpio import SysFSGPIO
 from ..ethtable import EthDispatcherTable
 from ..liberiotable import LiberioDispatcherTable
@@ -42,6 +43,9 @@ N3XX_DEFAULT_TIME_SOURCE = 'internal'
 N3XX_DEFAULT_ENABLE_GPS = True
 N3XX_DEFAULT_ENABLE_FPGPIO = True
 
+###############################################################################
+# Additional peripheral controllers specific to Magnesium
+###############################################################################
 class TCA6424(object):
     """
     Abstraction layer for the port/gpio expander
@@ -204,6 +208,224 @@ class FP_GPIO(object):
         assert index in range(self._gpiosize)
         return self._gpios.get(self._offset+index)
 
+###############################################################################
+# Transport managers
+###############################################################################
+class XportMgrUDP(object):
+    """
+    Transport manager for UDP connections
+    """
+    # Map Eth devices to UIO labels
+    eth_tables = {'eth1': 'misc-enet-regs0', 'eth2': 'misc-enet-regs1'}
+
+    def __init__(self, possible_chdr_ifaces, log):
+        self.log = log
+        self._possible_chdr_ifaces = possible_chdr_ifaces
+        self.log.info("Identifying available network interfaces...")
+        self._chdr_ifaces = \
+            self._init_interfaces(self._possible_chdr_ifaces)
+        self._eth_dispatchers = {
+            x: EthDispatcherTable(self.eth_tables.get(x))
+            for x in list(self._chdr_ifaces.keys())
+        }
+        for ifname, table in iteritems(self._eth_dispatchers):
+            table.set_ipv4_addr(self._chdr_ifaces[ifname]['ip_addr'])
+
+    def _init_interfaces(self, possible_ifaces):
+        """
+        Initialize the list of network interfaces
+        """
+        self.log.trace("Testing available interfaces out of `{}'".format(
+            possible_ifaces
+        ))
+        valid_ifaces = net.get_valid_interfaces(possible_ifaces)
+        if len(valid_ifaces):
+            self.log.debug("Found CHDR interfaces: `{}'".format(valid_ifaces))
+        else:
+            self.log.warning("No CHDR interfaces found!")
+        return {
+            x: net.get_iface_info(x)
+            for x in valid_ifaces
+        }
+
+    def init(self, args):
+        """
+        Call this when the user calls 'init' on the periph manager
+        """
+        # TODO re-run _init_interfaces, IP addresses could have changed since
+        # bootup
+        for _, table in iteritems(self._eth_dispatchers):
+            if 'forward_eth' in args or 'forward_bcast' in args:
+                table.set_forward_policy(
+                    args.get('forward_eth', False),
+                    args.get('forward_bcast', False)
+                )
+        if 'preload_ethtables' in args:
+            self._preload_ethtables(
+                self._eth_dispatchers,
+                args['preload_ethtables']
+            )
+
+    def deinit(self):
+        " Clean up after a session terminates "
+        pass
+
+    def _preload_ethtables(self, eth_dispatchers, table_file):
+        """
+        Populates the ethernet tables from a JSON file
+        """
+        import json
+        try:
+            eth_table_data = json.load(open(table_file))
+        except ValueError as ex:
+            self.log.warning(
+                "Bad values in preloading table file: %s",
+                str(ex)
+            )
+            return
+        self.log.info(
+            "Preloading Ethernet dispatch tables from JSON file `%s'.",
+            table_file
+        )
+        for eth_iface, data in iteritems(eth_table_data):
+            if eth_iface not in eth_dispatchers:
+                self.log.warning(
+                    "Request to preload eth dispatcher table for "
+                    "iface `{}', but no such interface is "
+                    "registered. Known interfaces: {}".format(
+                        str(eth_iface),
+                        ",".join(eth_dispatchers.keys())
+                    )
+                )
+                continue
+            eth_dispatcher = eth_dispatchers[eth_iface]
+            self.log.debug("Preloading {} dispatch table".format(eth_iface))
+            try:
+                for dst_ep, udp_data in iteritems(data):
+                    sid = SID()
+                    sid.set_dst_ep(int(dst_ep))
+                    eth_dispatcher.set_route(
+                        sid,
+                        udp_data['ip_addr'],
+                        udp_data['port'],
+                        udp_data.get('mac_addr', None)
+                    )
+            except ValueError as ex:
+                self.log.warning(
+                    "Bad values in preloading table file: %s",
+                    str(ex)
+                )
+
+    def request_xport(
+            self,
+            sid,
+            xport_type,
+        ):
+        """
+        Return UDP xport info
+        """
+        assert xport_type in ('CTRL', 'ASYNC_MSG', 'TX_DATA', 'RX_DATA')
+        xport_info = {
+            'type': 'UDP',
+            # TODO what about eth2, huh?
+            'ipv4': str(self._chdr_ifaces['eth1']['ip_addr']),
+            'port': '49153', # FIXME no hardcoding
+            'send_sid': str(sid)
+        }
+        return [xport_info]
+
+    def commit_xport(self, sid, xport_info):
+        """
+        fuu
+        """
+        # TODO do error checking on the xport_info
+        self.log.trace("Committing UDP transport using xport_info `%s'",
+                       str(xport_info))
+        sender_addr = xport_info['src_ipv4']
+        sender_port = int(xport_info['src_port'])
+        self.log.trace("Incoming connection is coming from %s:%d",
+                       sender_addr, sender_port)
+        mac_addr = get_mac_addr(sender_addr)
+        if mac_addr is None:
+            raise RuntimeError(
+                "Could not find MAC address for IP address {}".format(
+                    sender_addr))
+        self.log.trace("Incoming connection is coming from %s",
+                       mac_addr)
+        # Remove hardcodings in the following lines FIXME
+        my_xbar = lib.xbar.xbar.make("/dev/crossbar0") # TODO
+        my_xbar.set_route(sid.src_addr, 0) # TODO
+        eth_dispatcher = self._eth_dispatchers['eth1'] # TODO
+        eth_dispatcher.set_route(sid.reversed(), sender_addr, sender_port)
+        self.log.trace("UDP transport successfully committed!")
+        return True
+
+class XportMgrLiberio(object):
+    """
+    Transport manager for UDP connections
+    """
+    # udev label for the UIO device that controls the DMA engine
+    liberio_label = 'liberio'
+
+    def __init__(self, log):
+        self.log = log
+        self._dma_dispatcher = LiberioDispatcherTable(self.liberio_label)
+        self._data_chan_ctr = 0
+        self._max_chan = 10 # TODO get this number from somewhere
+
+    def init(self, args):
+        """
+        Call this when the user calls 'init' on the periph manager
+        """
+        pass
+
+    def deinit(self):
+        " Clean up after a session terminates "
+        self._data_chan_ctr = 0
+
+    def request_xport(
+            self,
+            sid,
+            xport_type,
+        ):
+        """
+        Return liberio xport info
+        """
+        assert xport_type in ('CTRL', 'ASYNC_MSG', 'TX_DATA', 'RX_DATA')
+        if xport_type == 'CTRL':
+            chan = 0
+        elif xport_type == 'ASYNC_MSG':
+            chan = 1
+        else:
+            chan = 2 + self._data_chan_ctr
+            self._data_chan_ctr += 1
+        xport_info = {
+            'type': 'liberio',
+            'send_sid': str(sid),
+            'muxed': str(xport_type in ('CTRL', 'ASYNC_MSG')),
+            'dma_chan': str(chan),
+            'tx_dev': "/dev/tx-dma{}".format(chan),
+            'rx_dev': "/dev/rx-dma{}".format(chan),
+        }
+        self.log.trace("Liberio: Chan: {} TX Device: {} RX Device: {}".format(
+            chan, xport_info['tx_dev'], xport_info['rx_dev']))
+        self.log.trace("Liberio channel is muxed: %s",
+                       "Yes" if xport_info['muxed'] else "No")
+        return [xport_info]
+
+    def commit_xport(self, sid, xport_info):
+        " Commit liberio transport "
+        chan = int(xport_info['dma_chan'])
+        my_xbar = lib.xbar.xbar.make("/dev/crossbar0") # TODO
+        my_xbar.set_route(sid.src_addr, 2) # TODO
+        self._dma_dispatcher.set_route(sid.reversed(), chan)
+        self.log.trace("Liberio transport successfully committed!")
+        return True
+
+
+###############################################################################
+# Main Class
+###############################################################################
 class n310(PeriphManagerBase):
     """
     Holds N310 specific attributes and methods
@@ -230,7 +452,6 @@ class n310(PeriphManagerBase):
     dboard_spimaster_addrs = ["e0006000.spi", "e0007000.spi"]
     chdr_interfaces = ['eth1', 'eth2']
     # N310-specific settings
-    eth_tables = {'eth1': 'misc-enet-regs0', 'eth2': 'misc-enet-regs1'}
     # Path to N310 FPGA bin file
     # This file will always contain the current image, regardless of SFP type,
     # dboard, etc. The host is responsible for providing a compatible image
@@ -242,8 +463,6 @@ class n310(PeriphManagerBase):
             'callback': "update_fpga",
         },
     }
-    # udev label for the UIO device that controls the DMA engine
-    liberio_label = 'liberio'
 
     def __init__(self, args):
         super(n310, self).__init__(args)
@@ -273,16 +492,11 @@ class n310(PeriphManagerBase):
         self._clock_source = None
         self._time_source = None
         self._init_ref_clock_and_time(args.default_args)
-        # Define some attributes so PyLint stays quiet
-        self._eth_dispatchers = None
-        self._dma_dispatcher = None
-        # Init Ethernet
-        self._eth_dispatchers = {
-            x: EthDispatcherTable(self.eth_tables.get(x))
-            for x in list(self._chdr_interfaces.keys())
+        # Init CHDR transports
+        self._xport_mgrs = {
+            'udp': XportMgrUDP(self.chdr_interfaces, self.log),
+            'liberio': XportMgrLiberio(self.log),
         }
-        for ifname, table in iteritems(self._eth_dispatchers):
-            table.set_ipv4_addr(self._chdr_interfaces[ifname]['ip_addr'])
         # Init complete.
         self.log.info("mboard info: {}".format(self.mboard_info))
 
@@ -315,112 +529,71 @@ class n310(PeriphManagerBase):
         dispatchers accordingly.
         """
         result = super(n310, self).init(args)
-        for _, table in iteritems(self._eth_dispatchers):
-            if 'forward_eth' in args or 'forward_bcast' in args:
-                table.set_forward_policy(
-                    args.get('forward_eth', False),
-                    args.get('forward_bcast', False)
-                )
-        if 'preload_ethtables' in args:
-            self._preload_ethtables(
-                self._eth_dispatchers,
-                args['preload_ethtables']
-            )
-        self._dma_dispatcher = LiberioDispatcherTable(self.liberio_label)
+        for xport_mgr in itervalues(self._xport_mgrs):
+            xport_mgr.init(args)
         return result
 
-    def _preload_ethtables(self, eth_dispatchers, table_file):
+    def deinit(self):
         """
-        Populates the ethernet tables from a JSON file
+        Clean up after a UHD session terminates.
         """
-        import json
-        try:
-            eth_table_data = json.load(open(table_file))
-        except ValueError as ex:
-            self.log.warning(
-                "Bad values in preloading table file: %s",
-                str(ex)
+        super(n310, self).deinit()
+        for xport_mgr in itervalues(self._xport_mgrs):
+            xport_mgr.deinit()
+
+    ###########################################################################
+    # Transport API
+    ###########################################################################
+    def request_xport(
+            self,
+            dst_address,
+            suggested_src_address,
+            xport_type
+        ):
+        """
+        See PeriphManagerBase.request_xport() for docs.
+        """
+        # For now, we always accept the suggestion if available, or fail
+        src_address = suggested_src_address
+        if src_address not in self._available_endpoints:
+            raise RuntimeError("no more sids yo")
+        sid = SID(src_address << 16 | dst_address)
+        self.log.debug(
+            "request_xport(dst=0x%04X, suggested_src_address=0x%04X, xport_type=%s): " \
+            "operating on SID: %s",
+            dst_address, suggested_src_address, str(xport_type), str(sid))
+        # FIXME token!
+        assert self.mboard_info['rpc_connection'] in ('remote', 'local')
+        if self.mboard_info['rpc_connection'] == 'remote':
+            return self._xport_mgrs['udp'].request_xport(
+                sid,
+                xport_type,
+            )
+        elif self.mboard_info['rpc_connection'] == 'local':
+            return self._xport_mgrs['liberio'].request_xport(
+                sid,
+                xport_type,
             )
-            return
-        self.log.info(
-            "Preloading Ethernet dispatch tables from JSON file `%s'.",
-            table_file
-        )
-        for eth_iface, data in iteritems(eth_table_data):
-            if eth_iface not in eth_dispatchers:
-                self.log.warning(
-                    "Request to preload eth dispatcher table for "
-                    "iface `{}', but no such interface is "
-                    "registered. Known interfaces: {}".format(
-                        str(eth_iface),
-                        ",".join(eth_dispatchers.keys())
-                    )
-                )
-                continue
-            eth_dispatcher = eth_dispatchers[eth_iface]
-            self.log.debug("Preloading {} dispatch table".format(eth_iface))
-            try:
-                for dst_ep, udp_data in iteritems(data):
-                    sid = SID()
-                    sid.set_dst_ep(int(dst_ep))
-                    eth_dispatcher.set_route(
-                        sid,
-                        udp_data['ip_addr'],
-                        udp_data['port'],
-                        udp_data.get('mac_addr', None)
-                    )
-            except ValueError as ex:
-                self.log.warning(
-                    "Bad values in preloading table file: %s",
-                    str(ex)
-                )
 
-    def _allocate_sid(self, sender_addr, port, sid, xbar_src_addr, xbar_src_port, new_ep): # FIXME mtu
+    def commit_xport(self, xport_info):
         """
-        Get the MAC address of the sender and store it in the FPGA ARP table
+        See PeriphManagerBase.commit_xport() for docs.
+
+        Reminder: All connections are incoming, i.e. "send" or "TX" means
+        remote device to local device, and "receive" or "RX" means this local
+        device to remote device. "Remote device" can be, for example, a UHD
+        session.
         """
+        ## Go, go, go
+        assert self.mboard_info['rpc_connection'] in ('remote', 'local')
+        sid = SID(xport_info['send_sid'])
+        self._available_endpoints.remove(sid.src_ep)
+        self.log.debug("Committing transport for SID %s, xport info: %s",
+                       str(sid), str(xport_info))
         if self.mboard_info['rpc_connection'] == 'remote':
-            self.log.debug("Preparing for UDP connection")
-            mac_addr = get_mac_addr(sender_addr)
-            if new_ep not in self._available_endpoints:
-                raise RuntimeError("no more sids yo")
-            self._available_endpoints.remove(new_ep)
-            if mac_addr is not None:
-                if sender_addr not in self.sid_endpoints:
-                    self.sid_endpoints.update({sender_addr: (new_ep,)})
-                else:
-                    current_allocation = self.sid_endpoints.get(sender_addr)
-                    new_allocation = current_allocation + (new_ep,)
-                    self.sid_endpoints.update({sender_addr: new_allocation})
-                sid = SID(sid)
-                sid.set_src_addr(xbar_src_addr)
-                sid.set_src_ep(new_ep)
-                my_xbar = lib.xbar.xbar.make("/dev/crossbar0") # TODO
-                my_xbar.set_route(xbar_src_addr, 0) # TODO
-                eth_dispatcher = self._eth_dispatchers['eth1'] # TODO
-                eth_dispatcher.set_route(sid.reversed(), sender_addr, port)
-            return sid.get()
-        else:
-            self.log.debug("Preparing for liberio connection")
-            if new_ep not in self._available_endpoints:
-                raise RuntimeError("no more sids yo")
-            self._available_endpoints.remove(new_ep)
-            if sender_addr not in self.sid_endpoints:
-                self.sid_endpoints.update({sender_addr: (new_ep,)})
-            else:
-                current_allocation = self.sid_endpoints.get(sender_addr)
-                new_allocation = current_allocation + (new_ep,)
-                self.sid_endpoints.update({sender_addr: new_allocation})
-            sid = SID(sid)
-            sid.set_src_addr(xbar_src_addr)
-            sid.set_src_ep(new_ep)
-            my_xbar = lib.xbar.xbar.make("/dev/crossbar0") # TODO
-            my_xbar.set_route(xbar_src_addr, 2) # TODO
-            mtu = 0
-            assert False # This path is not yet done
-            self._dma_dispatcher.set_route(sid.reversed(), new_ep, mtu)
-
-        return sid.get()
+            return self._xport_mgrs['udp'].commit_xport(sid, xport_info)
+        elif self.mboard_info['rpc_connection'] == 'local':
+            return self._xport_mgrs['liberio'].commit_xport(sid, xport_info)
 
     def get_clock_sources(self):
         " Lists all available clock sources. "
diff --git a/mpm/python/usrp_mpm/rpc_server.py b/mpm/python/usrp_mpm/rpc_server.py
index 10d37a3d7..2cd44dfe5 100644
--- a/mpm/python/usrp_mpm/rpc_server.py
+++ b/mpm/python/usrp_mpm/rpc_server.py
@@ -54,7 +54,7 @@ class MPMServer(RPCServer):
     RPC calls to appropiate calls in the periph_manager and dboard_managers.
     """
     # This is a list of methods in this class which require a claim
-    default_claimed_methods = ['init', 'reclaim', 'unclaim', 'allocate_sid']
+    default_claimed_methods = ['init', 'reclaim', 'unclaim']
 
     def __init__(self, state, mgr, *args, **kwargs):
         self.log = get_main_logger().getChild('RPCServer')
@@ -332,20 +332,6 @@ class MPMServer(RPCServer):
         """
         return self._last_error
 
-    def allocate_sid(self, token, *args):
-        """
-        Forwards the call to periph_manager._allocate_sid with the client ip addresss
-        as argument. Should be used to setup interfaces
-        """
-        if not self._check_token_valid(token):
-            self.log.warning("Attempt to allocate SID without valid token!")
-            return None
-        try:
-            return self.periph_manager._allocate_sid(self.client_host, *args)
-        except Exception as ex:
-            self._last_error = str(ex)
-            self.log.error("allocate_sid() failed: %s", str(ex))
-            raise
 
 
 def _rpc_server_process(shared_state, port, mgr):