8de49af0d2
The minimal-surprise behaviour, when no explicit SRP initiator device is specified, will probably be to use the most recently opened Infiniband device. This matches our behaviour with using the most recently opened net device for PXE, iSCSI, AoE, NBI, etc.
631 lines
15 KiB
C
631 lines
15 KiB
C
/*
|
|
* Copyright (C) 2006 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 <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <byteswap.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <gpxe/if_ether.h>
|
|
#include <gpxe/iobuf.h>
|
|
#include <gpxe/tables.h>
|
|
#include <gpxe/process.h>
|
|
#include <gpxe/init.h>
|
|
#include <gpxe/device.h>
|
|
#include <gpxe/errortab.h>
|
|
#include <gpxe/netdevice.h>
|
|
|
|
/** @file
|
|
*
|
|
* Network device management
|
|
*
|
|
*/
|
|
|
|
/** List of network devices */
|
|
struct list_head net_devices = LIST_HEAD_INIT ( net_devices );
|
|
|
|
/** List of open network devices, in reverse order of opening */
|
|
static struct list_head open_net_devices = LIST_HEAD_INIT ( open_net_devices );
|
|
|
|
/** Default link status code */
|
|
#define EUNKNOWN_LINK_STATUS EINPROGRESS
|
|
|
|
/** Human-readable message for the default link status */
|
|
struct errortab netdev_errors[] __errortab = {
|
|
{ EUNKNOWN_LINK_STATUS, "Unknown" },
|
|
};
|
|
|
|
/**
|
|
* Mark network device as having link down
|
|
*
|
|
* @v netdev Network device
|
|
*/
|
|
void netdev_link_down ( struct net_device *netdev ) {
|
|
|
|
switch ( netdev->link_rc ) {
|
|
case 0:
|
|
case -EUNKNOWN_LINK_STATUS:
|
|
netdev->link_rc = -ENOTCONN;
|
|
break;
|
|
default:
|
|
/* Avoid clobbering a more detailed link status code,
|
|
* if one is already set.
|
|
*/
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Record network device statistic
|
|
*
|
|
* @v stats Network device statistics
|
|
* @v rc Status code
|
|
*/
|
|
static void netdev_record_stat ( struct net_device_stats *stats, int rc ) {
|
|
struct net_device_error *error;
|
|
struct net_device_error *least_common_error;
|
|
unsigned int i;
|
|
|
|
/* If this is not an error, just update the good counter */
|
|
if ( rc == 0 ) {
|
|
stats->good++;
|
|
return;
|
|
}
|
|
|
|
/* Update the bad counter */
|
|
stats->bad++;
|
|
|
|
/* Locate the appropriate error record */
|
|
least_common_error = &stats->errors[0];
|
|
for ( i = 0 ; i < ( sizeof ( stats->errors ) /
|
|
sizeof ( stats->errors[0] ) ) ; i++ ) {
|
|
error = &stats->errors[i];
|
|
/* Update matching record, if found */
|
|
if ( error->rc == rc ) {
|
|
error->count++;
|
|
return;
|
|
}
|
|
if ( error->count < least_common_error->count )
|
|
least_common_error = error;
|
|
}
|
|
|
|
/* Overwrite the least common error record */
|
|
least_common_error->rc = rc;
|
|
least_common_error->count = 1;
|
|
}
|
|
|
|
/**
|
|
* Transmit raw packet via network device
|
|
*
|
|
* @v netdev Network device
|
|
* @v iobuf I/O buffer
|
|
* @ret rc Return status code
|
|
*
|
|
* Transmits the packet via the specified network device. This
|
|
* function takes ownership of the I/O buffer.
|
|
*/
|
|
int netdev_tx ( struct net_device *netdev, struct io_buffer *iobuf ) {
|
|
int rc;
|
|
|
|
DBGC ( netdev, "NETDEV %p transmitting %p (%p+%zx)\n",
|
|
netdev, iobuf, iobuf->data, iob_len ( iobuf ) );
|
|
|
|
list_add_tail ( &iobuf->list, &netdev->tx_queue );
|
|
|
|
if ( ! ( netdev->state & NETDEV_OPEN ) ) {
|
|
rc = -ENETUNREACH;
|
|
goto err;
|
|
}
|
|
|
|
if ( ( rc = netdev->op->transmit ( netdev, iobuf ) ) != 0 )
|
|
goto err;
|
|
|
|
return 0;
|
|
|
|
err:
|
|
netdev_tx_complete_err ( netdev, iobuf, rc );
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Complete network transmission
|
|
*
|
|
* @v netdev Network device
|
|
* @v iobuf I/O buffer
|
|
* @v rc Packet status code
|
|
*
|
|
* The packet must currently be in the network device's TX queue.
|
|
*/
|
|
void netdev_tx_complete_err ( struct net_device *netdev,
|
|
struct io_buffer *iobuf, int rc ) {
|
|
|
|
/* Update statistics counter */
|
|
netdev_record_stat ( &netdev->tx_stats, rc );
|
|
if ( rc == 0 ) {
|
|
DBGC ( netdev, "NETDEV %p transmission %p complete\n",
|
|
netdev, iobuf );
|
|
} else {
|
|
DBGC ( netdev, "NETDEV %p transmission %p failed: %s\n",
|
|
netdev, iobuf, strerror ( rc ) );
|
|
}
|
|
|
|
/* Catch data corruption as early as possible */
|
|
assert ( iobuf->list.next != NULL );
|
|
assert ( iobuf->list.prev != NULL );
|
|
|
|
/* Dequeue and free I/O buffer */
|
|
list_del ( &iobuf->list );
|
|
free_iob ( iobuf );
|
|
}
|
|
|
|
/**
|
|
* Complete network transmission
|
|
*
|
|
* @v netdev Network device
|
|
* @v rc Packet status code
|
|
*
|
|
* Completes the oldest outstanding packet in the TX queue.
|
|
*/
|
|
void netdev_tx_complete_next_err ( struct net_device *netdev, int rc ) {
|
|
struct io_buffer *iobuf;
|
|
|
|
list_for_each_entry ( iobuf, &netdev->tx_queue, list ) {
|
|
netdev_tx_complete_err ( netdev, iobuf, rc );
|
|
return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Flush device's transmit queue
|
|
*
|
|
* @v netdev Network device
|
|
*/
|
|
static void netdev_tx_flush ( struct net_device *netdev ) {
|
|
|
|
/* Discard any packets in the TX queue */
|
|
while ( ! list_empty ( &netdev->tx_queue ) ) {
|
|
netdev_tx_complete_next_err ( netdev, -ECANCELED );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add packet to receive queue
|
|
*
|
|
* @v netdev Network device
|
|
* @v iobuf I/O buffer, or NULL
|
|
*
|
|
* The packet is added to the network device's RX queue. This
|
|
* function takes ownership of the I/O buffer.
|
|
*/
|
|
void netdev_rx ( struct net_device *netdev, struct io_buffer *iobuf ) {
|
|
|
|
DBGC ( netdev, "NETDEV %p received %p (%p+%zx)\n",
|
|
netdev, iobuf, iobuf->data, iob_len ( iobuf ) );
|
|
|
|
/* Enqueue packet */
|
|
list_add_tail ( &iobuf->list, &netdev->rx_queue );
|
|
|
|
/* Update statistics counter */
|
|
netdev_record_stat ( &netdev->rx_stats, 0 );
|
|
}
|
|
|
|
/**
|
|
* Discard received packet
|
|
*
|
|
* @v netdev Network device
|
|
* @v iobuf I/O buffer, or NULL
|
|
* @v rc Packet status code
|
|
*
|
|
* The packet is discarded and an RX error is recorded. This function
|
|
* takes ownership of the I/O buffer. @c iobuf may be NULL if, for
|
|
* example, the net device wishes to report an error due to being
|
|
* unable to allocate an I/O buffer.
|
|
*/
|
|
void netdev_rx_err ( struct net_device *netdev,
|
|
struct io_buffer *iobuf, int rc ) {
|
|
|
|
DBGC ( netdev, "NETDEV %p failed to receive %p: %s\n",
|
|
netdev, iobuf, strerror ( rc ) );
|
|
|
|
/* Discard packet */
|
|
free_iob ( iobuf );
|
|
|
|
/* Update statistics counter */
|
|
netdev_record_stat ( &netdev->rx_stats, rc );
|
|
}
|
|
|
|
/**
|
|
* Poll for completed and received packets on network device
|
|
*
|
|
* @v netdev Network device
|
|
*
|
|
* Polls the network device for completed transmissions and received
|
|
* packets. Any received packets will be added to the RX packet queue
|
|
* via netdev_rx().
|
|
*/
|
|
void netdev_poll ( struct net_device *netdev ) {
|
|
|
|
if ( netdev->state & NETDEV_OPEN )
|
|
netdev->op->poll ( netdev );
|
|
}
|
|
|
|
/**
|
|
* Remove packet from device's receive queue
|
|
*
|
|
* @v netdev Network device
|
|
* @ret iobuf I/O buffer, or NULL
|
|
*
|
|
* Removes the first packet from the device's RX queue and returns it.
|
|
* Ownership of the packet is transferred to the caller.
|
|
*/
|
|
struct io_buffer * netdev_rx_dequeue ( struct net_device *netdev ) {
|
|
struct io_buffer *iobuf;
|
|
|
|
list_for_each_entry ( iobuf, &netdev->rx_queue, list ) {
|
|
list_del ( &iobuf->list );
|
|
return iobuf;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Flush device's receive queue
|
|
*
|
|
* @v netdev Network device
|
|
*/
|
|
static void netdev_rx_flush ( struct net_device *netdev ) {
|
|
struct io_buffer *iobuf;
|
|
|
|
/* Discard any packets in the RX queue */
|
|
while ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
|
|
netdev_rx_err ( netdev, iobuf, -ECANCELED );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Free network device
|
|
*
|
|
* @v refcnt Network device reference counter
|
|
*/
|
|
static void free_netdev ( struct refcnt *refcnt ) {
|
|
struct net_device *netdev =
|
|
container_of ( refcnt, struct net_device, refcnt );
|
|
|
|
netdev_tx_flush ( netdev );
|
|
netdev_rx_flush ( netdev );
|
|
clear_settings ( netdev_settings ( netdev ) );
|
|
free ( netdev );
|
|
}
|
|
|
|
/**
|
|
* Allocate network device
|
|
*
|
|
* @v priv_size Size of private data area (net_device::priv)
|
|
* @ret netdev Network device, or NULL
|
|
*
|
|
* Allocates space for a network device and its private data area.
|
|
*/
|
|
struct net_device * alloc_netdev ( size_t priv_size ) {
|
|
struct net_device *netdev;
|
|
size_t total_len;
|
|
|
|
total_len = ( sizeof ( *netdev ) + priv_size );
|
|
netdev = zalloc ( total_len );
|
|
if ( netdev ) {
|
|
netdev->refcnt.free = free_netdev;
|
|
netdev->link_rc = -EUNKNOWN_LINK_STATUS;
|
|
INIT_LIST_HEAD ( &netdev->tx_queue );
|
|
INIT_LIST_HEAD ( &netdev->rx_queue );
|
|
netdev_settings_init ( netdev );
|
|
netdev->priv = ( ( ( void * ) netdev ) + sizeof ( *netdev ) );
|
|
}
|
|
return netdev;
|
|
}
|
|
|
|
/**
|
|
* Register network device
|
|
*
|
|
* @v netdev Network device
|
|
* @ret rc Return status code
|
|
*
|
|
* Gives the network device a name and adds it to the list of network
|
|
* devices.
|
|
*/
|
|
int register_netdev ( struct net_device *netdev ) {
|
|
static unsigned int ifindex = 0;
|
|
int rc;
|
|
|
|
/* Create device name */
|
|
snprintf ( netdev->name, sizeof ( netdev->name ), "net%d",
|
|
ifindex++ );
|
|
|
|
/* Register per-netdev configuration settings */
|
|
if ( ( rc = register_settings ( netdev_settings ( netdev ),
|
|
NULL ) ) != 0 ) {
|
|
DBGC ( netdev, "NETDEV %p could not register settings: %s\n",
|
|
netdev, strerror ( rc ) );
|
|
return rc;
|
|
}
|
|
|
|
/* Add to device list */
|
|
netdev_get ( netdev );
|
|
list_add_tail ( &netdev->list, &net_devices );
|
|
DBGC ( netdev, "NETDEV %p registered as %s (phys %s hwaddr %s)\n",
|
|
netdev, netdev->name, netdev->dev->name,
|
|
netdev_hwaddr ( netdev ) );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Open network device
|
|
*
|
|
* @v netdev Network device
|
|
* @ret rc Return status code
|
|
*/
|
|
int netdev_open ( struct net_device *netdev ) {
|
|
int rc;
|
|
|
|
/* Do nothing if device is already open */
|
|
if ( netdev->state & NETDEV_OPEN )
|
|
return 0;
|
|
|
|
DBGC ( netdev, "NETDEV %p opening\n", netdev );
|
|
|
|
/* Open the device */
|
|
if ( ( rc = netdev->op->open ( netdev ) ) != 0 )
|
|
return rc;
|
|
|
|
/* Mark as opened */
|
|
netdev->state |= NETDEV_OPEN;
|
|
|
|
/* Add to head of open devices list */
|
|
list_add ( &netdev->open_list, &open_net_devices );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Close network device
|
|
*
|
|
* @v netdev Network device
|
|
*/
|
|
void netdev_close ( struct net_device *netdev ) {
|
|
|
|
/* Do nothing if device is already closed */
|
|
if ( ! ( netdev->state & NETDEV_OPEN ) )
|
|
return;
|
|
|
|
DBGC ( netdev, "NETDEV %p closing\n", netdev );
|
|
|
|
/* Close the device */
|
|
netdev->op->close ( netdev );
|
|
|
|
/* Flush TX and RX queues */
|
|
netdev_tx_flush ( netdev );
|
|
netdev_rx_flush ( netdev );
|
|
|
|
/* Mark as closed */
|
|
netdev->state &= ~NETDEV_OPEN;
|
|
|
|
/* Remove from open devices list */
|
|
list_del ( &netdev->open_list );
|
|
}
|
|
|
|
/**
|
|
* Unregister network device
|
|
*
|
|
* @v netdev Network device
|
|
*
|
|
* Removes the network device from the list of network devices.
|
|
*/
|
|
void unregister_netdev ( struct net_device *netdev ) {
|
|
|
|
/* Ensure device is closed */
|
|
netdev_close ( netdev );
|
|
|
|
/* Unregister per-netdev configuration settings */
|
|
unregister_settings ( netdev_settings ( netdev ) );
|
|
|
|
/* Remove from device list */
|
|
list_del ( &netdev->list );
|
|
netdev_put ( netdev );
|
|
DBGC ( netdev, "NETDEV %p unregistered\n", netdev );
|
|
}
|
|
|
|
/** Enable or disable interrupts
|
|
*
|
|
* @v netdev Network device
|
|
* @v enable Interrupts should be enabled
|
|
*/
|
|
void netdev_irq ( struct net_device *netdev, int enable ) {
|
|
netdev->op->irq ( netdev, enable );
|
|
}
|
|
|
|
/**
|
|
* Get network device by name
|
|
*
|
|
* @v name Network device name
|
|
* @ret netdev Network device, or NULL
|
|
*/
|
|
struct net_device * find_netdev ( const char *name ) {
|
|
struct net_device *netdev;
|
|
|
|
list_for_each_entry ( netdev, &net_devices, list ) {
|
|
if ( strcmp ( netdev->name, name ) == 0 )
|
|
return netdev;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Get network device by PCI bus:dev.fn address
|
|
*
|
|
* @v bus_type Bus type
|
|
* @v location Bus location
|
|
* @ret netdev Network device, or NULL
|
|
*/
|
|
struct net_device * find_netdev_by_location ( unsigned int bus_type,
|
|
unsigned int location ) {
|
|
struct net_device *netdev;
|
|
|
|
list_for_each_entry ( netdev, &net_devices, list ) {
|
|
if ( ( netdev->dev->desc.bus_type == bus_type ) &&
|
|
( netdev->dev->desc.location == location ) )
|
|
return netdev;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Get most recently opened network device
|
|
*
|
|
* @ret netdev Most recently opened network device, or NULL
|
|
*/
|
|
struct net_device * last_opened_netdev ( void ) {
|
|
struct net_device *netdev;
|
|
|
|
list_for_each_entry ( netdev, &open_net_devices, open_list ) {
|
|
assert ( netdev->state & NETDEV_OPEN );
|
|
return netdev;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Transmit network-layer packet
|
|
*
|
|
* @v iobuf I/O buffer
|
|
* @v netdev Network device
|
|
* @v net_protocol Network-layer protocol
|
|
* @v ll_dest Destination link-layer address
|
|
* @ret rc Return status code
|
|
*
|
|
* Prepends link-layer headers to the I/O buffer and transmits the
|
|
* packet via the specified network device. This function takes
|
|
* ownership of the I/O buffer.
|
|
*/
|
|
int net_tx ( struct io_buffer *iobuf, struct net_device *netdev,
|
|
struct net_protocol *net_protocol, const void *ll_dest ) {
|
|
struct ll_protocol *ll_protocol = netdev->ll_protocol;
|
|
int rc;
|
|
|
|
/* Force a poll on the netdevice to (potentially) clear any
|
|
* backed-up TX completions. This is needed on some network
|
|
* devices to avoid excessive losses due to small TX ring
|
|
* sizes.
|
|
*/
|
|
netdev_poll ( netdev );
|
|
|
|
/* Add link-layer header */
|
|
if ( ( rc = ll_protocol->push ( netdev, iobuf, ll_dest, netdev->ll_addr,
|
|
net_protocol->net_proto ) ) != 0 ) {
|
|
free_iob ( iobuf );
|
|
return rc;
|
|
}
|
|
|
|
/* Transmit packet */
|
|
return netdev_tx ( netdev, iobuf );
|
|
}
|
|
|
|
/**
|
|
* Process received network-layer packet
|
|
*
|
|
* @v iobuf I/O buffer
|
|
* @v netdev Network device
|
|
* @v net_proto Network-layer protocol, in network-byte order
|
|
* @v ll_source Source link-layer address
|
|
* @ret rc Return status code
|
|
*/
|
|
int net_rx ( struct io_buffer *iobuf, struct net_device *netdev,
|
|
uint16_t net_proto, const void *ll_source ) {
|
|
struct net_protocol *net_protocol;
|
|
|
|
/* Hand off to network-layer protocol, if any */
|
|
for_each_table_entry ( net_protocol, NET_PROTOCOLS ) {
|
|
if ( net_protocol->net_proto == net_proto )
|
|
return net_protocol->rx ( iobuf, netdev, ll_source );
|
|
}
|
|
|
|
DBGC ( netdev, "NETDEV %p unknown network protocol %04x\n",
|
|
netdev, ntohs ( net_proto ) );
|
|
free_iob ( iobuf );
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Single-step the network stack
|
|
*
|
|
* @v process Network stack process
|
|
*
|
|
* This polls all interfaces for received packets, and processes
|
|
* packets from the RX queue.
|
|
*/
|
|
static void net_step ( struct process *process __unused ) {
|
|
struct net_device *netdev;
|
|
struct io_buffer *iobuf;
|
|
struct ll_protocol *ll_protocol;
|
|
const void *ll_dest;
|
|
const void *ll_source;
|
|
uint16_t net_proto;
|
|
int rc;
|
|
|
|
/* Poll and process each network device */
|
|
list_for_each_entry ( netdev, &net_devices, list ) {
|
|
|
|
/* Poll for new packets */
|
|
netdev_poll ( netdev );
|
|
|
|
/* Process at most one received packet. Give priority
|
|
* to getting packets out of the NIC over processing
|
|
* the received packets, because we advertise a window
|
|
* that assumes that we can receive packets from the
|
|
* NIC faster than they arrive.
|
|
*/
|
|
if ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
|
|
|
|
DBGC ( netdev, "NETDEV %p processing %p (%p+%zx)\n",
|
|
netdev, iobuf, iobuf->data,
|
|
iob_len ( iobuf ) );
|
|
|
|
/* Remove link-layer header */
|
|
ll_protocol = netdev->ll_protocol;
|
|
if ( ( rc = ll_protocol->pull ( netdev, iobuf,
|
|
&ll_dest, &ll_source,
|
|
&net_proto ) ) != 0 ) {
|
|
free_iob ( iobuf );
|
|
continue;
|
|
}
|
|
|
|
net_rx ( iobuf, netdev, net_proto, ll_source );
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Networking stack process */
|
|
struct process net_process __permanent_process = {
|
|
.list = LIST_HEAD_INIT ( net_process.list ),
|
|
.step = net_step,
|
|
};
|