source: bootcd/isolinux/syslinux-6.03/gpxe/src/drivers/net/ipoib.c @ 26ffad7

/*
 * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

FILE_LICENCE ( GPL2_OR_LATER );

#include <stdint.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <byteswap.h>
#include <errno.h>
#include <gpxe/errortab.h>
#include <gpxe/if_arp.h>
#include <gpxe/iobuf.h>
#include <gpxe/netdevice.h>
#include <gpxe/infiniband.h>
#include <gpxe/ib_pathrec.h>
#include <gpxe/ib_mcast.h>
#include <gpxe/ipoib.h>

/** @file
 *
 * IP over Infiniband
 */

/** Number of IPoIB send work queue entries */
#define IPOIB_NUM_SEND_WQES 2

/** Number of IPoIB receive work queue entries */
#define IPOIB_NUM_RECV_WQES 4

/** Number of IPoIB completion entries */
#define IPOIB_NUM_CQES 8

/** An IPoIB device */
struct ipoib_device {
        /** Network device */
        struct net_device *netdev;
        /** Underlying Infiniband device */
        struct ib_device *ibdev;
        /** Completion queue */
        struct ib_completion_queue *cq;
        /** Queue pair */
        struct ib_queue_pair *qp;
        /** Broadcast MAC */
        struct ipoib_mac broadcast;
        /** Joined to IPv4 broadcast multicast group
         *
         * This flag indicates whether or not we have initiated the
         * join to the IPv4 broadcast multicast group.
         */
        int broadcast_joined;
        /** IPv4 broadcast multicast group membership */
        struct ib_mc_membership broadcast_membership;
};

/** Broadcast IPoIB address */
static struct ipoib_mac ipoib_broadcast = {
        .flags__qpn = htonl ( IB_QPN_BROADCAST ),
        .gid.u.bytes =  { 0xff, 0x12, 0x40, 0x1b, 0x00, 0x00, 0x00, 0x00,
                          0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff },
};

/** Link status for "broadcast join in progress" */
#define EINPROGRESS_JOINING ( EINPROGRESS | EUNIQ_01 )

/** Human-readable message for the link status */
struct errortab ipoib_errors[] __errortab = {
        { EINPROGRESS_JOINING, "Joining" },
};

/****************************************************************************
 *
 * IPoIB peer cache
 *
 ****************************************************************************
 */

/**
 * IPoIB peer address
 *
 * The IPoIB link-layer header is only four bytes long and so does not
 * have sufficient room to store IPoIB MAC address(es).  We therefore
 * maintain a cache of MAC addresses identified by a single-byte key,
 * and abuse the spare two bytes within the link-layer header to
 * communicate these MAC addresses between the link-layer code and the
 * netdevice driver.
 */
struct ipoib_peer {
        /** Key */
        uint8_t key;
        /** MAC address */
        struct ipoib_mac mac;
};

/** Number of IPoIB peer cache entries
 *
 * Must be a power of two.
 */
#define IPOIB_NUM_CACHED_PEERS 4

/** IPoIB peer address cache */
static struct ipoib_peer ipoib_peer_cache[IPOIB_NUM_CACHED_PEERS];

/** Oldest IPoIB peer cache entry index */
static unsigned int ipoib_peer_cache_idx = 1;

/**
 * Look up cached peer by key
 *
 * @v key               Peer cache key
 * @ret peer            Peer cache entry, or NULL
 */
static struct ipoib_peer * ipoib_lookup_peer_by_key ( unsigned int key ) {
        struct ipoib_peer *peer;
        unsigned int i;

        for ( i = 0 ; i < IPOIB_NUM_CACHED_PEERS ; i++ ) {
                peer = &ipoib_peer_cache[i];
                if ( peer->key == key )
                        return peer;
        }

        if ( key != 0 ) {
                DBG ( "IPoIB warning: peer cache lost track of key %x while "
                      "still in use\n", key );
        }
        return NULL;
}

/**
 * Store GID and QPN in peer cache
 *
 * @v mac               Peer MAC address
 * @ret peer            Peer cache entry
 */
static struct ipoib_peer * ipoib_cache_peer ( const struct ipoib_mac *mac ) {
        struct ipoib_peer *peer;
        unsigned int key;
        unsigned int i;

        /* Look for existing cache entry */
        for ( i = 0 ; i < IPOIB_NUM_CACHED_PEERS ; i++ ) {
                peer = &ipoib_peer_cache[i];
                if ( memcmp ( &peer->mac, mac, sizeof ( peer->mac ) ) == 0 )
                        return peer;
        }

        /* No entry found: create a new one */
        key = ipoib_peer_cache_idx++;
        peer = &ipoib_peer_cache[ key % IPOIB_NUM_CACHED_PEERS ];
        if ( peer->key )
                DBG ( "IPoIB peer %x evicted from cache\n", peer->key );

        memset ( peer, 0, sizeof ( *peer ) );
        peer->key = key;
        memcpy ( &peer->mac, mac, sizeof ( peer->mac ) );
        DBG ( "IPoIB peer %x has MAC %s\n",
              peer->key, ipoib_ntoa ( &peer->mac ) );
        return peer;
}

/****************************************************************************
 *
 * IPoIB link layer
 *
 ****************************************************************************
 */

/**
 * Add IPoIB link-layer header
 *
 * @v netdev            Network device
 * @v iobuf             I/O buffer
 * @v ll_dest           Link-layer destination address
 * @v ll_source         Source link-layer address
 * @v net_proto         Network-layer protocol, in network-byte order
 * @ret rc              Return status code
 */
static int ipoib_push ( struct net_device *netdev __unused,
                        struct io_buffer *iobuf, const void *ll_dest,
                        const void *ll_source __unused, uint16_t net_proto ) {
        struct ipoib_hdr *ipoib_hdr =
                iob_push ( iobuf, sizeof ( *ipoib_hdr ) );
        const struct ipoib_mac *dest_mac = ll_dest;
        const struct ipoib_mac *src_mac = ll_source;
        struct ipoib_peer *dest;
        struct ipoib_peer *src;

        /* Add link-layer addresses to cache */
        dest = ipoib_cache_peer ( dest_mac );
        src = ipoib_cache_peer ( src_mac );

        /* Build IPoIB header */
        ipoib_hdr->proto = net_proto;
        ipoib_hdr->u.peer.dest = dest->key;
        ipoib_hdr->u.peer.src = src->key;

        return 0;
}

/**
 * Remove IPoIB link-layer header
 *
 * @v netdev            Network device
 * @v iobuf             I/O buffer
 * @ret ll_dest         Link-layer destination address
 * @ret ll_source       Source link-layer address
 * @ret net_proto       Network-layer protocol, in network-byte order
 * @ret rc              Return status code
 */
static int ipoib_pull ( struct net_device *netdev,
                        struct io_buffer *iobuf, const void **ll_dest,
                        const void **ll_source, uint16_t *net_proto ) {
        struct ipoib_device *ipoib = netdev->priv;
        struct ipoib_hdr *ipoib_hdr = iobuf->data;
        struct ipoib_peer *dest;
        struct ipoib_peer *source;

        /* Sanity check */
        if ( iob_len ( iobuf ) < sizeof ( *ipoib_hdr ) ) {
                DBG ( "IPoIB packet too short for link-layer header\n" );
                DBG_HD ( iobuf->data, iob_len ( iobuf ) );
                return -EINVAL;
        }

        /* Strip off IPoIB header */
        iob_pull ( iobuf, sizeof ( *ipoib_hdr ) );

        /* Identify source and destination addresses, and clear
         * reserved word in IPoIB header
         */
        dest = ipoib_lookup_peer_by_key ( ipoib_hdr->u.peer.dest );
        source = ipoib_lookup_peer_by_key ( ipoib_hdr->u.peer.src );
        ipoib_hdr->u.reserved = 0;

        /* Fill in required fields */
        *ll_dest = ( dest ? &dest->mac : &ipoib->broadcast );
        *ll_source = ( source ? &source->mac : &ipoib->broadcast );
        *net_proto = ipoib_hdr->proto;

        return 0;
}

/**
 * Initialise IPoIB link-layer address
 *
 * @v hw_addr           Hardware address
 * @v ll_addr           Link-layer address
 */
static void ipoib_init_addr ( const void *hw_addr, void *ll_addr ) {
        const struct ib_gid_half *guid = hw_addr;
        struct ipoib_mac *mac = ll_addr;

        memset ( mac, 0, sizeof ( *mac ) );
        memcpy ( &mac->gid.u.half[1], guid, sizeof ( mac->gid.u.half[1] ) );
}

/**
 * Transcribe IPoIB link-layer address
 *
 * @v ll_addr   Link-layer address
 * @ret string  Link-layer address in human-readable format
 */
const char * ipoib_ntoa ( const void *ll_addr ) {
        static char buf[45];
        const struct ipoib_mac *mac = ll_addr;

        snprintf ( buf, sizeof ( buf ), "%08x:%08x:%08x:%08x:%08x",
                   htonl ( mac->flags__qpn ), htonl ( mac->gid.u.dwords[0] ),
                   htonl ( mac->gid.u.dwords[1] ),
                   htonl ( mac->gid.u.dwords[2] ),
                   htonl ( mac->gid.u.dwords[3] ) );
        return buf;
}

/**
 * Hash multicast address
 *
 * @v af                Address family
 * @v net_addr          Network-layer address
 * @v ll_addr           Link-layer address to fill in
 * @ret rc              Return status code
 */
static int ipoib_mc_hash ( unsigned int af __unused,
                           const void *net_addr __unused,
                           void *ll_addr __unused ) {

        return -ENOTSUP;
}

/**
 * Generate Mellanox Ethernet-compatible compressed link-layer address
 *
 * @v ll_addr           Link-layer address
 * @v eth_addr          Ethernet-compatible address to fill in
 */
static int ipoib_mlx_eth_addr ( const struct ib_gid_half *guid,
                                uint8_t *eth_addr ) {
        eth_addr[0] = ( ( guid->u.bytes[3] == 2 ) ? 0x00 : 0x02 );
        eth_addr[1] = guid->u.bytes[1];
        eth_addr[2] = guid->u.bytes[2];
        eth_addr[3] = guid->u.bytes[5];
        eth_addr[4] = guid->u.bytes[6];
        eth_addr[5] = guid->u.bytes[7];
        return 0;
}

/** An IPoIB Ethernet-compatible compressed link-layer address generator */
struct ipoib_eth_addr_handler {
        /** GUID byte 1 */
        uint8_t byte1;
        /** GUID byte 2 */
        uint8_t byte2;
        /** Handler */
        int ( * eth_addr ) ( const struct ib_gid_half *guid,
                             uint8_t *eth_addr );
};

/** IPoIB Ethernet-compatible compressed link-layer address generators */
static struct ipoib_eth_addr_handler ipoib_eth_addr_handlers[] = {
        { 0x02, 0xc9, ipoib_mlx_eth_addr },
};

/**
 * Generate Ethernet-compatible compressed link-layer address
 *
 * @v ll_addr           Link-layer address
 * @v eth_addr          Ethernet-compatible address to fill in
 */
static int ipoib_eth_addr ( const void *ll_addr, void *eth_addr ) {
        const struct ipoib_mac *ipoib_addr = ll_addr;
        const struct ib_gid_half *guid = &ipoib_addr->gid.u.half[1];
        struct ipoib_eth_addr_handler *handler;
        unsigned int i;

        for ( i = 0 ; i < ( sizeof ( ipoib_eth_addr_handlers ) /
                            sizeof ( ipoib_eth_addr_handlers[0] ) ) ; i++ ) {
                handler = &ipoib_eth_addr_handlers[i];
                if ( ( handler->byte1 == guid->u.bytes[1] ) &&
                     ( handler->byte2 == guid->u.bytes[2] ) ) {
                        return handler->eth_addr ( guid, eth_addr );
                }
        }
        return -ENOTSUP;
}

/** IPoIB protocol */
struct ll_protocol ipoib_protocol __ll_protocol = {
        .name           = "IPoIB",
        .ll_proto       = htons ( ARPHRD_INFINIBAND ),
        .hw_addr_len    = sizeof ( struct ib_gid_half ),
        .ll_addr_len    = IPOIB_ALEN,
        .ll_header_len  = IPOIB_HLEN,
        .push           = ipoib_push,
        .pull           = ipoib_pull,
        .init_addr      = ipoib_init_addr,
        .ntoa           = ipoib_ntoa,
        .mc_hash        = ipoib_mc_hash,
        .eth_addr       = ipoib_eth_addr,
};

/**
 * Allocate IPoIB device
 *
 * @v priv_size         Size of driver private data
 * @ret netdev          Network device, or NULL
 */
struct net_device * alloc_ipoibdev ( size_t priv_size ) {
        struct net_device *netdev;

        netdev = alloc_netdev ( priv_size );
        if ( netdev ) {
                netdev->ll_protocol = &ipoib_protocol;
                netdev->ll_broadcast = ( uint8_t * ) &ipoib_broadcast;
                netdev->max_pkt_len = IB_MAX_PAYLOAD_SIZE;
        }
        return netdev;
}

/****************************************************************************
 *
 * IPoIB network device
 *
 ****************************************************************************
 */

/**
 * Transmit packet via IPoIB network device
 *
 * @v netdev            Network device
 * @v iobuf             I/O buffer
 * @ret rc              Return status code
 */
static int ipoib_transmit ( struct net_device *netdev,
                            struct io_buffer *iobuf ) {
        struct ipoib_device *ipoib = netdev->priv;
        struct ib_device *ibdev = ipoib->ibdev;
        struct ipoib_hdr *ipoib_hdr;
        struct ipoib_peer *dest;
        struct ib_address_vector av;
        int rc;

        /* Sanity check */
        if ( iob_len ( iobuf ) < sizeof ( *ipoib_hdr ) ) {
                DBGC ( ipoib, "IPoIB %p buffer too short\n", ipoib );
                return -EINVAL;
        }
        ipoib_hdr = iobuf->data;

        /* Attempting transmission while link is down will put the
         * queue pair into an error state, so don't try it.
         */
        if ( ! ib_link_ok ( ibdev ) )
                return -ENETUNREACH;

        /* Identify destination address */
        dest = ipoib_lookup_peer_by_key ( ipoib_hdr->u.peer.dest );
        if ( ! dest )
                return -ENXIO;
        ipoib_hdr->u.reserved = 0;

        /* Construct address vector */
        memset ( &av, 0, sizeof ( av ) );
        av.qpn = ( ntohl ( dest->mac.flags__qpn ) & IB_QPN_MASK );
        av.gid_present = 1;
        memcpy ( &av.gid, &dest->mac.gid, sizeof ( av.gid ) );
        if ( ( rc = ib_resolve_path ( ibdev, &av ) ) != 0 ) {
                /* Path not resolved yet */
                return rc;
        }

        return ib_post_send ( ibdev, ipoib->qp, &av, iobuf );
}

/**
 * Handle IPoIB send completion
 *
 * @v ibdev             Infiniband device
 * @v qp                Queue pair
 * @v iobuf             I/O buffer
 * @v rc                Completion status code
 */
static void ipoib_complete_send ( struct ib_device *ibdev __unused,
                                  struct ib_queue_pair *qp,
                                  struct io_buffer *iobuf, int rc ) {
        struct ipoib_device *ipoib = ib_qp_get_ownerdata ( qp );

        netdev_tx_complete_err ( ipoib->netdev, iobuf, rc );
}

/**
 * Handle IPoIB receive completion
 *
 * @v ibdev             Infiniband device
 * @v qp                Queue pair
 * @v av                Address vector, or NULL
 * @v iobuf             I/O buffer
 * @v rc                Completion status code
 */
static void ipoib_complete_recv ( struct ib_device *ibdev __unused,
                                  struct ib_queue_pair *qp,
                                  struct ib_address_vector *av,
                                  struct io_buffer *iobuf, int rc ) {
        struct ipoib_device *ipoib = ib_qp_get_ownerdata ( qp );
        struct net_device *netdev = ipoib->netdev;
        struct ipoib_hdr *ipoib_hdr;
        struct ipoib_mac ll_src;
        struct ipoib_peer *src;

        if ( rc != 0 ) {
                netdev_rx_err ( netdev, iobuf, rc );
                return;
        }

        /* Sanity check */
        if ( iob_len ( iobuf ) < sizeof ( struct ipoib_hdr ) ) {
                DBGC ( ipoib, "IPoIB %p received packet too short to "
                       "contain IPoIB header\n", ipoib );
                DBGC_HD ( ipoib, iobuf->data, iob_len ( iobuf ) );
                netdev_rx_err ( netdev, iobuf, -EIO );
                return;
        }
        ipoib_hdr = iobuf->data;

        /* Parse source address */
        if ( av->gid_present ) {
                ll_src.flags__qpn = htonl ( av->qpn );
                memcpy ( &ll_src.gid, &av->gid, sizeof ( ll_src.gid ) );
                src = ipoib_cache_peer ( &ll_src );
                ipoib_hdr->u.peer.src = src->key;
        }

        /* Hand off to network layer */
        netdev_rx ( netdev, iobuf );
}

/** IPoIB completion operations */
static struct ib_completion_queue_operations ipoib_cq_op = {
        .complete_send = ipoib_complete_send,
        .complete_recv = ipoib_complete_recv,
};

/**
 * Poll IPoIB network device
 *
 * @v netdev            Network device
 */
static void ipoib_poll ( struct net_device *netdev ) {
        struct ipoib_device *ipoib = netdev->priv;
        struct ib_device *ibdev = ipoib->ibdev;

        ib_poll_eq ( ibdev );
}

/**
 * Enable/disable interrupts on IPoIB network device
 *
 * @v netdev            Network device
 * @v enable            Interrupts should be enabled
 */
static void ipoib_irq ( struct net_device *netdev __unused,
                        int enable __unused ) {
        /* No implementation */
}

/**
 * Handle IPv4 broadcast multicast group join completion
 *
 * @v ibdev             Infiniband device
 * @v qp                Queue pair
 * @v membership        Multicast group membership
 * @v rc                Status code
 * @v mad               Response MAD (or NULL on error)
 */
void ipoib_join_complete ( struct ib_device *ibdev __unused,
                           struct ib_queue_pair *qp __unused,
                           struct ib_mc_membership *membership, int rc,
                           union ib_mad *mad __unused ) {
        struct ipoib_device *ipoib = container_of ( membership,
                                   struct ipoib_device, broadcast_membership );

        /* Record join status as link status */
        netdev_link_err ( ipoib->netdev, rc );
}

/**
 * Join IPv4 broadcast multicast group
 *
 * @v ipoib             IPoIB device
 * @ret rc              Return status code
 */
static int ipoib_join_broadcast_group ( struct ipoib_device *ipoib ) {
        int rc;

        if ( ( rc = ib_mcast_join ( ipoib->ibdev, ipoib->qp,
                                    &ipoib->broadcast_membership,
                                    &ipoib->broadcast.gid,
                                    ipoib_join_complete ) ) != 0 ) {
                DBGC ( ipoib, "IPoIB %p could not join broadcast group: %s\n",
                       ipoib, strerror ( rc ) );
                return rc;
        }
        ipoib->broadcast_joined = 1;

        return 0;
}

/**
 * Leave IPv4 broadcast multicast group
 *
 * @v ipoib             IPoIB device
 */
static void ipoib_leave_broadcast_group ( struct ipoib_device *ipoib ) {

        if ( ipoib->broadcast_joined ) {
                ib_mcast_leave ( ipoib->ibdev, ipoib->qp,
                                 &ipoib->broadcast_membership );
                ipoib->broadcast_joined = 0;
        }
}

/**
 * Open IPoIB network device
 *
 * @v netdev            Network device
 * @ret rc              Return status code
 */
static int ipoib_open ( struct net_device *netdev ) {
        struct ipoib_device *ipoib = netdev->priv;
        struct ib_device *ibdev = ipoib->ibdev;
        struct ipoib_mac *mac = ( ( struct ipoib_mac * ) netdev->ll_addr );
        int rc;

        /* Open IB device */
        if ( ( rc = ib_open ( ibdev ) ) != 0 ) {
                DBGC ( ipoib, "IPoIB %p could not open device: %s\n",
                       ipoib, strerror ( rc ) );
                goto err_ib_open;
        }

        /* Allocate completion queue */
        ipoib->cq = ib_create_cq ( ibdev, IPOIB_NUM_CQES, &ipoib_cq_op );
        if ( ! ipoib->cq ) {
                DBGC ( ipoib, "IPoIB %p could not allocate completion queue\n",
                       ipoib );
                rc = -ENOMEM;
                goto err_create_cq;
        }

        /* Allocate queue pair */
        ipoib->qp = ib_create_qp ( ibdev, IB_QPT_UD,
                                   IPOIB_NUM_SEND_WQES, ipoib->cq,
                                   IPOIB_NUM_RECV_WQES, ipoib->cq );
        if ( ! ipoib->qp ) {
                DBGC ( ipoib, "IPoIB %p could not allocate queue pair\n",
                       ipoib );
                rc = -ENOMEM;
                goto err_create_qp;
        }
        ib_qp_set_ownerdata ( ipoib->qp, ipoib );

        /* Update MAC address with QPN */
        mac->flags__qpn = htonl ( ipoib->qp->qpn );

        /* Fill receive rings */
        ib_refill_recv ( ibdev, ipoib->qp );

        /* Fake a link status change to join the broadcast group */
        ipoib_link_state_changed ( ibdev );

        return 0;

        ib_destroy_qp ( ibdev, ipoib->qp );
 err_create_qp:
        ib_destroy_cq ( ibdev, ipoib->cq );
 err_create_cq:
        ib_close ( ibdev );
 err_ib_open:
        return rc;
}

/**
 * Close IPoIB network device
 *
 * @v netdev            Network device
 */
static void ipoib_close ( struct net_device *netdev ) {
        struct ipoib_device *ipoib = netdev->priv;
        struct ib_device *ibdev = ipoib->ibdev;
        struct ipoib_mac *mac = ( ( struct ipoib_mac * ) netdev->ll_addr );

        /* Leave broadcast group */
        ipoib_leave_broadcast_group ( ipoib );

        /* Remove QPN from MAC address */
        mac->flags__qpn = 0;

        /* Tear down the queues */
        ib_destroy_qp ( ibdev, ipoib->qp );
        ib_destroy_cq ( ibdev, ipoib->cq );

        /* Close IB device */
        ib_close ( ibdev );
}

/** IPoIB network device operations */
static struct net_device_operations ipoib_operations = {
        .open           = ipoib_open,
        .close          = ipoib_close,
        .transmit       = ipoib_transmit,
        .poll           = ipoib_poll,
        .irq            = ipoib_irq,
};

/**
 * Handle link status change
 *
 * @v ibdev             Infiniband device
 */
void ipoib_link_state_changed ( struct ib_device *ibdev ) {
        struct net_device *netdev = ib_get_ownerdata ( ibdev );
        struct ipoib_device *ipoib = netdev->priv;
        struct ipoib_mac *mac = ( ( struct ipoib_mac * ) netdev->ll_addr );
        int rc;

        /* Leave existing broadcast group */
        ipoib_leave_broadcast_group ( ipoib );

        /* Update MAC address based on potentially-new GID prefix */
        memcpy ( &mac->gid.u.half[0], &ibdev->gid.u.half[0],
                 sizeof ( mac->gid.u.half[0] ) );

        /* Update broadcast GID based on potentially-new partition key */
        ipoib->broadcast.gid.u.words[2] =
                htons ( ibdev->pkey | IB_PKEY_FULL );

        /* Set net device link state to reflect Infiniband link state */
        rc = ib_link_rc ( ibdev );
        netdev_link_err ( netdev, ( rc ? rc : -EINPROGRESS_JOINING ) );

        /* Join new broadcast group */
        if ( ib_link_ok ( ibdev ) &&
             ( ( rc = ipoib_join_broadcast_group ( ipoib ) ) != 0 ) ) {
                DBGC ( ipoib, "IPoIB %p could not rejoin broadcast group: "
                       "%s\n", ipoib, strerror ( rc ) );
                netdev_link_err ( netdev, rc );
                return;
        }
}

/**
 * Probe IPoIB device
 *
 * @v ibdev             Infiniband device
 * @ret rc              Return status code
 */
int ipoib_probe ( struct ib_device *ibdev ) {
        struct net_device *netdev;
        struct ipoib_device *ipoib;
        int rc;

        /* Allocate network device */
        netdev = alloc_ipoibdev ( sizeof ( *ipoib ) );
        if ( ! netdev )
                return -ENOMEM;
        netdev_init ( netdev, &ipoib_operations );
        ipoib = netdev->priv;
        ib_set_ownerdata ( ibdev, netdev );
        netdev->dev = ibdev->dev;
        memset ( ipoib, 0, sizeof ( *ipoib ) );
        ipoib->netdev = netdev;
        ipoib->ibdev = ibdev;

        /* Extract hardware address */
        memcpy ( netdev->hw_addr, &ibdev->gid.u.half[1],
                 sizeof ( ibdev->gid.u.half[1] ) );

        /* Set default broadcast address */
        memcpy ( &ipoib->broadcast, &ipoib_broadcast,
                 sizeof ( ipoib->broadcast ) );
        netdev->ll_broadcast = ( ( uint8_t * ) &ipoib->broadcast );

        /* Register network device */
        if ( ( rc = register_netdev ( netdev ) ) != 0 )
                goto err_register_netdev;

        return 0;

 err_register_netdev:
        netdev_nullify ( netdev );
        netdev_put ( netdev );
        return rc;
}

/**
 * Remove IPoIB device
 *
 * @v ibdev             Infiniband device
 */
void ipoib_remove ( struct ib_device *ibdev ) {
        struct net_device *netdev = ib_get_ownerdata ( ibdev );

        unregister_netdev ( netdev );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}