/
githubmirror
/
ipxe
Обзор
Документация
Войти
/
githubmirror
/
ipxe
Код
Запросы
0
Пакеты
0
Релизы
0
Аналитика
Безопасность
v1.0.0
src/net/netdevice.c
633 строки
15 KB
Michael Brown
[netdevice] Allow the hardware and link-layer addresses to differ in size
12 авг 2009, 03:23
12 авг 2009, 03:23
4eab5bc
Код
Авторство
О чём код?
/* * 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, };