diff options
Diffstat (limited to '')
-rw-r--r-- | debian/grub-extras/disabled/gpxe/src/net/netdevice.c | 633 |
1 files changed, 633 insertions, 0 deletions
diff --git a/debian/grub-extras/disabled/gpxe/src/net/netdevice.c b/debian/grub-extras/disabled/gpxe/src/net/netdevice.c new file mode 100644 index 0000000..ee0d0b7 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/net/netdevice.c @@ -0,0 +1,633 @@ +/* + * 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++ ); + + /* Set initial link-layer address */ + netdev->ll_protocol->init_addr ( netdev->hw_addr, netdev->ll_addr ); + + /* 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_addr ( 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, +}; |