netdevice.c File Reference

Network device management. More...

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <byteswap.h>
#include <string.h>
#include <errno.h>
#include <config/general.h>
#include <ipxe/if_ether.h>
#include <ipxe/iobuf.h>
#include <ipxe/tables.h>
#include <ipxe/process.h>
#include <ipxe/init.h>
#include <ipxe/malloc.h>
#include <ipxe/device.h>
#include <ipxe/errortab.h>
#include <ipxe/profile.h>
#include <ipxe/fault.h>
#include <ipxe/vlan.h>
#include <ipxe/netdevice.h>

Go to the source code of this file.

Macros
#define	EUNKNOWN_LINK_STATUS   __einfo_error ( EINFO_EUNKNOWN_LINK_STATUS )
	Default unknown link status code. More...
#define	EINFO_EUNKNOWN_LINK_STATUS   __einfo_uniqify ( EINFO_EINPROGRESS, 0x01, "Unknown" )
#define	EUNUSED_CONFIG   __einfo_error ( EINFO_EUNUSED_CONFIG )
	Default not-yet-attempted-configuration status code. More...
#define	EINFO_EUNUSED_CONFIG   __einfo_uniqify ( EINFO_EINPROGRESS, 0x02, "Unused" )
#define	EINPROGRESS_CONFIG   __einfo_error ( EINFO_EINPROGRESS_CONFIG )
	Default configuration-in-progress status code. More...
#define	EINFO_EINPROGRESS_CONFIG   __einfo_uniqify ( EINFO_EINPROGRESS, 0x03, "Incomplete" )
#define	ENOTCONN_LINK_DOWN   __einfo_error ( EINFO_ENOTCONN_LINK_DOWN )
	Default link-down status code. More...
#define	EINFO_ENOTCONN_LINK_DOWN   __einfo_uniqify ( EINFO_ENOTCONN, 0x01, "Down" )

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static int	netdev_has_ll_addr (struct net_device *netdev)
	Check whether or not network device has a link-layer address. More...
static size_t	netdev_priv_offset (struct net_driver *driver)
	Get offset of network device driver private data. More...
void *	netdev_priv (struct net_device *netdev, struct net_driver *driver)
	Get network device driver private data. More...
static void	netdev_notify (struct net_device *netdev)
	Notify drivers of network device or link state change. More...
void	netdev_rx_freeze (struct net_device *netdev)
	Freeze network device receive queue processing. More...
void	netdev_rx_unfreeze (struct net_device *netdev)
	Unfreeze network device receive queue processing. More...
void	netdev_link_err (struct net_device *netdev, int rc)
	Mark network device as having a specific link state. More...
void	netdev_link_down (struct net_device *netdev)
	Mark network device as having link down. More...
void	netdev_link_block (struct net_device *netdev, unsigned long timeout)
	Mark network device link as being blocked. More...
void	netdev_link_unblock (struct net_device *netdev)
	Mark network device link as being unblocked. More...
static void	netdev_link_block_expired (struct retry_timer *timer, int fail __unused)
	Handle network device link block timer expiry. More...
static void	netdev_record_stat (struct net_device_stats *stats, int rc)
	Record network device statistic. More...
int	netdev_tx (struct net_device *netdev, struct io_buffer *iobuf)
	Transmit raw packet via network device. More...
void	netdev_tx_defer (struct net_device *netdev, struct io_buffer *iobuf)
	Defer transmitted packet. More...
void	netdev_tx_err (struct net_device *netdev, struct io_buffer *iobuf, int rc)
	Discard transmitted packet. More...
void	netdev_tx_complete_err (struct net_device *netdev, struct io_buffer *iobuf, int rc)
	Complete network transmission. More...
void	netdev_tx_complete_next_err (struct net_device *netdev, int rc)
	Complete network transmission. More...
static void	netdev_tx_flush (struct net_device *netdev)
	Flush device's transmit queue. More...
void	netdev_rx (struct net_device *netdev, struct io_buffer *iobuf)
	Add packet to receive queue. More...
void	netdev_rx_err (struct net_device *netdev, struct io_buffer *iobuf, int rc)
	Discard received packet. More...
void	netdev_poll (struct net_device *netdev)
	Poll for completed and received packets on network device. More...
struct io_buffer *	netdev_rx_dequeue (struct net_device *netdev)
	Remove packet from device's receive queue. More...
static void	netdev_rx_flush (struct net_device *netdev)
	Flush device's receive queue. More...
static void	netdev_config_close (struct net_device_configuration *config, int rc)
	Finish network device configuration. More...
static void	free_netdev (struct refcnt *refcnt)
	Free network device. More...
struct net_device *	alloc_netdev (size_t priv_len)
	Allocate network device. More...
int	register_netdev (struct net_device *netdev)
	Register network device. More...
int	netdev_open (struct net_device *netdev)
	Open network device. More...
void	netdev_close (struct net_device *netdev)
	Close network device. More...
void	unregister_netdev (struct net_device *netdev)
	Unregister network device. More...
void	netdev_irq (struct net_device *netdev, int enable)
	Enable or disable interrupts. More...
struct net_device *	find_netdev (const char *name)
	Get network device by name. More...
struct net_device *	find_netdev_by_scope_id (unsigned int scope_id)
	Get network device by scope ID. More...
struct net_device *	find_netdev_by_location (unsigned int bus_type, unsigned int location)
	Get network device by PCI bus:dev.fn address. More...
struct net_device *	last_opened_netdev (void)
	Get most recently opened network device. More...
int	net_tx (struct io_buffer *iobuf, struct net_device *netdev, struct net_protocol *net_protocol, const void *ll_dest, const void *ll_source)
	Transmit network-layer packet. More...
int	net_rx (struct io_buffer *iobuf, struct net_device *netdev, uint16_t net_proto, const void *ll_dest, const void *ll_source, unsigned int flags)
	Process received network-layer packet. More...
void	net_poll (void)
	Poll the network stack. More...
static void	net_step (struct process *process __unused)
	Single-step the network stack. More...
__weak unsigned int	vlan_tci (struct net_device *netdev __unused)
	Get the VLAN tag control information (when VLAN support is not present) More...
__weak void	vlan_netdev_rx (struct net_device *netdev, unsigned int tag, struct io_buffer *iobuf)
	Add VLAN tag-stripped packet to queue (when VLAN support is not present) More...
__weak void	vlan_netdev_rx_err (struct net_device *netdev, unsigned int tag __unused, struct io_buffer *iobuf, int rc)
	Discard received VLAN tag-stripped packet (when VLAN support is not present) More...
	PERMANENT_PROCESS (net_process, net_step)
	Networking stack process. More...
static unsigned int	net_discard (void)
	Discard some cached network device data. More...
struct cache_discarder net_discarder	__cache_discarder (CACHE_NORMAL)
	Network device cache discarder. More...
struct net_device_configurator *	find_netdev_configurator (const char *name)
	Find network device configurator. More...
int	netdev_configure (struct net_device *netdev, struct net_device_configurator *configurator)
	Start network device configuration. More...
int	netdev_configure_all (struct net_device *netdev)
	Start network device configuration via all supported configurators. More...
static int	netdev_has_configuration_rc (struct net_device *netdev, int rc)
	Check if network device has a configuration with a specified status code. More...
int	netdev_configuration_in_progress (struct net_device *netdev)
	Check if network device configuration is in progress. More...
int	netdev_configuration_ok (struct net_device *netdev)
	Check if network device has at least one successful configuration. More...

Variables
struct list_head	net_devices = LIST_HEAD_INIT ( net_devices )
	List of network devices. More...
static struct list_head	open_net_devices = LIST_HEAD_INIT ( open_net_devices )
	List of open network devices, in reverse order of opening. More...
static struct profiler net_poll_profiler	__profiler = { .name = "net.poll" }
	Network polling profiler. More...
struct errortab netdev_errors []	__errortab
	Human-readable message for the default link statuses. More...
static struct interface_operation	netdev_config_ops []
	Network device configuration interface operations. More...
static struct interface_descriptor	netdev_config_desc
	Network device configuration interface descriptor. More...

Detailed Description

Network device management.

Definition in file netdevice.c.

Macro Definition Documentation

EUNKNOWN_LINK_STATUS

#define EUNKNOWN_LINK_STATUS   __einfo_error ( EINFO_EUNKNOWN_LINK_STATUS )

Default unknown link status code.

Definition at line 68 of file netdevice.c.

EINFO_EUNKNOWN_LINK_STATUS

#define EINFO_EUNKNOWN_LINK_STATUS   __einfo_uniqify ( EINFO_EINPROGRESS, 0x01, "Unknown" )

Definition at line 69 of file netdevice.c.

EUNUSED_CONFIG

#define EUNUSED_CONFIG   __einfo_error ( EINFO_EUNUSED_CONFIG )

Default not-yet-attempted-configuration status code.

Definition at line 73 of file netdevice.c.

EINFO_EUNUSED_CONFIG

#define EINFO_EUNUSED_CONFIG   __einfo_uniqify ( EINFO_EINPROGRESS, 0x02, "Unused" )

Definition at line 74 of file netdevice.c.

EINPROGRESS_CONFIG

#define EINPROGRESS_CONFIG   __einfo_error ( EINFO_EINPROGRESS_CONFIG )

Default configuration-in-progress status code.

Definition at line 78 of file netdevice.c.

EINFO_EINPROGRESS_CONFIG

#define EINFO_EINPROGRESS_CONFIG   __einfo_uniqify ( EINFO_EINPROGRESS, 0x03, "Incomplete" )

Definition at line 79 of file netdevice.c.

ENOTCONN_LINK_DOWN

#define ENOTCONN_LINK_DOWN   __einfo_error ( EINFO_ENOTCONN_LINK_DOWN )

Default link-down status code.

Definition at line 83 of file netdevice.c.

EINFO_ENOTCONN_LINK_DOWN

#define EINFO_ENOTCONN_LINK_DOWN   __einfo_uniqify ( EINFO_ENOTCONN, 0x01, "Down" )

Definition at line 84 of file netdevice.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

netdev_has_ll_addr()

static int netdev_has_ll_addr ( struct net_device *  netdev )

static

Check whether or not network device has a link-layer address.

Parameters

netdev

Network device

Return values

has_ll_addr

Network device has a link-layer address

Definition at line 101 of file netdevice.c.

                                                            {
        uint8_t *ll_addr = netdev->ll_addr;
        size_t remaining = sizeof ( netdev->ll_addr );

        while ( remaining-- ) {
                if ( *(ll_addr++) != 0 )
                        return 1;
        }
        return 0;
}

References net_device::ll_addr, and netdev.

Referenced by register_netdev().

netdev_priv_offset()

static size_t netdev_priv_offset ( struct net_driver *  driver )

static

Get offset of network device driver private data.

Parameters

driver

Upper-layer driver, or NULL for device driver

Return values

offset

Offset of driver private data

Definition at line 118 of file netdevice.c.

                                                               {
        struct net_device *netdev;
        unsigned int num_configs;
        size_t offset;

        /* Allow space for network device */
        offset = sizeof ( *netdev );

        /* Allow space for configurations */
        num_configs = table_num_entries ( NET_DEVICE_CONFIGURATORS );
        offset += ( num_configs * sizeof ( netdev->configs[0] ) );

        /* Place variable-length device driver private data at end */
        if ( ! driver )
                driver = table_end ( NET_DRIVERS );

        /* Allow space for preceding upper-layer drivers' private data */
        for_each_table_entry_continue_reverse ( driver, NET_DRIVERS ) {
                offset += driver->priv_len;
        }

        /* Sanity check */
        assert ( ( offset & ( sizeof ( void * ) - 1 ) ) == 0 );

        return offset;
}

References assert(), net_device::configs, for_each_table_entry_continue_reverse, NET_DEVICE_CONFIGURATORS, NET_DRIVERS, netdev, offset, net_driver::priv_len, table_end, and table_num_entries.

Referenced by alloc_netdev(), and netdev_priv().

netdev_priv()

void* netdev_priv	(	struct net_device *	netdev,
		struct net_driver *	driver
	)

Get network device driver private data.

Parameters

netdev	Network device
driver	Upper-layer driver, or NULL for device driver

Return values

priv	Driver private data

Definition at line 152 of file netdevice.c.

                                                                            {

        return ( ( ( void * ) netdev ) + netdev_priv_offset ( driver ) );
}

References netdev, and netdev_priv_offset().

Referenced by alloc_netdev(), eapol_rx(), fcoe_fip_rx(), fcoe_rx(), lldp_rx(), netdev_notify(), register_netdev(), and unregister_netdev().

netdev_notify()

static void netdev_notify ( struct net_device *  netdev )

static

Notify drivers of network device or link state change.

Parameters

netdev

Network device

Definition at line 162 of file netdevice.c.

                                                        {
        struct net_driver *driver;
        void *priv;

        for_each_table_entry ( driver, NET_DRIVERS ) {
                priv = netdev_priv ( netdev, driver );
                if ( driver->notify )
                        driver->notify ( netdev, priv );
        }
}

References for_each_table_entry, NET_DRIVERS, netdev, netdev_priv(), net_driver::notify, and priv.

Referenced by netdev_close(), netdev_link_err(), netdev_open(), netdev_rx_freeze(), and netdev_rx_unfreeze().

netdev_rx_freeze()

void netdev_rx_freeze

(

struct net_device *

netdev

)

Freeze network device receive queue processing.

Parameters

netdev

Network device

Definition at line 178 of file netdevice.c.

                                                    {

        /* Mark receive queue processing as frozen */
        netdev->state |= NETDEV_RX_FROZEN;

        /* Notify drivers of change */
        netdev_notify ( netdev );
}

References netdev, netdev_notify(), NETDEV_RX_FROZEN, and net_device::state.

Referenced by pxe_netdev_open(), and pxenv_undi_transmit().

netdev_rx_unfreeze()

void netdev_rx_unfreeze

(

struct net_device *

netdev

)

Unfreeze network device receive queue processing.

Parameters

netdev

Network device

Definition at line 192 of file netdevice.c.

                                                      {

        /* Mark receive queue processing as not frozen */
        netdev->state &= ~NETDEV_RX_FROZEN;

        /* Notify drivers of change */
        netdev_notify ( netdev );
}

References netdev, netdev_notify(), NETDEV_RX_FROZEN, and net_device::state.

Referenced by pxe_netdev_close(), and pxe_set_netdev().

netdev_link_err()

void netdev_link_err	(	struct net_device *	netdev,
		int	rc
	)

Mark network device as having a specific link state.

Parameters

netdev	Network device
rc	Link status code

Definition at line 207 of file netdevice.c.

                                                           {

        /* Stop link block timer */
        stop_timer ( &netdev->link_block );

        /* Record link state */
        netdev->link_rc = rc;
        if ( netdev->link_rc == 0 ) {
                DBGC ( netdev, "NETDEV %s link is up\n", netdev->name );
        } else {
                DBGC ( netdev, "NETDEV %s link is down: %s\n",
                       netdev->name, strerror ( netdev->link_rc ) );
        }

        /* Notify drivers of link state change */
        netdev_notify ( netdev );
}

References DBGC, net_device::link_block, net_device::link_rc, net_device::name, netdev, netdev_notify(), rc, stop_timer(), and strerror().

Referenced by eoib_join_complete(), eoib_link_state_changed(), gve_startup(), iphone_check_link(), ipoib_join_complete(), ipoib_link_state_changed(), net80211_deauthenticate(), net80211_set_state(), net80211_step_associate(), netdev_link_down(), netdev_link_up(), netfront_close(), rhine_check_link(), skeleton_check_link(), and vlan_sync().

netdev_link_down()

void netdev_link_down

(

struct net_device *

netdev

)

Mark network device as having link down.

Parameters

netdev

Network device

Definition at line 230 of file netdevice.c.

                                                    {

        /* Avoid clobbering a more detailed link status code, if one
         * is already set.
         */
        if ( ( netdev->link_rc == 0 ) ||
             ( netdev->link_rc == -EUNKNOWN_LINK_STATUS ) ) {
                netdev_link_err ( netdev, -ENOTCONN_LINK_DOWN );
        }
}

References ENOTCONN_LINK_DOWN, EUNKNOWN_LINK_STATUS, net_device::link_rc, netdev, and netdev_link_err().

Referenced by __vxge_hw_vpath_alarm_process(), atl1e_check_link(), atl1e_down(), atl_check_link(), atl_probe(), axge_check_link(), bnxt_set_link(), dm96xx_link_nsr(), ecm_intr_complete(), exanic_check_link(), flexboot_nodnic_state_change_netdev(), forcedeth_link_status(), gve_restart(), hermon_state_change_netdev(), hunt_check_link(), hunt_open(), ice_admin_link(), icplus_check_link(), intel_check_link(), intelx_check_link(), intelxl_admin_link(), intelxlvf_admin_link(), intelxvf_check_link(), jme_check_link(), jme_close(), jme_link_change(), mii_check_link(), myri10ge_interrupt_handler(), natsemi_check_link(), ncm_intr_complete(), net80211_netdev_close(), net80211_set_state(), netfront_close(), netfront_probe(), nii_poll_link(), phantom_poll_link_state(), realtek_check_link(), rhine_check_link(), rndis_rx_query_oid(), rndis_rx_status(), sis190_phy_task(), skge_down(), skge_link_down(), sky2_link_down(), sky2_up(), snpnet_check_link(), tg3_phy_reset(), tg3_setup_copper_phy(), tg3_setup_fiber_mii_phy(), tg3_test_and_report_link_chg(), txnic_lmac_update_link(), velocity_check_link(), vmxnet3_check_link(), vxge_close(), and vxge_open().

netdev_link_block()

void netdev_link_block	(	struct net_device *	netdev,
		unsigned long	timeout
	)

Mark network device link as being blocked.

Parameters

netdev	Network device
timeout	Timeout (in ticks)

Definition at line 247 of file netdevice.c.

                                                                            {

        /* Start link block timer */
        if ( ! netdev_link_blocked ( netdev ) ) {
                DBGC ( netdev, "NETDEV %s link blocked for %ld ticks\n",
                       netdev->name, timeout );
        }
        start_timer_fixed ( &netdev->link_block, timeout );
}

References DBGC, net_device::link_block, net_device::name, netdev, netdev_link_blocked(), start_timer_fixed(), and timeout().

Referenced by eap_rx_identity(), eth_slow_lacp_rx(), and stp_rx().

netdev_link_unblock()

void netdev_link_unblock

(

struct net_device *

netdev

)

Mark network device link as being unblocked.

Parameters

netdev

Network device

Definition at line 262 of file netdevice.c.

                                                       {

        /* Stop link block timer */
        if ( netdev_link_blocked ( netdev ) )
                DBGC ( netdev, "NETDEV %s link unblocked\n", netdev->name );
        stop_timer ( &netdev->link_block );
}

References DBGC, net_device::link_block, net_device::name, netdev, netdev_link_blocked(), and stop_timer().

Referenced by eap_rx_success(), eth_slow_lacp_rx(), and stp_rx().

netdev_link_block_expired()

static void netdev_link_block_expired ( struct retry_timer *  timer, int fail  __unused  )

static

Handle network device link block timer expiry.

Parameters

timer	Link block timer
fail	Failure indicator

Definition at line 276 of file netdevice.c.

                                                            {
        struct net_device *netdev =
                container_of ( timer, struct net_device, link_block );

        /* Assume link is no longer blocked */
        DBGC ( netdev, "NETDEV %s link block expired\n", netdev->name );
}

References container_of, DBGC, net_device::link_block, net_device::name, and netdev.

Referenced by alloc_netdev().

netdev_record_stat()

static void netdev_record_stat ( struct net_device_stats *  stats, int  rc  )

static

Record network device statistic.

Parameters

stats	Network device statistics
rc	Status code

Definition at line 291 of file netdevice.c.

                                                                          {
        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;
}

References net_device_stats::bad, net_device_error::count, error, net_device_stats::errors, net_device_stats::good, net_device_error::rc, and rc.

Referenced by netdev_rx(), netdev_rx_err(), and netdev_tx_err().

netdev_tx()

int netdev_tx	(	struct net_device *	netdev,
		struct io_buffer *	iobuf
	)

Transmit raw packet via network device.

Parameters

netdev	Network device
iobuf	I/O buffer

Return values

rc	Return status code

Transmits the packet via the specified network device. This function takes ownership of the I/O buffer.

Definition at line 334 of file netdevice.c.

                                                                     {
        int rc;

        DBGC2 ( netdev, "NETDEV %s transmitting %p (%p+%zx)\n",
                netdev->name, iobuf, iobuf->data, iob_len ( iobuf ) );
        profile_start ( &net_tx_profiler );

        /* Enqueue packet */
        list_add_tail ( &iobuf->list, &netdev->tx_queue );

        /* Guard against re-entry */
        if ( netdev->state & NETDEV_TX_IN_PROGRESS ) {
                rc = -EBUSY;
                goto err_busy;
        }
        netdev->state |= NETDEV_TX_IN_PROGRESS;

        /* Avoid calling transmit() on unopened network devices */
        if ( ! netdev_is_open ( netdev ) ) {
                rc = -ENETUNREACH;
                goto err_closed;
        }

        /* Discard packet (for test purposes) if applicable */
        if ( ( rc = inject_fault ( NETDEV_DISCARD_RATE ) ) != 0 )
                goto err_fault;

        /* Map for DMA, if required */
        if ( netdev->dma && ( ! dma_mapped ( &iobuf->map ) ) ) {
                if ( ( rc = iob_map_tx ( iobuf, netdev->dma ) ) != 0 )
                        goto err_map;
        }

        /* Transmit packet */
        if ( ( rc = netdev->op->transmit ( netdev, iobuf ) ) != 0 )
                goto err_transmit;

        /* Clear in-progress flag */
        netdev->state &= ~NETDEV_TX_IN_PROGRESS;

        profile_stop ( &net_tx_profiler );
        return 0;

 err_transmit:
 err_map:
 err_fault:
 err_closed:
        netdev->state &= ~NETDEV_TX_IN_PROGRESS;
 err_busy:
        netdev_tx_complete_err ( netdev, iobuf, rc );
        return rc;
}

References io_buffer::data, DBGC2, net_device::dma, dma_mapped(), EBUSY, ENETUNREACH, iob_len(), iob_map_tx(), io_buffer::list, list_add_tail, io_buffer::map, net_device::name, netdev, NETDEV_DISCARD_RATE, netdev_is_open(), netdev_tx_complete_err(), NETDEV_TX_IN_PROGRESS, net_device::op, profile_start(), profile_stop(), rc, net_device::state, net_device_operations::transmit, and net_device::tx_queue.

Referenced by efi_snp_transmit(), gdbudp_recv(), gdbudp_send(), net80211_handle_auth(), net80211_netdev_transmit(), net80211_tx_mgmt(), net_tx(), netdev_tx_complete_err(), and pxenv_undi_transmit().

netdev_tx_defer()

void netdev_tx_defer	(	struct net_device *	netdev,
		struct io_buffer *	iobuf
	)

Defer transmitted packet.

Parameters

netdev	Network device
iobuf	I/O buffer

Drivers may call netdev_tx_defer() if there is insufficient space in the transmit descriptor ring. Any packets deferred in this way will be automatically retransmitted as soon as space becomes available (i.e. as soon as the driver calls netdev_tx_complete()).

The packet must currently be in the network device's TX queue.

Drivers utilising netdev_tx_defer() must ensure that space in the transmit descriptor ring is freed up before calling netdev_tx_complete(). For example, if the ring is modelled using a producer counter and a consumer counter, then the consumer counter must be incremented before the call to netdev_tx_complete(). Failure to do this will cause the retransmitted packet to be immediately redeferred (which will result in out-of-order transmissions and other nastiness).

I/O buffers that have been mapped for DMA will remain mapped while present in the deferred transmit queue.

Definition at line 412 of file netdevice.c.

                                                                            {

        /* Catch data corruption as early as possible */
        list_check_contains_entry ( iobuf, &netdev->tx_queue, list );

        /* Remove from transmit queue */
        list_del ( &iobuf->list );

        /* Add to deferred transmit queue */
        list_add_tail ( &iobuf->list, &netdev->tx_deferred );

        /* Record "out of space" statistic */
        netdev_tx_err ( netdev, NULL, -ENOBUFS );
}

References ENOBUFS, io_buffer::list, list_add_tail, list_check_contains_entry, list_del, netdev, netdev_tx_err(), NULL, net_device::tx_deferred, and net_device::tx_queue.

Referenced by gve_transmit(), mnpnet_transmit(), nii_transmit(), realtek_transmit(), rndis_tx_defer(), and snpnet_transmit().

netdev_tx_err()

void netdev_tx_err	(	struct net_device *	netdev,
		struct io_buffer *	iobuf,
		int	rc
	)

Discard transmitted packet.

Parameters

netdev	Network device
iobuf	I/O buffer, or NULL
rc	Packet status code

The packet is discarded and a TX error is recorded. This function takes ownership of the I/O buffer.

The I/O buffer will be automatically unmapped for DMA, if applicable.

Definition at line 440 of file netdevice.c.

                                                       {

        /* Update statistics counter */
        netdev_record_stat ( &netdev->tx_stats, rc );
        if ( rc == 0 ) {
                DBGC2 ( netdev, "NETDEV %s transmission %p complete\n",
                        netdev->name, iobuf );
        } else {
                DBGC ( netdev, "NETDEV %s transmission %p failed: %s\n",
                       netdev->name, iobuf, strerror ( rc ) );
        }

        /* Unmap I/O buffer, if required */
        if ( iobuf && dma_mapped ( &iobuf->map ) )
                iob_unmap ( iobuf );

        /* Discard packet */
        free_iob ( iobuf );
}

References DBGC, DBGC2, dma_mapped(), free_iob(), iob_unmap(), io_buffer::map, net_device::name, netdev, netdev_record_stat(), rc, strerror(), and net_device::tx_stats.

Referenced by eoib_duplicate(), intel_poll(), neighbour_destroy(), net_tx(), netdev_tx_complete_err(), netdev_tx_defer(), rdc_poll(), rhine_poll(), rndis_tx_complete_err(), snpnet_poll_tx(), vmxnet3_poll_events(), and vmxnet3_poll_tx().

netdev_tx_complete_err()

void netdev_tx_complete_err	(	struct net_device *	netdev,
		struct io_buffer *	iobuf,
		int	rc
	)

Complete network transmission.

Parameters

netdev	Network device
iobuf	I/O buffer
rc	Packet status code

The packet must currently be in the network device's TX queue.

Definition at line 470 of file netdevice.c.

                                                                {

        /* Catch data corruption as early as possible */
        list_check_contains_entry ( iobuf, &netdev->tx_queue, list );

        /* Dequeue and free I/O buffer */
        list_del ( &iobuf->list );
        netdev_tx_err ( netdev, iobuf, rc );

        /* Handle pending transmit queue */
        while ( ( iobuf = list_first_entry ( &netdev->tx_deferred,
                                             struct io_buffer, list ) ) ) {

                /* Remove from pending transmit queue */
                list_del ( &iobuf->list );

                /* When any transmit completion fails, cancel all
                 * pending transmissions.
                 */
                if ( rc != 0 ) {
                        netdev_tx_err ( netdev, iobuf, -ECANCELED );
                        continue;
                }

                /* Otherwise, attempt to transmit the first pending packet */
                netdev_tx ( netdev, iobuf );
                break;
        }
}

References ECANCELED, io_buffer::list, list_check_contains_entry, list_del, list_first_entry, netdev, netdev_tx(), netdev_tx_err(), rc, net_device::tx_deferred, and net_device::tx_queue.

Referenced by axge_out_complete(), dm96xx_out_complete(), ecm_out_complete(), eoib_complete_send(), flexboot_nodnic_eth_complete_send(), gve_start(), hermon_eth_complete_send(), ifec_tx_process(), iphone_out_complete(), ipoib_complete_send(), jme_free_tx_buffers(), jme_tx_clean(), mnpnet_close(), mnpnet_poll_tx(), ncm_out_complete(), net80211_tx_complete(), netdev_tx(), netdev_tx_complete(), netdev_tx_complete_next_err(), netfront_poll_tx(), nii_close(), phantom_close(), rndis_tx_complete_err(), sis190_process_tx(), smscusb_out_complete(), snpnet_close(), vmxnet3_flush_tx(), and vxge_xmit_compl().

netdev_tx_complete_next_err()

void netdev_tx_complete_next_err	(	struct net_device *	netdev,
		int	rc
	)

Complete network transmission.

Parameters

netdev	Network device
rc	Packet status code

Completes the oldest outstanding packet in the TX queue.

Definition at line 509 of file netdevice.c.

                                                                       {
        struct io_buffer *iobuf;

        if ( ( iobuf = list_first_entry ( &netdev->tx_queue, struct io_buffer,
                                          list ) ) != NULL ) {
                netdev_tx_complete_err ( netdev, iobuf, rc );
        }
}

References io_buffer::list, list_first_entry, netdev, netdev_tx_complete_err(), NULL, rc, and net_device::tx_queue.

Referenced by myson_poll_tx(), natsemi_poll_tx(), netdev_tx_complete_next(), netdev_tx_flush(), rhine_poll_tx(), txnic_complete_sqe(), and velocity_poll_tx().

netdev_tx_flush()

static void netdev_tx_flush ( struct net_device *  netdev )

static

Flush device's transmit queue.

Parameters

netdev

Network device

Definition at line 523 of file netdevice.c.

                                                          {

        /* Discard any packets in the TX queue.  This will also cause
         * any packets in the deferred TX queue to be discarded
         * automatically.
         */
        while ( ! list_empty ( &netdev->tx_queue ) ) {
                netdev_tx_complete_next_err ( netdev, -ECANCELED );
        }
        assert ( list_empty ( &netdev->tx_queue ) );
        assert ( list_empty ( &netdev->tx_deferred ) );
}

References assert(), ECANCELED, list_empty, netdev, netdev_tx_complete_next_err(), net_device::tx_deferred, and net_device::tx_queue.

Referenced by free_netdev(), and netdev_close().

netdev_rx()

void netdev_rx	(	struct net_device *	netdev,
		struct io_buffer *	iobuf
	)

Add packet to receive queue.

Parameters

netdev	Network device
iobuf	I/O buffer

The packet is added to the network device's RX queue. This function takes ownership of the I/O buffer.

The I/O buffer will be automatically unmapped for DMA, if applicable.

Definition at line 548 of file netdevice.c.

                                                                      {
        int rc;

        DBGC2 ( netdev, "NETDEV %s received %p (%p+%zx)\n",
                netdev->name, iobuf, iobuf->data, iob_len ( iobuf ) );

        /* Discard packet (for test purposes) if applicable */
        if ( ( rc = inject_fault ( NETDEV_DISCARD_RATE ) ) != 0 ) {
                netdev_rx_err ( netdev, iobuf, rc );
                return;
        }

        /* Unmap I/O buffer, if required */
        if ( dma_mapped ( &iobuf->map ) )
                iob_unmap ( iobuf );

        /* Enqueue packet */
        list_add_tail ( &iobuf->list, &netdev->rx_queue );

        /* Update statistics counter */
        netdev_record_stat ( &netdev->rx_stats, 0 );
}

References io_buffer::data, DBGC2, dma_mapped(), iob_len(), iob_unmap(), io_buffer::list, list_add_tail, io_buffer::map, net_device::name, netdev, NETDEV_DISCARD_RATE, netdev_record_stat(), netdev_rx_err(), rc, net_device::rx_queue, and net_device::rx_stats.

Referenced by a3c90x_process_rx_packets(), atl1e_clean_rx_irq(), atl_poll_rx(), axge_in_complete(), b44_process_rx_packets(), bnxt_rx_process(), dm96xx_in_complete(), ecm_in_complete(), efab_receive(), efx_hunt_receive(), ena_poll_rx(), eoib_complete_recv(), exanic_poll_rx(), flexboot_nodnic_eth_complete_recv(), gve_poll_rx(), icplus_poll_rx(), ifec_rx_process(), igbvf_process_rx_packets(), intel_poll_rx(), iphone_in_complete(), ipoib_complete_recv(), jme_alloc_and_feed_iob(), legacy_poll(), mnpnet_poll_rx(), myri10ge_net_poll(), myson_poll_rx(), natsemi_poll_rx(), ncm_in_complete(), net80211_rx(), netfront_poll_rx(), nii_poll_rx(), nv_process_rx_packets(), pcnet32_process_rx_packets(), phantom_poll(), pnic_poll(), rdc_poll_rx(), realtek_legacy_poll_rx(), realtek_poll_rx(), rhine_poll_rx(), rndis_rx_data(), sis190_process_rx(), skge_rx_done(), sky2_status_intr(), smsc75xx_in_complete(), smsc95xx_in_complete(), snpnet_poll_rx(), tg3_rx_complete(), txnic_complete_rqe(), undinet_poll(), velocity_poll_rx(), virtnet_process_rx_packets(), vlan_netdev_rx(), vlan_rx(), vmxnet3_poll_rx(), and vxge_hw_vpath_poll_rx().

netdev_rx_err()

void netdev_rx_err	(	struct net_device *	netdev,
		struct io_buffer *	iobuf,
		int	rc
	)

Discard received packet.

Parameters

netdev	Network device
iobuf	I/O buffer, or NULL
rc	Packet status code

The packet is discarded and an RX error is recorded. This function takes ownership of the I/O buffer. 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.

The I/O buffer will be automatically unmapped for DMA, if applicable.

Definition at line 586 of file netdevice.c.

                                                       {

        DBGC ( netdev, "NETDEV %s failed to receive %p: %s\n",
               netdev->name, iobuf, strerror ( rc ) );

        /* Unmap I/O buffer, if required */
        if ( iobuf && dma_mapped ( &iobuf->map ) )
                iob_unmap ( iobuf );

        /* Discard packet */
        free_iob ( iobuf );

        /* Update statistics counter */
        netdev_record_stat ( &netdev->rx_stats, rc );
}

References DBGC, dma_mapped(), free_iob(), iob_unmap(), io_buffer::map, net_device::name, netdev, netdev_record_stat(), rc, net_device::rx_stats, and strerror().

Referenced by a3c90x_process_rx_packets(), atl1e_clean_rx_irq(), axge_in_complete(), axge_intr_complete(), axge_poll(), b44_process_rx_packets(), bnxt_rx_process(), dm96xx_in_complete(), dm96xx_intr_complete(), dm96xx_poll(), ecm_in_complete(), ecm_intr_complete(), ecm_poll(), efx_hunt_receive(), eoib_complete_recv(), exanic_close(), exanic_poll_rx(), flexboot_nodnic_eth_complete_recv(), gve_poll_rx(), icplus_poll_rx(), ifec_rx_process(), igbvf_process_rx_packets(), intel_poll(), intel_poll_rx(), intelx_poll(), intelxvf_poll(), iphone_in_complete(), iphone_poll(), ipoib_complete_recv(), jme_process_receive(), mnpnet_poll_rx(), myson_poll_rx(), myson_refill_rx(), natsemi_poll_rx(), natsemi_refill_rx(), ncm_in_complete(), ncm_intr_complete(), ncm_poll(), net80211_rx(), net80211_rx_err(), net_poll(), netdev_rx(), netdev_rx_flush(), netfront_poll_rx(), netfront_refill_rx(), nii_poll_rx(), nv_process_rx_packets(), pcnet32_process_rx_packets(), phantom_refill_rx_ring(), pnic_poll(), rdc_poll_rx(), realtek_legacy_poll_rx(), realtek_poll_rx(), rhine_poll(), rhine_poll_rx(), rndis_rx(), rndis_rx_data(), rndis_rx_err(), rndis_rx_message(), rndis_rx_status(), skge_rx_done(), sky2_receive(), sky2_status_intr(), smsc75xx_in_complete(), smsc75xx_poll(), smsc95xx_in_complete(), smsc95xx_poll(), smscusb_intr_complete(), snpnet_poll_rx(), snpnet_poll_tx(), tg3_rx_complete(), txnic_complete_rqe(), undinet_poll(), velocity_poll_rx(), vlan_netdev_rx(), vlan_netdev_rx_err(), vmxnet3_flush_rx(), vmxnet3_poll_events(), vmxnet3_poll_rx(), and vxge_hw_vpath_poll_rx().

netdev_poll()

void netdev_poll

(

struct net_device *

netdev

)

Poll for completed and received packets on network device.

Parameters

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().

Definition at line 612 of file netdevice.c.

                                               {

        /* Avoid calling poll() on unopened network devices */
        if ( ! netdev_is_open ( netdev ) )
                return;

        /* Guard against re-entry */
        if ( netdev->state & NETDEV_POLL_IN_PROGRESS )
                return;

        /* Poll device */
        netdev->state |= NETDEV_POLL_IN_PROGRESS;
        netdev->op->poll ( netdev );
        netdev->state &= ~NETDEV_POLL_IN_PROGRESS;
}

References netdev, netdev_is_open(), NETDEV_POLL_IN_PROGRESS, net_device::op, net_device_operations::poll, and net_device::state.

Referenced by efi_snp_poll(), gdbudp_recv(), iflinkwait(), net_poll(), and vlan_poll().

netdev_rx_dequeue()

struct io_buffer* netdev_rx_dequeue

(

struct net_device *

netdev

)

Remove packet from device's receive queue.

Parameters

netdev

Network device

Return values

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.

Definition at line 637 of file netdevice.c.

                                                                   {
        struct io_buffer *iobuf;

        iobuf = list_first_entry ( &netdev->rx_queue, struct io_buffer, list );
        if ( ! iobuf )
                return NULL;

        list_del ( &iobuf->list );
        return iobuf;
}

References io_buffer::list, list_del, list_first_entry, netdev, NULL, and net_device::rx_queue.

Referenced by efi_snp_poll(), gdbudp_recv(), net_poll(), netdev_rx_flush(), and pxenv_undi_isr().

netdev_rx_flush()

static void netdev_rx_flush ( struct net_device *  netdev )

static

Flush device's receive queue.

Parameters

netdev

Network device

Definition at line 653 of file netdevice.c.

                                                          {
        struct io_buffer *iobuf;

        /* Discard any packets in the RX queue */
        while ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
                netdev_rx_err ( netdev, iobuf, -ECANCELED );
        }
}

References ECANCELED, netdev, netdev_rx_dequeue(), and netdev_rx_err().

Referenced by free_netdev(), and netdev_close().

netdev_config_close()

static void netdev_config_close ( struct net_device_configuration *  config, int  rc  )

static

Finish network device configuration.

Parameters

config	Network device configuration
rc	Reason for completion

Definition at line 668 of file netdevice.c.

                                           {
        struct net_device_configurator *configurator = config->configurator;
        struct net_device *netdev = config->netdev;

        /* Restart interface */
        intf_restart ( &config->job, rc );

        /* Record configuration result */
        config->rc = rc;
        if ( rc == 0 ) {
                DBGC ( netdev, "NETDEV %s configured via %s\n",
                       netdev->name, configurator->name );
        } else {
                DBGC ( netdev, "NETDEV %s configuration via %s failed: %s\n",
                       netdev->name, configurator->name, strerror ( rc ) );
        }
}

References net_device_configuration::configurator, DBGC, intf_restart(), net_device_configuration::job, net_device_configurator::name, net_device::name, netdev, net_device_configuration::netdev, net_device_configuration::rc, rc, and strerror().

free_netdev()

static void free_netdev ( struct refcnt *  refcnt )

static

Free network device.

Parameters

refcnt

Network device reference counter

Definition at line 702 of file netdevice.c.

                                                  {
        struct net_device *netdev =
                container_of ( refcnt, struct net_device, refcnt );

        assert ( ! timer_running ( &netdev->link_block ) );
        netdev_tx_flush ( netdev );
        netdev_rx_flush ( netdev );
        clear_settings ( netdev_settings ( netdev ) );
        free ( netdev );
}

References assert(), clear_settings(), container_of, free, net_device::link_block, netdev, netdev_rx_flush(), netdev_settings(), and netdev_tx_flush().

Referenced by alloc_netdev().

alloc_netdev()

struct net_device* alloc_netdev

(

size_t

priv_len

)

Allocate network device.

Parameters

priv_len

Length of private data area (net_device::priv)

Return values

netdev

Network device, or NULL

Allocates space for a network device and its private data area.

Definition at line 721 of file netdevice.c.

                                                     {
        struct net_device *netdev;
        struct net_device_configurator *configurator;
        struct net_device_configuration *config;

        netdev = zalloc ( netdev_priv_offset ( NULL ) + priv_len );
        if ( netdev ) {
                ref_init ( &netdev->refcnt, free_netdev );
                netdev->link_rc = -EUNKNOWN_LINK_STATUS;
                timer_init ( &netdev->link_block, netdev_link_block_expired,
                             &netdev->refcnt );
                INIT_LIST_HEAD ( &netdev->tx_queue );
                INIT_LIST_HEAD ( &netdev->tx_deferred );
                INIT_LIST_HEAD ( &netdev->rx_queue );
                netdev_settings_init ( netdev );
                config = netdev->configs;
                for_each_table_entry ( configurator, NET_DEVICE_CONFIGURATORS ){
                        config->netdev = netdev;
                        config->configurator = configurator;
                        config->rc = -EUNUSED_CONFIG;
                        intf_init ( &config->job, &netdev_config_desc,
                                    &netdev->refcnt );
                        config++;
                }
                netdev->priv = netdev_priv ( netdev, NULL );
        }
        return netdev;
}

References net_device::configs, net_device_configuration::configurator, EUNKNOWN_LINK_STATUS, EUNUSED_CONFIG, for_each_table_entry, free_netdev(), INIT_LIST_HEAD, intf_init(), net_device_configuration::job, net_device::link_block, net_device::link_rc, NET_DEVICE_CONFIGURATORS, netdev, net_device_configuration::netdev, netdev_config_desc, netdev_link_block_expired(), netdev_priv(), netdev_priv_offset(), netdev_settings_init(), NULL, net_device::priv, net_device_configuration::rc, ref_init, net_device::refcnt, net_device::rx_queue, net_device::tx_deferred, net_device::tx_queue, and zalloc().

Referenced by alloc_etherdev(), alloc_ipoibdev(), net80211_alloc(), and nii_start().

register_netdev()

int register_netdev

(

struct net_device *

netdev

)

Register network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Gives the network device a name and adds it to the list of network devices.

Definition at line 759 of file netdevice.c.

                                                  {
        struct ll_protocol *ll_protocol = netdev->ll_protocol;
        struct net_driver *driver;
        struct net_device *duplicate;
        unsigned int i;
        uint32_t seed;
        void *priv;
        int rc;

        /* Set initial link-layer address, if not already set */
        if ( ! netdev_has_ll_addr ( netdev ) ) {
                ll_protocol->init_addr ( netdev->hw_addr, netdev->ll_addr );
        }

        /* Set MTU, if not already set */
        if ( ! netdev->mtu ) {
                netdev->mtu = ( netdev->max_pkt_len -
                                ll_protocol->ll_header_len );
        }

        /* Reject named network devices that already exist */
        if ( netdev->name[0] && ( duplicate = find_netdev ( netdev->name ) ) ) {
                DBGC ( netdev, "NETDEV rejecting duplicate name %s\n",
                       duplicate->name );
                rc = -EEXIST;
                goto err_duplicate;
        }

        /* Assign a unique device name, if not already set */
        if ( netdev->name[0] == '\0' ) {
                for ( i = 0 ; ; i++ ) {
                        snprintf ( netdev->name, sizeof ( netdev->name ),
                                   "net%d", i );
                        if ( find_netdev ( netdev->name ) == NULL )
                                break;
                }
        }

        /* Assign a unique non-zero scope ID */
        for ( netdev->scope_id = 1 ; ; netdev->scope_id++ ) {
                if ( find_netdev_by_scope_id ( netdev->scope_id ) == NULL )
                        break;
        }

        /* Use least significant bits of the link-layer address to
         * improve the randomness of the (non-cryptographic) random
         * number generator.
         */
        memcpy ( &seed, ( netdev->ll_addr + ll_protocol->ll_addr_len
                          - sizeof ( seed ) ), sizeof ( seed ) );
        srand ( rand() ^ seed );

        /* Add to device list */
        netdev_get ( netdev );
        list_add_tail ( &netdev->list, &net_devices );
        DBGC ( netdev, "NETDEV %s registered (phys %s hwaddr %s)\n",
               netdev->name, netdev->dev->name,
               netdev_addr ( netdev ) );

        /* Register per-netdev configuration settings */
        if ( ( rc = register_settings ( netdev_settings ( netdev ),
                                        NULL, netdev->name ) ) != 0 ) {
                DBGC ( netdev, "NETDEV %s could not register settings: %s\n",
                       netdev->name, strerror ( rc ) );
                goto err_register_settings;
        }

        /* Probe device */
        for_each_table_entry ( driver, NET_DRIVERS ) {
                priv = netdev_priv ( netdev, driver );
                if ( driver->probe &&
                     ( rc = driver->probe ( netdev, priv ) ) != 0 ) {
                        DBGC ( netdev, "NETDEV %s could not add %s device: "
                               "%s\n", netdev->name, driver->name,
                               strerror ( rc ) );
                        goto err_probe;
                }
        }

        return 0;

 err_probe:
        for_each_table_entry_continue_reverse ( driver, NET_DRIVERS ) {
                priv = netdev_priv ( netdev, driver );
                if ( driver->remove )
                        driver->remove ( netdev, priv );
        }
        clear_settings ( netdev_settings ( netdev ) );
        unregister_settings ( netdev_settings ( netdev ) );
 err_register_settings:
        list_del ( &netdev->list );
        netdev_put ( netdev );
 err_duplicate:
        return rc;
}

References clear_settings(), DBGC, net_device::dev, EEXIST, find_netdev(), find_netdev_by_scope_id(), for_each_table_entry, for_each_table_entry_continue_reverse, net_device::hw_addr, ll_protocol::init_addr, net_device::list, list_add_tail, list_del, net_device::ll_addr, ll_protocol::ll_addr_len, ll_protocol::ll_header_len, net_device::ll_protocol, net_device::max_pkt_len, memcpy(), net_device::mtu, device::name, net_device::name, net_driver::name, net_devices, NET_DRIVERS, netdev, netdev_addr(), netdev_get(), netdev_has_ll_addr(), netdev_priv(), netdev_put(), netdev_settings(), NULL, priv, net_driver::probe, rand(), rc, register_settings(), net_driver::remove, net_device::scope_id, snprintf(), srand(), strerror(), and unregister_settings().

Referenced by a3c90x_probe(), atl1e_probe(), atl_probe(), axge_probe(), b44_probe(), bnxt_init_one(), dm96xx_probe(), ecm_probe(), efab_probe(), ena_probe(), eoib_create(), exanic_probe_port(), flexboot_nodnic_register_netdev(), forcedeth_probe(), gve_probe(), hermon_register_netdev(), hunt_probe(), ice_probe(), icplus_probe(), ifec_pci_probe(), igbvf_probe(), intel_probe(), intelx_probe(), intelxl_probe(), intelxlvf_probe(), intelxvf_probe(), iphone_probe(), ipoib_probe(), jme_probe(), lan78xx_probe(), legacy_probe(), mnpnet_start(), myri10ge_pci_probe(), myson_probe(), natsemi_probe(), ncm_probe(), net80211_register(), netfront_probe(), nii_start(), pcnet32_probe(), phantom_probe(), pnic_probe(), rdc_probe(), realtek_probe(), register_rndis(), rhine_probe(), sis190_probe(), skeleton_probe(), skge_probe(), sky2_probe(), smsc75xx_probe(), smsc95xx_probe(), snpnet_start(), tg3_init_one(), txnic_lmac_probe(), undinet_probe(), velocity_probe(), virtnet_probe_legacy(), virtnet_probe_modern(), vlan_create(), vmxnet3_probe(), and vxge_device_register().

netdev_open()

int netdev_open

(

struct net_device *

netdev

)

Open network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 861 of file netdevice.c.

                                              {
        int rc;

        /* Do nothing if device is already open */
        if ( netdev->state & NETDEV_OPEN )
                return 0;

        DBGC ( netdev, "NETDEV %s opening\n", netdev->name );

        /* Mark as opened */
        netdev->state |= NETDEV_OPEN;

        /* Open the device */
        if ( ( rc = netdev->op->open ( netdev ) ) != 0 )
                goto err;

        /* Add to head of open devices list */
        list_add ( &netdev->open_list, &open_net_devices );

        /* Notify drivers of device state change */
        netdev_notify ( netdev );

        return 0;

 err:
        netdev->state &= ~NETDEV_OPEN;
        return rc;
}

References DBGC, list_add, net_device::name, netdev, netdev_notify(), NETDEV_OPEN, net_device::op, net_device_operations::open, net_device::open_list, open_net_devices, rc, and net_device::state.

Referenced by apply_netdev_settings(), efi_autoexec_network(), efi_snp_initialize(), efi_snp_reset(), gdbudp_ensure_netdev_open(), ifopen(), iwlist(), netvsc_reset(), pxe_exec(), pxe_netdev_open(), pxenv_udp_open(), vlan_open(), vlan_sync(), and xve_open().

netdev_close()

void netdev_close

(

struct net_device *

netdev

)

Close network device.

Parameters

netdev

Network device

Definition at line 895 of file netdevice.c.

                                                {
        unsigned int num_configs;
        unsigned int i;

        /* Do nothing if device is already closed */
        if ( ! ( netdev->state & NETDEV_OPEN ) )
                return;

        DBGC ( netdev, "NETDEV %s closing\n", netdev->name );

        /* Terminate any ongoing configurations.  Use intf_close()
         * rather than intf_restart() to allow the cancellation to be
         * reported back to us if a configuration is actually in
         * progress.
         */
        num_configs = table_num_entries ( NET_DEVICE_CONFIGURATORS );
        for ( i = 0 ; i < num_configs ; i++ )
                intf_close ( &netdev->configs[i].job, -ECANCELED );

        /* Remove from open devices list */
        list_del ( &netdev->open_list );

        /* Mark as closed */
        netdev->state &= ~NETDEV_OPEN;

        /* Notify drivers of device state change */
        netdev_notify ( netdev );

        /* Close the device */
        netdev->op->close ( netdev );

        /* Stop link block timer */
        stop_timer ( &netdev->link_block );

        /* Flush TX and RX queues */
        netdev_tx_flush ( netdev );
        netdev_rx_flush ( netdev );
}

References net_device_operations::close, net_device::configs, DBGC, ECANCELED, intf_close(), net_device_configuration::job, net_device::link_block, list_del, net_device::name, NET_DEVICE_CONFIGURATORS, netdev, netdev_notify(), NETDEV_OPEN, netdev_rx_flush(), netdev_tx_flush(), net_device::op, net_device::open_list, net_device::state, stop_timer(), and table_num_entries.

Referenced by apply_netdev_settings(), efi_snp_reset(), efi_snp_shutdown(), ifclose(), ifconf_payload(), iflinkwait_payload(), iwlist(), netvsc_reset(), pxe_netdev_close(), unregister_netdev(), vlan_close(), vlan_sync(), and xve_close().

unregister_netdev()

void unregister_netdev

(

struct net_device *

netdev

)

Unregister network device.

Parameters

netdev

Network device

Removes the network device from the list of network devices.

Definition at line 941 of file netdevice.c.

                                                     {
        struct net_driver *driver;
        void *priv;

        /* Ensure device is closed */
        netdev_close ( netdev );

        /* Remove device */
        for_each_table_entry_reverse ( driver, NET_DRIVERS ) {
                priv = netdev_priv ( netdev, driver );
                if ( driver->remove )
                        driver->remove ( netdev, priv );
        }

        /* Unregister per-netdev configuration settings */
        clear_settings ( netdev_settings ( netdev ) );
        unregister_settings ( netdev_settings ( netdev ) );

        /* Remove from device list */
        DBGC ( netdev, "NETDEV %s unregistered\n", netdev->name );
        list_del ( &netdev->list );
        netdev_put ( netdev );
}

References clear_settings(), DBGC, for_each_table_entry_reverse, net_device::list, list_del, net_device::name, NET_DRIVERS, netdev, netdev_close(), netdev_priv(), netdev_put(), netdev_settings(), priv, net_driver::remove, and unregister_settings().

Referenced by a3c90x_remove(), atl1e_remove(), atl_remove(), axge_probe(), axge_remove(), b44_remove(), bnxt_remove_one(), dm96xx_probe(), dm96xx_remove(), ecm_probe(), ecm_remove(), efab_probe(), efab_remove(), ena_probe(), ena_remove(), eoib_create(), eoib_destroy(), exanic_probe_port(), exanic_remove_port(), flexboot_nodnic_unregister_netdev(), forcedeth_remove(), gve_probe(), gve_remove(), hermon_register_netdev(), hermon_unregister_netdev(), hunt_remove(), ice_probe(), ice_remove(), icplus_probe(), icplus_remove(), ifec_pci_remove(), igbvf_remove(), intel_probe(), intel_remove(), intelx_probe(), intelx_remove(), intelxl_probe(), intelxl_remove(), intelxlvf_probe(), intelxlvf_remove(), intelxvf_probe(), intelxvf_remove(), iphone_probe(), iphone_remove(), ipoib_probe(), ipoib_remove(), jme_remove(), lan78xx_probe(), lan78xx_remove(), legacy_remove(), mnpnet_start(), mnpnet_stop(), myri10ge_pci_probe(), myri10ge_pci_remove(), myson_probe(), myson_remove(), natsemi_probe(), natsemi_remove(), ncm_probe(), ncm_remove(), net80211_unregister(), netfront_probe(), netfront_remove(), nii_start(), nii_stop(), pcnet32_remove(), phantom_probe(), phantom_remove(), pnic_remove(), rdc_probe(), rdc_remove(), realtek_probe(), realtek_remove(), register_rndis(), rhine_remove(), sis190_remove(), skeleton_probe(), skeleton_remove(), skge_remove(), sky2_remove(), smsc75xx_probe(), smsc75xx_remove(), smsc95xx_probe(), smsc95xx_remove(), snpnet_start(), snpnet_stop(), tg3_remove_one(), txnic_lmac_probe(), txnic_lmac_remove(), undinet_remove(), unregister_rndis(), velocity_remove(), virtnet_probe_legacy(), virtnet_probe_modern(), virtnet_remove(), vlan_create(), vlan_destroy(), vmxnet3_probe(), vmxnet3_remove(), and vxge_device_unregister().

netdev_irq()

void netdev_irq	(	struct net_device *	netdev,
		int	enable
	)

Enable or disable interrupts.

Parameters

netdev	Network device
enable	Interrupts should be enabled

Definition at line 970 of file netdevice.c.

                                                          {

        /* Enable or disable device interrupts, if applicable */
        if ( netdev_irq_supported ( netdev ) )
                netdev->op->irq ( netdev, enable );

        /* Record interrupt enabled state */
        netdev->state &= ~NETDEV_IRQ_ENABLED;
        if ( enable )
                netdev->state |= NETDEV_IRQ_ENABLED;
}

References net_device_operations::irq, netdev, NETDEV_IRQ_ENABLED, netdev_irq_supported(), net_device::op, and net_device::state.

Referenced by pxe_netdev_close(), pxe_netdev_open(), pxenv_undi_isr(), pxenv_undi_transmit(), virtnet_open_legacy(), virtnet_open_modern(), and vlan_irq().

find_netdev()

struct net_device* find_netdev

(

const char *

name

)

Get network device by name.

Parameters

name	Network device name

Return values

netdev

Network device, or NULL

Definition at line 988 of file netdevice.c.

                                                     {
        struct net_device *netdev;

        /* Allow "netX" shortcut */
        if ( strcmp ( name, "netX" ) == 0 )
                return last_opened_netdev();

        /* Identify network device by name */
        list_for_each_entry ( netdev, &net_devices, list ) {
                if ( strcmp ( netdev->name, name ) == 0 )
                        return netdev;
        }

        return NULL;
}

References last_opened_netdev(), net_device::list, list_for_each_entry, net_device::name, name, net_devices, netdev, NULL, and strcmp().

Referenced by gdbudp_configure(), ipv6_sock_aton(), netdev_redirect(), parse_netdev(), and register_netdev().

find_netdev_by_scope_id()

struct net_device* find_netdev_by_scope_id

(

unsigned int

scope_id

)

Get network device by scope ID.

Parameters

index

Network device index

Return values

netdev

Network device, or NULL

Definition at line 1010 of file netdevice.c.

                                                                      {
        struct net_device *netdev;

        /* Identify network device by index */
        list_for_each_entry ( netdev, &net_devices, list ) {
                if ( netdev->scope_id == scope_id )
                        return netdev;
        }

        return NULL;
}

References net_device::list, list_for_each_entry, net_devices, netdev, NULL, and net_device::scope_id.

Referenced by ipv6_sock_ntoa(), and register_netdev().

find_netdev_by_location()

struct net_device* find_netdev_by_location	(	unsigned int	bus_type,
		unsigned int	location
	)

Get network device by PCI bus:dev.fn address.

Parameters

bus_type	Bus type
location	Bus location

Return values

netdev

Network device, or NULL

Definition at line 1029 of file netdevice.c.

                                                                      {
        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;    
}

References device_description::bus_type, device::desc, net_device::dev, net_device::list, list_for_each_entry, device_description::location, net_devices, netdev, and NULL.

Referenced by pxenv_start_undi().

last_opened_netdev()

struct net_device* last_opened_netdev

(

void

)

Get most recently opened network device.

Return values

netdev

Most recently opened network device, or NULL

Definition at line 1047 of file netdevice.c.

                                                {
        struct net_device *netdev;

        netdev = list_first_entry ( &open_net_devices, struct net_device,
                                    open_list );
        if ( ! netdev )
                return NULL;

        assert ( netdev_is_open ( netdev ) );
        return netdev;
}

References assert(), list_first_entry, netdev, netdev_is_open(), NULL, net_device::open_list, and open_net_devices.

Referenced by aoe_open(), find_netdev(), ipv6_sock_aton(), last_opened_snpdev(), nbi_prepare_dhcp(), and pxe_exec().

net_tx()

int net_tx	(	struct io_buffer *	iobuf,
		struct net_device *	netdev,
		struct net_protocol *	net_protocol,
		const void *	ll_dest,
		const void *	ll_source
	)

Transmit network-layer packet.

Parameters

iobuf	I/O buffer
netdev	Network device
net_protocol	Network-layer protocol
ll_dest	Destination link-layer address
ll_source	Source link-layer address

Return values

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.

Definition at line 1073 of file netdevice.c.

                                     {
        struct ll_protocol *ll_protocol = netdev->ll_protocol;
        int rc;

        /* Add link-layer header */
        if ( ( rc = ll_protocol->push ( netdev, iobuf, ll_dest, ll_source,
                                        net_protocol->net_proto ) ) != 0 ) {
                /* Record error for diagnosis */
                netdev_tx_err ( netdev, iobuf, rc );
                return rc;
        }

        /* Transmit packet */
        return netdev_tx ( netdev, iobuf );
}

References net_device::ll_protocol, net_protocol::net_proto, netdev, netdev_tx(), netdev_tx_err(), ll_protocol::push, and rc.

Referenced by aoecmd_tx(), arp_rx(), arp_tx_request(), eapol_tx(), eth_slow_lacp_rx(), eth_slow_marker_rx(), fcoe_deliver(), fcoe_fip_tx_keepalive(), fcoe_fip_tx_solicitation(), fcoe_fip_tx_vlan(), ipv4_tx(), ipv6_tx(), loopback_test(), neighbour_discovered(), neighbour_tx(), vlan_transmit(), and wpa_send_eapol().

net_rx()

int net_rx	(	struct io_buffer *	iobuf,
		struct net_device *	netdev,
		uint16_t	net_proto,
		const void *	ll_dest,
		const void *	ll_source,
		unsigned int	flags
	)

Process received network-layer packet.

Parameters

iobuf	I/O buffer
netdev	Network device
net_proto	Network-layer protocol, in network-byte order
ll_dest	Destination link-layer address
ll_source	Source link-layer address
flags	Packet flags

Return values

rc	Return status code

Definition at line 1102 of file netdevice.c.

                                  {
        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_dest,
                                                  ll_source, flags );
        }

        DBGC ( netdev, "NETDEV %s unknown network protocol %04x\n",
               netdev->name, ntohs ( net_proto ) );
        free_iob ( iobuf );
        return -ENOTSUP;
}

References DBGC, ENOTSUP, flags, for_each_table_entry, free_iob(), net_device::name, net_protocol::net_proto, NET_PROTOCOLS, netdev, ntohs, and net_protocol::rx.

Referenced by net_poll().

net_poll()

void net_poll

(

void

)

Poll the network stack.

This polls all interfaces for received packets, and processes packets from the RX queue.

Definition at line 1126 of file netdevice.c.

                       {
        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;
        unsigned int flags;
        int rc;

        /* Poll and process each network device */
        list_for_each_entry ( netdev, &net_devices, list ) {

                /* Poll for new packets */
                profile_start ( &net_poll_profiler );
                netdev_poll ( netdev );
                profile_stop ( &net_poll_profiler );

                /* Leave received packets on the queue if receive
                 * queue processing is currently frozen.  This will
                 * happen when the raw packets are to be manually
                 * dequeued using netdev_rx_dequeue(), rather than
                 * processed via the usual networking stack.
                 */
                if ( netdev_rx_frozen ( netdev ) )
                        continue;

                /* Process all received packets */
                while ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {

                        DBGC2 ( netdev, "NETDEV %s processing %p (%p+%zx)\n",
                                netdev->name, iobuf, iobuf->data,
                                iob_len ( iobuf ) );
                        profile_start ( &net_rx_profiler );

                        /* Remove link-layer header */
                        ll_protocol = netdev->ll_protocol;
                        if ( ( rc = ll_protocol->pull ( netdev, iobuf,
                                                        &ll_dest, &ll_source,
                                                        &net_proto,
                                                        &flags ) ) != 0 ) {
                                free_iob ( iobuf );
                                continue;
                        }

                        /* Hand packet to network layer */
                        if ( ( rc = net_rx ( iob_disown ( iobuf ), netdev,
                                             net_proto, ll_dest,
                                             ll_source, flags ) ) != 0 ) {
                                /* Record error for diagnosis */
                                netdev_rx_err ( netdev, NULL, rc );
                        }
                        profile_stop ( &net_rx_profiler );
                }
        }
}

References io_buffer::data, DBGC2, flags, free_iob(), iob_disown, iob_len(), list_for_each_entry, net_device::ll_protocol, net_device::name, net_devices, net_rx(), netdev, netdev_poll(), netdev_rx_dequeue(), netdev_rx_err(), netdev_rx_frozen(), NULL, profile_start(), profile_stop(), ll_protocol::pull, and rc.

Referenced by loopback_wait(), net_step(), and pxenv_undi_isr().

net_step()

static void net_step ( struct process *process  __unused )

static

Single-step the network stack.

Parameters

process

Network stack process

Definition at line 1188 of file netdevice.c.

                                                          {
        net_poll();
}

References net_poll().

vlan_tci()

__weak unsigned int vlan_tci

(

struct net_device *netdev

__unused

)

Get the VLAN tag control information (when VLAN support is not present)

Parameters

netdev

Network device

Return values

tag	0, indicating that device is not a VLAN device

Definition at line 1198 of file netdevice.c.

                                                                    {
        return 0;
}

Referenced by efi_snp_probe(), and efi_vlan_find().

vlan_netdev_rx()

__weak void vlan_netdev_rx	(	struct net_device *	netdev,
		unsigned int	tag,
		struct io_buffer *	iobuf
	)

Add VLAN tag-stripped packet to queue (when VLAN support is not present)

Parameters

netdev	Network device
tag	VLAN tag, or zero
iobuf	I/O buffer

Definition at line 1209 of file netdevice.c.

                                                       {

        if ( tag == 0 ) {
                netdev_rx ( netdev, iobuf );
        } else {
                netdev_rx_err ( netdev, iobuf, -ENODEV );
        }
}

Referenced by hermon_eth_complete_recv(), and intelxl_poll_rx().

vlan_netdev_rx_err()

__weak void vlan_netdev_rx_err	(	struct net_device *	netdev,
		unsigned int tag	__unused,
		struct io_buffer *	iobuf,
		int	rc
	)

Discard received VLAN tag-stripped packet (when VLAN support is not present)

Parameters

netdev	Network device
tag	VLAN tag, or zero
iobuf	I/O buffer, or NULL
rc	Packet status code

Definition at line 1227 of file netdevice.c.

                                                                   {

        netdev_rx_err ( netdev, iobuf, rc );
}

Referenced by hermon_eth_complete_recv(), and intelxl_poll_rx().

PERMANENT_PROCESS()

PERMANENT_PROCESS	(	net_process	,
		net_step
	)

Networking stack process.

net_discard()

static unsigned int net_discard ( void  )

static

Discard some cached network device data.

Return values

discarded

Number of cached items discarded

Definition at line 1242 of file netdevice.c.

                                         {
        struct net_device *netdev;
        struct io_buffer *iobuf;
        unsigned int discarded = 0;

        /* Try to drop one deferred TX packet from each network device */
        for_each_netdev ( netdev ) {
                if ( ( iobuf = list_first_entry ( &netdev->tx_deferred,
                                                  struct io_buffer,
                                                  list ) ) != NULL ) {

                        /* Discard first deferred packet */
                        list_del ( &iobuf->list );
                        if ( dma_mapped ( &iobuf->map ) )
                                iob_unmap ( iobuf );
                        free_iob ( iobuf );

                        /* Report discard */
                        discarded++;
                }
        }

        return discarded;
}

References dma_mapped(), for_each_netdev, free_iob(), iob_unmap(), io_buffer::list, list_del, list_first_entry, io_buffer::map, netdev, NULL, and net_device::tx_deferred.

__cache_discarder()

struct cache_discarder net_discarder __cache_discarder

(

CACHE_NORMAL

)

Network device cache discarder.

find_netdev_configurator()

struct net_device_configurator* find_netdev_configurator

(

const char *

name

)

Find network device configurator.

Parameters

name

Name

Return values

configurator

Network device configurator, or NULL

Definition at line 1278 of file netdevice.c.

                                                                               {
        struct net_device_configurator *configurator;

        for_each_table_entry ( configurator, NET_DEVICE_CONFIGURATORS ) {
                if ( strcmp ( configurator->name, name ) == 0 )
                        return configurator;
        }
        return NULL;
}

References for_each_table_entry, net_device_configurator::name, name, NET_DEVICE_CONFIGURATORS, NULL, and strcmp().

Referenced by parse_netdev_configurator().

netdev_configure()

int netdev_configure	(	struct net_device *	netdev,
		struct net_device_configurator *	configurator
	)

Start network device configuration.

Parameters

netdev	Network device
configurator	Network device configurator

Return values

rc	Return status code

Definition at line 1295 of file netdevice.c.

                                                                      {
        struct net_device_configuration *config =
                netdev_configuration ( netdev, configurator );
        int rc;

        /* Check applicability of configurator */
        if ( ! netdev_configurator_applies ( netdev, configurator ) ) {
                DBGC ( netdev, "NETDEV %s does not support configuration via "
                       "%s\n", netdev->name, configurator->name );
                return -ENOTSUP;
        }

        /* Terminate any ongoing configuration */
        intf_restart ( &config->job, -ECANCELED );

        /* Mark configuration as being in progress */
        config->rc = -EINPROGRESS_CONFIG;

        DBGC ( netdev, "NETDEV %s starting configuration via %s\n",
               netdev->name, configurator->name );

        /* Start configuration */
        if ( ( rc = configurator->start ( &config->job, netdev ) ) != 0 ) {
                DBGC ( netdev, "NETDEV %s could not start configuration via "
                       "%s: %s\n", netdev->name, configurator->name,
                       strerror ( rc ) );
                config->rc = rc;
                return rc;
        }

        return 0;
}

References net_device_configuration::configurator, DBGC, ECANCELED, EINPROGRESS_CONFIG, ENOTSUP, intf_restart(), net_device_configuration::job, net_device_configurator::name, net_device::name, netdev, netdev_configuration(), netdev_configurator_applies(), net_device_configuration::rc, rc, net_device_configurator::start, and strerror().

Referenced by ifconf(), and netdev_configure_all().

netdev_configure_all()

int netdev_configure_all

(

struct net_device *

netdev

)

Start network device configuration via all supported configurators.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 1335 of file netdevice.c.

                                                       {
        struct net_device_configurator *configurator;
        int rc;

        /* Start configuration for each configurator */
        for_each_table_entry ( configurator, NET_DEVICE_CONFIGURATORS ) {

                /* Skip any inapplicable configurators */
                if ( ! netdev_configurator_applies ( netdev, configurator ) )
                        continue;

                /* Start configuration */
                if ( ( rc = netdev_configure ( netdev, configurator ) ) != 0 )
                        return rc;
        }

        return 0;
}

References for_each_table_entry, NET_DEVICE_CONFIGURATORS, netdev, netdev_configurator_applies(), netdev_configure(), and rc.

Referenced by efi_pxe_dhcp(), and ifconf().

netdev_has_configuration_rc()

static int netdev_has_configuration_rc ( struct net_device *  netdev, int  rc  )

static

Check if network device has a configuration with a specified status code.

Parameters

netdev	Network device
rc	Status code

Return values

has_rc

Network device has a configuration with this status code

Definition at line 1361 of file netdevice.c.

                                                                             {
        unsigned int num_configs;
        unsigned int i;

        num_configs = table_num_entries ( NET_DEVICE_CONFIGURATORS );
        for ( i = 0 ; i < num_configs ; i++ ) {
                if ( netdev->configs[i].rc == rc )
                        return 1;
        }
        return 0;
}

References net_device::configs, NET_DEVICE_CONFIGURATORS, netdev, net_device_configuration::rc, rc, and table_num_entries.

Referenced by netdev_configuration_in_progress(), and netdev_configuration_ok().

netdev_configuration_in_progress()

int netdev_configuration_in_progress

(

struct net_device *

netdev

)

Check if network device configuration is in progress.

Parameters

netdev

Network device

Return values

is_in_progress

Network device configuration is in progress

Definition at line 1379 of file netdevice.c.

                                                                   {

        return netdev_has_configuration_rc ( netdev, -EINPROGRESS_CONFIG );
}

References EINPROGRESS_CONFIG, netdev, and netdev_has_configuration_rc().

Referenced by efi_pxe_dhcp(), and ifconf_progress().

netdev_configuration_ok()

int netdev_configuration_ok

(

struct net_device *

netdev

)

Check if network device has at least one successful configuration.

Parameters

netdev	Network device
configurator	Configurator

Return values

rc	Return status code

Definition at line 1391 of file netdevice.c.

                                                          {

        return netdev_has_configuration_rc ( netdev, 0 );
}

References netdev, and netdev_has_configuration_rc().

Referenced by efi_pxe_dhcp(), and ifconf_progress().

Variable Documentation

net_devices

struct list_head net_devices = LIST_HEAD_INIT ( net_devices )

List of network devices.

Definition at line 53 of file netdevice.c.

Referenced by find_netdev(), find_netdev_by_location(), find_netdev_by_scope_id(), have_netdevs(), net_poll(), and register_netdev().

open_net_devices

struct list_head open_net_devices = LIST_HEAD_INIT ( open_net_devices )

static

List of open network devices, in reverse order of opening.

Definition at line 56 of file netdevice.c.

Referenced by last_opened_netdev(), and netdev_open().

__profiler

struct profiler net_tx_profiler __profiler = { .name = "net.poll" }

static

Network polling profiler.

Network transmit profiler.

Network receive profiler.

Definition at line 59 of file netdevice.c.

__errortab

struct errortab netdev_errors [] __errortab

Initial value:

= {
        __einfo_errortab ( EINFO_EUNKNOWN_LINK_STATUS ),
        __einfo_errortab ( EINFO_ENOTCONN_LINK_DOWN ),
        __einfo_errortab ( EINFO_EUNUSED_CONFIG ),
        __einfo_errortab ( EINFO_EINPROGRESS_CONFIG ),
}

Human-readable message for the default link statuses.

Definition at line 88 of file netdevice.c.

netdev_config_ops

struct interface_operation netdev_config_ops[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct net_device_configuration *,
                  netdev_config_close ),
}

Network device configuration interface operations.

Definition at line 688 of file netdevice.c.

netdev_config_desc

struct interface_descriptor netdev_config_desc

static

Initial value:

=
        INTF_DESC ( struct net_device_configuration, job, netdev_config_ops )

Network device configuration interface descriptor.

Definition at line 694 of file netdevice.c.

Referenced by alloc_netdev().