netfront.c File Reference

Xen netfront driver. More...

#include <stdint.h>
#include <stdlib.h>
#include <errno.h>
#include <ipxe/netdevice.h>
#include <ipxe/ethernet.h>
#include <ipxe/if_ether.h>
#include <ipxe/malloc.h>
#include <ipxe/base16.h>
#include <ipxe/xen.h>
#include <ipxe/xenstore.h>
#include <ipxe/xenbus.h>
#include <ipxe/xengrant.h>
#include <ipxe/xenevent.h>
#include "netfront.h"

Go to the source code of this file.

Macros
#define	EIO_NETIF_RSP_ERROR    __einfo_error ( EINFO_EIO_NETIF_RSP_ERROR )
#define	EINFO_EIO_NETIF_RSP_ERROR
#define	EIO_NETIF_RSP_DROPPED    __einfo_error ( EINFO_EIO_NETIF_RSP_DROPPED )
#define	EINFO_EIO_NETIF_RSP_DROPPED
#define	EIO_NETIF_RSP(status)

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static	LIST_HEAD (netfront_devices)
	List of netfront devices.
static int	netfront_reset (struct netfront_nic *netfront)
	Reset device.
static int	netfront_read_mac (struct netfront_nic *netfront, void *hw_addr)
	Fetch MAC address.
static int	netfront_write_num (struct netfront_nic *netfront, const char *subkey, unsigned long num)
	Write XenStore numeric value.
static int	netfront_write_flag (struct netfront_nic *netfront, const char *subkey)
	Write XenStore flag value.
static int	netfront_rm (struct netfront_nic *netfront, const char *subkey)
	Delete XenStore value.
static int	netfront_create_event (struct netfront_nic *netfront)
	Create event channel.
static int	netfront_send_event (struct netfront_nic *netfront)
	Send event.
static void	netfront_destroy_event (struct netfront_nic *netfront)
	Destroy event channel.
static int	netfront_create_ring (struct netfront_nic *netfront, struct netfront_ring *ring)
	Create descriptor ring.
static int	netfront_push (struct netfront_nic *netfront, struct netfront_ring *ring, physaddr_t addr, struct io_buffer *iobuf, uint16_t *id, grant_ref_t *ref)
	Add buffer to descriptor ring.
static struct io_buffer *	netfront_pull (struct netfront_nic *netfront, struct netfront_ring *ring, unsigned int id)
	Remove buffer from descriptor ring.
static void	netfront_destroy_ring (struct netfront_nic *netfront, struct netfront_ring *ring, void(*discard)(struct io_buffer *))
	Destroy descriptor ring.
static void	netfront_discard (struct netfront_nic *netfront)
	Discard partially received I/O buffers.
static void	netfront_refill_rx (struct net_device *netdev)
	Refill receive descriptor ring.
static int	netfront_open (struct net_device *netdev)
	Open network device.
static void	netfront_close (struct net_device *netdev)
	Close network device.
static int	netfront_transmit (struct net_device *netdev, struct io_buffer *iobuf)
	Transmit packet.
static void	netfront_poll_tx (struct net_device *netdev)
	Poll for completed packets.
static void	netfront_poll_rx (struct net_device *netdev)
	Poll for received packets.
static void	netfront_poll (struct net_device *netdev)
	Poll for completed and received packets.
static int	netfront_probe (struct xen_device *xendev)
	Probe Xen device.
static void	netfront_remove (struct xen_device *xendev)
	Remove Xen device.
	XEN_ROM ("netfront", "Xen netfront virtual NIC")
static int	netfront_net_probe (struct net_device *netdev, void *priv __unused)
	Inhibit emulated PCI devices.

Variables
static struct net_device_operations	netfront_operations
	Network device operations.
struct xen_driver netfront_driver	__xen_driver
	Xen netfront driver.
struct net_driver netfront_net_driver	__net_driver
	Emulated PCI device inhibitor driver.

Detailed Description

Xen netfront driver.

Definition in file netfront.c.

Macro Definition Documentation

EIO_NETIF_RSP_ERROR

#define EIO_NETIF_RSP_ERROR    __einfo_error ( EINFO_EIO_NETIF_RSP_ERROR )

Definition at line 49 of file netfront.c.

#define EIO_NETIF_RSP_ERROR                                             \
        __einfo_error ( EINFO_EIO_NETIF_RSP_ERROR )

EINFO_EIO_NETIF_RSP_ERROR

#define EINFO_EIO_NETIF_RSP_ERROR

Value:

        __einfo_uniqify ( EINFO_EIO, -NETIF_RSP_ERROR,                   \
                          "Unspecified network error" )

Definition at line 51 of file netfront.c.

#define EINFO_EIO_NETIF_RSP_ERROR                                       \
        __einfo_uniqify ( EINFO_EIO, -NETIF_RSP_ERROR,                  \
                          "Unspecified network error" )

EIO_NETIF_RSP_DROPPED

#define EIO_NETIF_RSP_DROPPED    __einfo_error ( EINFO_EIO_NETIF_RSP_DROPPED )

Definition at line 54 of file netfront.c.

#define EIO_NETIF_RSP_DROPPED                                           \
        __einfo_error ( EINFO_EIO_NETIF_RSP_DROPPED )

EINFO_EIO_NETIF_RSP_DROPPED

#define EINFO_EIO_NETIF_RSP_DROPPED

Value:

        __einfo_uniqify ( EINFO_EIO, -NETIF_RSP_DROPPED,               \
                          "Packet dropped" )

Definition at line 56 of file netfront.c.

#define EINFO_EIO_NETIF_RSP_DROPPED                                     \
        __einfo_uniqify ( EINFO_EIO, -NETIF_RSP_DROPPED,                \
                          "Packet dropped" )

EIO_NETIF_RSP

#define EIO_NETIF_RSP

(

status

)

Value:

        EUNIQ ( EINFO_EIO, ( -(status) & 0x1f ),                    \
                EIO_NETIF_RSP_ERROR, EIO_NETIF_RSP_DROPPED )

Definition at line 59 of file netfront.c.

#define EIO_NETIF_RSP( status )                                         \
        EUNIQ ( EINFO_EIO, ( -(status) & 0x1f ),                        \
                EIO_NETIF_RSP_ERROR, EIO_NETIF_RSP_DROPPED )

Referenced by netfront_poll_rx(), and netfront_poll_tx().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

LIST_HEAD()

LIST_HEAD ( netfront_devices )

static

List of netfront devices.

netfront_reset()

int netfront_reset ( struct netfront_nic * netfront )

static

Reset device.

Parameters

netfront

Netfront device

Return values

rc	Return status code

Definition at line 79 of file netfront.c.

                                                            {
        struct xen_device *xendev = netfront->xendev;
        int state;
        int rc;
 
        /* Get current backend state */
        if ( ( state = xenbus_backend_state ( xendev ) ) < 0 ) {
                rc = state;
                DBGC ( netfront, "NETFRONT %s could not read backend state: "
                       "%s\n", xendev->key, strerror ( rc ) );
                return rc;
        }
 
        /* If the backend is not already in InitWait, then mark
         * frontend as Closed to shut down the backend.
         */
        if ( state != XenbusStateInitWait ) {
 
                /* Set state to Closed */
                xenbus_set_state ( xendev, XenbusStateClosed );
 
                /* Wait for backend to reach Closed */
                if ( ( rc = xenbus_backend_wait ( xendev,
                                                  XenbusStateClosed ) ) != 0 ) {
                        DBGC ( netfront, "NETFRONT %s backend did not reach "
                               "Closed: %s\n", xendev->key, strerror ( rc ) );
                        return rc;
                }
        }
 
        /* Reset state to Initialising */
        xenbus_set_state ( xendev, XenbusStateInitialising );
 
        /* Wait for backend to reach InitWait */
        if ( ( rc = xenbus_backend_wait ( xendev, XenbusStateInitWait ) ) != 0){
                DBGC ( netfront, "NETFRONT %s backend did not reach InitWait: "
                       "%s\n", xendev->key, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, xen_device::key, rc, state, strerror(), xenbus_backend_state(), xenbus_backend_wait(), xenbus_set_state(), XenbusStateClosed, XenbusStateInitialising, XenbusStateInitWait, and netfront_nic::xendev.

Referenced by netfront_close(), netfront_open(), and netfront_probe().

netfront_read_mac()

int netfront_read_mac ( struct netfront_nic * netfront, void * hw_addr )

static

Fetch MAC address.

Parameters

netfront	Netfront device
hw_addr	Hardware address to fill in

Return values

rc	Return status code

Definition at line 129 of file netfront.c.

                                                                              {
        struct xen_device *xendev = netfront->xendev;
        struct xen_hypervisor *xen = xendev->xen;
        char *mac;
        int len;
        int rc;
 
        /* Fetch MAC address */
        if ( ( rc = xenstore_read ( xen, &mac, xendev->key, "mac", NULL ) )!=0){
                DBGC ( netfront, "NETFRONT %s could not read MAC address: %s\n",
                       xendev->key, strerror ( rc ) );
                goto err_xenstore_read;
        }
        DBGC2 ( netfront, "NETFRONT %s has MAC address \"%s\"\n",
                xendev->key, mac );
 
        /* Decode MAC address */
        len = hex_decode ( ':', mac, hw_addr, ETH_ALEN );
        if ( len < 0 ) {
                rc = len;
                DBGC ( netfront, "NETFRONT %s could not decode MAC address "
                       "\"%s\": %s\n", xendev->key, mac, strerror ( rc ) );
                goto err_decode;
        }
 
        /* Success */
        rc = 0;
 
 err_decode:
        free ( mac );
 err_xenstore_read:
        return rc;
}

References DBGC, DBGC2, ETH_ALEN, free, hex_decode(), xen_device::key, len, mac, NULL, rc, strerror(), xen_device::xen, netfront_nic::xendev, and xenstore_read().

Referenced by netfront_probe().

netfront_write_num()

int netfront_write_num ( struct netfront_nic * netfront, const char * subkey, unsigned long num )

static

Write XenStore numeric value.

Parameters

netfront	Netfront device
subkey	Subkey
num	Numeric value

Return values

rc	Return status code

Definition at line 171 of file netfront.c.

                                                                        {
        struct xen_device *xendev = netfront->xendev;
        struct xen_hypervisor *xen = xendev->xen;
        int rc;
 
        /* Write value */
        if ( ( rc = xenstore_write_num ( xen, num, xendev->key, subkey,
                                         NULL ) ) != 0 ) {
                DBGC ( netfront, "NETFRONT %s could not set %s=\"%ld\": %s\n",
                       xendev->key, subkey, num, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, xen_device::key, NULL, num, rc, strerror(), xen_device::xen, netfront_nic::xendev, and xenstore_write_num().

Referenced by netfront_create_event(), netfront_create_ring(), and netfront_write_flag().

netfront_write_flag()

int netfront_write_flag ( struct netfront_nic * netfront, const char * subkey )

static

Write XenStore flag value.

Parameters

netfront	Netfront device
subkey	Subkey
num	Numeric value

Return values

rc	Return status code

Definition at line 196 of file netfront.c.

                                                      {
 
        return netfront_write_num ( netfront, subkey, 1 );
}

References netfront_write_num().

Referenced by netfront_open().

netfront_rm()

int netfront_rm ( struct netfront_nic * netfront, const char * subkey )

static

Delete XenStore value.

Parameters

netfront	Netfront device
subkey	Subkey

Return values

rc	Return status code

Definition at line 209 of file netfront.c.

                                                                             {
        struct xen_device *xendev = netfront->xendev;
        struct xen_hypervisor *xen = xendev->xen;
        int rc;
 
        /* Remove value */
        if ( ( rc = xenstore_rm ( xen, xendev->key, subkey, NULL ) ) != 0 ) {
                DBGC ( netfront, "NETFRONT %s could not delete %s: %s\n",
                       xendev->key, subkey, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, xen_device::key, NULL, rc, strerror(), xen_device::xen, netfront_nic::xendev, and xenstore_rm().

Referenced by netfront_close(), netfront_create_event(), netfront_create_ring(), netfront_destroy_event(), netfront_destroy_ring(), and netfront_open().

netfront_create_event()

int netfront_create_event ( struct netfront_nic * netfront )

static

Create event channel.

Parameters

netfront

Netfront device

Return values

rc	Return status code

Definition at line 237 of file netfront.c.

                                                                   {
        struct xen_device *xendev = netfront->xendev;
        struct xen_hypervisor *xen = xendev->xen;
        struct evtchn_alloc_unbound alloc_unbound;
        struct evtchn_close close;
        int xenrc;
        int rc;
 
        /* Allocate event */
        alloc_unbound.dom = DOMID_SELF;
        alloc_unbound.remote_dom = xendev->backend_id;
        if ( ( xenrc = xenevent_alloc_unbound ( xen, &alloc_unbound ) ) != 0 ) {
                rc = -EXEN ( xenrc );
                DBGC ( netfront, "NETFRONT %s could not allocate event: %s\n",
                       xendev->key, strerror ( rc ) );
                goto err_alloc_unbound;
        }
        netfront->event.port = alloc_unbound.port;
 
        /* Publish event channel */
        if ( ( rc = netfront_write_num ( netfront, "event-channel",
                                         netfront->event.port ) ) != 0 )
                goto err_write_num;
 
        DBGC ( netfront, "NETFRONT %s event-channel=\"%d\"\n",
               xendev->key, netfront->event.port );
        return 0;
 
        netfront_rm ( netfront, "event-channel" );
 err_write_num:
        close.port = netfront->event.port;
        xenevent_close ( xen, &close );
 err_alloc_unbound:
        return rc;
}

References alloc_unbound, xen_device::backend_id, close, DBGC, DOMID_SELF, netfront_nic::event, EXEN, xen_device::key, netfront_rm(), netfront_write_num(), evtchn_send::port, rc, strerror(), xen_device::xen, and netfront_nic::xendev.

Referenced by netfront_open().

netfront_send_event()

int netfront_send_event ( struct netfront_nic * netfront )

inlinestatic

Send event.

Parameters

netfront

Netfront device

Return values

rc	Return status code

Definition at line 280 of file netfront.c.

                                                      {
        struct xen_device *xendev = netfront->xendev;
        struct xen_hypervisor *xen = xendev->xen;
        int xenrc;
        int rc;
 
        /* Send event */
        if ( ( xenrc = xenevent_send ( xen, &netfront->event ) ) != 0 ) {
                rc = -EXEN ( xenrc );
                DBGC ( netfront, "NETFRONT %s could not send event: %s\n",
                       xendev->key, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, netfront_nic::event, EXEN, xen_device::key, rc, strerror(), xen_device::xen, and netfront_nic::xendev.

Referenced by netfront_refill_rx(), and netfront_transmit().

netfront_destroy_event()

void netfront_destroy_event ( struct netfront_nic * netfront )

static

Destroy event channel.

Parameters

netfront

Netfront device

Definition at line 302 of file netfront.c.

                                                                     {
        struct xen_device *xendev = netfront->xendev;
        struct xen_hypervisor *xen = xendev->xen;
        struct evtchn_close close;
 
        /* Unpublish event channel */
        netfront_rm ( netfront, "event-channel" );
 
        /* Close event channel */
        close.port = netfront->event.port;
        xenevent_close ( xen, &close );
}

References close, netfront_nic::event, netfront_rm(), evtchn_send::port, xen_device::xen, and netfront_nic::xendev.

Referenced by netfront_close(), and netfront_open().

netfront_create_ring()

int netfront_create_ring ( struct netfront_nic * netfront, struct netfront_ring * ring )

static

Create descriptor ring.

Parameters

netfront	Netfront device
ring	Descriptor ring

Return values

rc	Return status code

Definition at line 329 of file netfront.c.

                                                               {
        struct xen_device *xendev = netfront->xendev;
        struct xen_hypervisor *xen = xendev->xen;
        physaddr_t addr;
        unsigned int i;
        int rc;
 
        /* Initialise buffer ID ring */
        for ( i = 0 ; i < ring->count ; i++ ) {
                ring->ids[i] = i;
                assert ( ring->iobufs[i] == NULL );
        }
        ring->id_prod = 0;
        ring->id_cons = 0;
 
        /* Allocate and initialise shared ring */
        ring->sring.raw = malloc_phys ( PAGE_SIZE, PAGE_SIZE );
        if ( ! ring->sring.raw ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
 
        /* Grant access to shared ring */
        addr = virt_to_phys ( ring->sring.raw );
        if ( ( rc = xengrant_permit_access ( xen, ring->ref, xendev->backend_id,
                                             0, addr ) ) != 0 ) {
                DBGC ( netfront, "NETFRONT %s could not permit access to "
                       "%#08lx: %s\n", xendev->key, addr, strerror ( rc ) );
                goto err_permit_access;
        }
 
        /* Publish shared ring reference */
        if ( ( rc = netfront_write_num ( netfront, ring->ref_key,
                                         ring->ref ) ) != 0 )
                goto err_write_num;
 
        DBGC ( netfront, "NETFRONT %s %s=\"%d\" [%08lx,%08lx)\n", xendev->key,
               ring->ref_key, ring->ref, addr, ( addr + PAGE_SIZE ) );
        return 0;
 
        netfront_rm ( netfront, ring->ref_key );
 err_write_num:
        xengrant_invalidate ( xen, ring->ref );
 err_permit_access:
        free_phys ( ring->sring.raw, PAGE_SIZE );
 err_alloc:
        return rc;
}

References addr, assert, xen_device::backend_id, netfront_ring::count, DBGC, ENOMEM, free_phys(), netfront_ring::id_cons, netfront_ring::id_prod, netfront_ring::ids, netfront_ring::iobufs, xen_device::key, malloc_phys(), netfront_rm(), netfront_write_num(), NULL, PAGE_SIZE, netfront_ring::raw, rc, netfront_ring::ref, netfront_ring::ref_key, netfront_ring::sring, strerror(), xen_device::xen, and netfront_nic::xendev.

Referenced by netfront_open().

netfront_push()

int netfront_push ( struct netfront_nic * netfront, struct netfront_ring * ring, physaddr_t addr, struct io_buffer * iobuf, uint16_t * id, grant_ref_t * ref )

static

Add buffer to descriptor ring.

Parameters

netfront	Netfront device
ring	Descriptor ring
addr	Physical address
iobuf	Associated I/O buffer, or NULL
id	Buffer ID to fill in
ref	Grant reference to fill in

Return values

rc	Return status code

The caller is responsible for ensuring that there is space in the ring.

Definition at line 393 of file netfront.c.

                                              {
        struct xen_device *xendev = netfront->xendev;
        struct xen_hypervisor *xen = xendev->xen;
        unsigned int next_id;
        unsigned int next_ref;
        int rc;
 
        /* Sanity check */
        assert ( ! netfront_ring_is_full ( ring ) );
 
        /* Allocate buffer ID */
        next_id = ring->ids[ ring->id_prod & ( ring->count - 1 ) ];
        next_ref = ring->refs[next_id];
 
        /* Grant access to page containing address */
        if ( ( rc = xengrant_permit_access ( xen, next_ref, xendev->backend_id,
                                             0, addr ) ) != 0 ) {
                DBGC ( netfront, "NETFRONT %s could not permit access to "
                       "%#08lx: %s\n", xendev->key, addr, strerror ( rc ) );
                return rc;
        }
 
        /* Store associated I/O buffer, if any */
        assert ( ring->iobufs[next_id] == NULL );
        ring->iobufs[next_id] = iobuf;
 
        /* Consume buffer ID */
        ring->id_prod++;
 
        /* Return buffer ID and grant reference */
        *id = next_id;
        *ref = next_ref;
 
        return 0;
}

References addr, assert, xen_device::backend_id, netfront_ring::count, DBGC, netfront_ring::id_prod, netfront_ring::ids, netfront_ring::iobufs, xen_device::key, NULL, rc, ref, netfront_ring::refs, strerror(), xen_device::xen, and netfront_nic::xendev.

Referenced by netfront_refill_rx(), and netfront_transmit().

netfront_pull()

struct io_buffer * netfront_pull ( struct netfront_nic * netfront, struct netfront_ring * ring, unsigned int id )

static

Remove buffer from descriptor ring.

Parameters

netfront	Netfront device
ring	Descriptor ring
id	Buffer ID

Return values

iobuf

Associated I/O buffer, if any

Definition at line 440 of file netfront.c.

                                                            {
        struct xen_device *xendev = netfront->xendev;
        struct xen_hypervisor *xen = xendev->xen;
        struct io_buffer *iobuf;
 
        /* Sanity check */
        assert ( id < ring->count );
 
        /* Revoke access from I/O buffer page */
        xengrant_invalidate ( xen, ring->refs[id] );
 
        /* Retrieve I/O buffer */
        iobuf = ring->iobufs[id];
        ring->iobufs[id] = NULL;
 
        /* Free buffer ID */
        ring->ids[ ( ring->id_cons++ ) & ( ring->count - 1 ) ] = id;
 
        return iobuf;
}

References assert, count, netfront_ring::count, id, netfront_ring::id_cons, netfront_ring::ids, netfront_ring::iobufs, NULL, netfront_ring::refs, xen_device::xen, and netfront_nic::xendev.

Referenced by netfront_destroy_ring(), netfront_poll_rx(), and netfront_poll_tx().

netfront_destroy_ring()

void netfront_destroy_ring ( struct netfront_nic * netfront, struct netfront_ring * ring, void(* discard )(struct io_buffer *) )

static

Destroy descriptor ring.

Parameters

netfront	Netfront device
ring	Descriptor ring
discard	Method used to discard outstanding buffer, or NULL

Definition at line 470 of file netfront.c.

                                                                               {
        struct xen_device *xendev = netfront->xendev;
        struct xen_hypervisor *xen = xendev->xen;
        struct io_buffer *iobuf;
        unsigned int id;
 
        /* Flush any outstanding buffers */
        while ( ! netfront_ring_is_empty ( ring ) ) {
                id = ring->ids[ ring->id_cons & ( ring->count - 1 ) ];
                iobuf = netfront_pull ( netfront, ring, id );
                if ( discard )
                        discard ( iobuf );
        }
 
        /* Unpublish shared ring reference */
        netfront_rm ( netfront, ring->ref_key );
 
        /* Revoke access from shared ring */
        xengrant_invalidate ( xen, ring->ref );
 
        /* Free page */
        free_phys ( ring->sring.raw, PAGE_SIZE );
        ring->sring.raw = NULL;
}

References netfront_ring::count, free_phys(), id, netfront_ring::id_cons, netfront_ring::ids, netfront_pull(), netfront_rm(), NULL, PAGE_SIZE, netfront_ring::raw, netfront_ring::ref, netfront_ring::ref_key, netfront_ring::sring, xen_device::xen, and netfront_nic::xendev.

Referenced by netfront_close(), and netfront_open().

netfront_discard()

void netfront_discard ( struct netfront_nic * netfront )

static

Discard partially received I/O buffers.

Parameters

netfront

Netfront device

Definition at line 502 of file netfront.c.

                                                               {
        struct io_buffer *iobuf;
        struct io_buffer *tmp;
 
        /* Discard all buffers in the list */
        list_for_each_entry_safe ( iobuf, tmp, &netfront->rx_partial, list ) {
                list_del ( &iobuf->list );
                free_iob ( iobuf );
        }
}

References free_iob(), io_buffer::list, list_del, list_for_each_entry_safe, netfront_nic::rx_partial, and tmp.

Referenced by netfront_close(), and netfront_poll_rx().

netfront_refill_rx()

void netfront_refill_rx ( struct net_device * netdev )

static

Refill receive descriptor ring.

Parameters

netdev

Network device

Definition at line 525 of file netfront.c.

                                                             {
        struct netfront_nic *netfront = netdev->priv;
        struct xen_device *xendev = netfront->xendev;
        struct io_buffer *iobuf;
        struct netif_rx_request *request;
        unsigned int refilled = 0;
        physaddr_t addr;
        int notify;
        int rc;
 
        /* Refill ring */
        while ( netfront_ring_fill ( &netfront->rx ) < NETFRONT_RX_FILL ) {
 
                /* Allocate I/O buffer */
                iobuf = alloc_iob ( PAGE_SIZE );
                if ( ! iobuf ) {
                        /* Wait for next refill */
                        break;
                }
                addr = virt_to_phys ( iobuf->data );
 
                /* Add to descriptor ring */
                request = RING_GET_REQUEST ( &netfront->rx_fring,
                                             netfront->rx_fring.req_prod_pvt );
                if ( ( rc = netfront_push ( netfront, &netfront->rx, addr,
                                            iobuf, &request->id,
                                            &request->gref ) ) != 0 ) {
                        netdev_rx_err ( netdev, iobuf, rc );
                        break;
                }
                DBGC2 ( netfront, "NETFRONT %s RX id %d ref %d is %#08lx+%zx\n",
                        xendev->key, request->id, request->gref, addr,
                        iob_tailroom ( iobuf ) );
 
                /* Move to next descriptor */
                netfront->rx_fring.req_prod_pvt++;
                refilled++;
        }
 
        /* Push new descriptors and notify backend if applicable */
        if ( refilled ) {
                RING_PUSH_REQUESTS_AND_CHECK_NOTIFY ( &netfront->rx_fring,
                                                      notify );
                if ( notify )
                        netfront_send_event ( netfront );
        }
}

References addr, alloc_iob(), io_buffer::data, DBGC2, iob_tailroom(), xen_device::key, netdev, netdev_rx_err(), netfront_push(), NETFRONT_RX_FILL, netfront_send_event(), PAGE_SIZE, rc, request, RING_GET_REQUEST, RING_PUSH_REQUESTS_AND_CHECK_NOTIFY, netfront_nic::rx, netfront_nic::rx_fring, and netfront_nic::xendev.

Referenced by netfront_open(), and netfront_poll().

netfront_open()

int netfront_open ( struct net_device * netdev )

static

Open network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 579 of file netfront.c.

                                                       {
        struct netfront_nic *netfront = netdev->priv;
        struct xen_device *xendev = netfront->xendev;
        int rc;
 
        /* Ensure device is in a suitable initial state */
        if ( ( rc = netfront_reset ( netfront ) ) != 0 )
                goto err_reset;
 
        /* Create transmit descriptor ring */
        if ( ( rc = netfront_create_ring ( netfront, &netfront->tx ) ) != 0 )
                goto err_create_tx;
        SHARED_RING_INIT ( netfront->tx_sring );
        FRONT_RING_INIT ( &netfront->tx_fring, netfront->tx_sring, PAGE_SIZE );
        assert ( RING_SIZE ( &netfront->tx_fring ) >= netfront->tx.count );
 
        /* Create receive descriptor ring */
        if ( ( rc = netfront_create_ring ( netfront, &netfront->rx ) ) != 0 )
                goto err_create_rx;
        SHARED_RING_INIT ( netfront->rx_sring );
        FRONT_RING_INIT ( &netfront->rx_fring, netfront->rx_sring, PAGE_SIZE );
        assert ( RING_SIZE ( &netfront->rx_fring ) >= netfront->rx.count );
 
        /* Create event channel */
        if ( ( rc = netfront_create_event ( netfront ) ) != 0 )
                goto err_create_event;
 
        /* "Request" the rx-copy feature.  Current versions of
         * xen_netback.ko will fail silently if this parameter is not
         * present.
         */
        if ( ( rc = netfront_write_flag ( netfront, "request-rx-copy" ) ) != 0 )
                goto err_request_rx_copy;
 
        /* Inform backend that we can support scatter-gather */
        if ( ( rc = netfront_write_flag ( netfront, "feature-sg" ) ) != 0 )
                goto err_feature_sg;
 
        /* Disable checksum offload, since we will always do the work anyway */
        if ( ( rc = netfront_write_flag ( netfront,
                                          "feature-no-csum-offload" ) ) != 0 )
                goto err_feature_no_csum_offload;
 
        /* Inform backend that we will send notifications for RX requests */
        if ( ( rc = netfront_write_flag ( netfront,
                                          "feature-rx-notify" ) ) != 0 )
                goto err_feature_rx_notify;
 
        /* Set state to Connected */
        if ( ( rc = xenbus_set_state ( xendev, XenbusStateConnected ) ) != 0 ) {
                DBGC ( netfront, "NETFRONT %s could not set state=\"%d\": %s\n",
                       xendev->key, XenbusStateConnected, strerror ( rc ) );
                goto err_set_state;
        }
 
        /* Wait for backend to connect */
        if ( ( rc = xenbus_backend_wait ( xendev, XenbusStateConnected ) ) !=0){
                DBGC ( netfront, "NETFRONT %s could not connect to backend: "
                       "%s\n", xendev->key, strerror ( rc ) );
                goto err_backend_wait;
        }
 
        /* Refill receive descriptor ring */
        netfront_refill_rx ( netdev );
 
        /* Set link up */
        netdev_link_up ( netdev );
 
        return 0;
 
 err_backend_wait:
        netfront_reset ( netfront );
 err_set_state:
        netfront_rm ( netfront, "feature-rx-notify" );
 err_feature_rx_notify:
        netfront_rm ( netfront, "feature-no-csum-offload" );
 err_feature_no_csum_offload:
        netfront_rm ( netfront, "feature-sg" );
 err_feature_sg:
        netfront_rm ( netfront, "request-rx-copy" );
 err_request_rx_copy:
        netfront_destroy_event ( netfront );
 err_create_event:
        netfront_destroy_ring ( netfront, &netfront->rx, NULL );
 err_create_rx:
        netfront_destroy_ring ( netfront, &netfront->tx, NULL );
 err_create_tx:
 err_reset:
        return rc;
}

References assert, netfront_ring::count, DBGC, FRONT_RING_INIT, xen_device::key, netdev, netdev_link_up(), netfront_create_event(), netfront_create_ring(), netfront_destroy_event(), netfront_destroy_ring(), netfront_refill_rx(), netfront_reset(), netfront_rm(), netfront_write_flag(), NULL, PAGE_SIZE, rc, RING_SIZE, netfront_nic::rx, netfront_nic::rx_fring, SHARED_RING_INIT, strerror(), netfront_nic::tx, netfront_nic::tx_fring, xenbus_backend_wait(), xenbus_set_state(), XenbusStateConnected, and netfront_nic::xendev.

netfront_close()

void netfront_close ( struct net_device * netdev )

static

Close network device.

Parameters

netdev

Network device

Definition at line 675 of file netfront.c.

                                                         {
        struct netfront_nic *netfront = netdev->priv;
        struct xen_device *xendev = netfront->xendev;
        int rc;
 
        /* Reset devic, thereby ensuring that grant references are no
         * longer in use, etc.
         */
        if ( ( rc = netfront_reset ( netfront ) ) != 0 ) {
                DBGC ( netfront, "NETFRONT %s could not disconnect from "
                       "backend: %s\n", xendev->key, strerror ( rc ) );
                /* Things will probably go _very_ badly wrong if this
                 * happens, since it means the backend may still write
                 * to the outstanding RX buffers that we are about to
                 * free.  The best we can do is report the error via
                 * the link status, but there's a good chance the
                 * machine will crash soon.
                 */
                netdev_link_err ( netdev, rc );
        } else {
                netdev_link_down ( netdev );
        }
 
        /* Delete flags */
        netfront_rm ( netfront, "feature-rx-notify" );
        netfront_rm ( netfront, "feature-no-csum-offload" );
        netfront_rm ( netfront, "feature-sg" );
        netfront_rm ( netfront, "request-rx-copy" );
 
        /* Destroy event channel */
        netfront_destroy_event ( netfront );
 
        /* Discard any partially received I/O buffers */
        netfront_discard ( netfront );
 
        /* Destroy receive descriptor ring, freeing any outstanding
         * I/O buffers.
         */
        netfront_destroy_ring ( netfront, &netfront->rx, free_iob );
 
        /* Destroy transmit descriptor ring.  Leave any outstanding
         * I/O buffers to be freed by netdev_tx_flush().
         */
        netfront_destroy_ring ( netfront, &netfront->tx, NULL );
}

References DBGC, free_iob(), xen_device::key, netdev, netdev_link_down(), netdev_link_err(), netfront_destroy_event(), netfront_destroy_ring(), netfront_discard(), netfront_reset(), netfront_rm(), NULL, rc, netfront_nic::rx, strerror(), netfront_nic::tx, and netfront_nic::xendev.

netfront_transmit()

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

static

Transmit packet.

Parameters

netdev	Network device
iobuf	I/O buffer

Return values

rc	Return status code

Definition at line 728 of file netfront.c.

                                                         {
        struct netfront_nic *netfront = netdev->priv;
        struct xen_device *xendev = netfront->xendev;
        struct netif_tx_request *request;
        physaddr_t addr;
        size_t len;
        size_t remaining;
        size_t frag_len;
        unsigned int offset;
        unsigned int count;
        unsigned int more;
        int notify;
        int rc;
 
        /* Calculate number of page buffers required */
        addr = virt_to_phys ( iobuf->data );
        len = iob_len ( iobuf );
        offset = ( addr & ( PAGE_SIZE - 1 ) );
        count = ( ( offset + len + PAGE_SIZE - 1 ) / PAGE_SIZE );
 
        /* Check that we have space in the ring */
        if ( netfront_ring_space ( &netfront->tx ) < count ) {
                DBGC ( netfront, "NETFRONT %s out of transmit descriptors\n",
                       xendev->key );
                return -ENOBUFS;
        }
 
        /* Add to descriptor ring */
        remaining = len;
        while ( remaining ) {
 
                /* Calculate length of this fragment */
                frag_len = ( PAGE_SIZE - offset );
                if ( frag_len >= remaining ) {
                        frag_len = remaining;
                        more = 0;
                } else {
                        more = NETTXF_more_data;
                }
 
                /* Populate request */
                request = RING_GET_REQUEST ( &netfront->tx_fring,
                                             netfront->tx_fring.req_prod_pvt );
                if ( ( rc = netfront_push ( netfront, &netfront->tx, addr,
                                            ( more ? NULL : iobuf ),
                                            &request->id,
                                            &request->gref ) ) != 0 ) {
                        return rc;
                }
                request->flags = ( NETTXF_data_validated | more );
                request->offset = offset;
                request->size = ( ( remaining == len ) ? len : frag_len );
                DBGC2 ( netfront, "NETFRONT %s TX id %d ref %d is "
                        "%#08lx+%zx%s\n", xendev->key, request->id,
                        request->gref, addr, frag_len, ( more ? "..." : "" ) );
 
                /* Move to next descriptor */
                netfront->tx_fring.req_prod_pvt++;
                addr += frag_len;
                remaining -= frag_len;
                offset = 0;
        }
 
        /* Push new descriptors and notify backend if applicable */
        RING_PUSH_REQUESTS_AND_CHECK_NOTIFY ( &netfront->tx_fring, notify );
        if ( notify )
                netfront_send_event ( netfront );
 
        return 0;
}

References addr, count, io_buffer::data, DBGC, DBGC2, ENOBUFS, iob_len(), xen_device::key, len, netdev, netfront_push(), netfront_send_event(), NETTXF_data_validated, NETTXF_more_data, NULL, offset, PAGE_SIZE, rc, request, RING_GET_REQUEST, RING_PUSH_REQUESTS_AND_CHECK_NOTIFY, netfront_nic::tx, netfront_nic::tx_fring, and netfront_nic::xendev.

netfront_poll_tx()

void netfront_poll_tx ( struct net_device * netdev )

static

Poll for completed packets.

Parameters

netdev

Network device

Definition at line 805 of file netfront.c.

                                                           {
        struct netfront_nic *netfront = netdev->priv;
        struct xen_device *xendev = netfront->xendev;
        struct netif_tx_response *response;
        struct io_buffer *iobuf;
        int status;
        int rc;
 
        /* Consume any unconsumed responses */
        while ( RING_HAS_UNCONSUMED_RESPONSES ( &netfront->tx_fring ) ) {
 
                /* Get next response */
                response = RING_GET_RESPONSE ( &netfront->tx_fring,
                                               netfront->tx_fring.rsp_cons++ );
 
                /* Retrieve from descriptor ring */
                iobuf = netfront_pull ( netfront, &netfront->tx, response->id );
                status = response->status;
                if ( status >= NETIF_RSP_OKAY ) {
                        DBGC2 ( netfront, "NETFRONT %s TX id %d complete\n",
                                xendev->key, response->id );
                        if ( iobuf )
                                netdev_tx_complete ( netdev, iobuf );
                } else {
                        rc = -EIO_NETIF_RSP ( status );
                        DBGC2 ( netfront, "NETFRONT %s TX id %d error %d: %s\n",
                                xendev->key, response->id, status,
                                strerror ( rc ) );
                        netdev_tx_complete_err ( netdev, iobuf, rc );
                }
        }
}

References DBGC2, EIO_NETIF_RSP, netif_tx_response::id, xen_device::key, netdev, netdev_tx_complete(), netdev_tx_complete_err(), netfront_pull(), NETIF_RSP_OKAY, rc, RING_GET_RESPONSE, RING_HAS_UNCONSUMED_RESPONSES, netif_tx_response::status, status, strerror(), netfront_nic::tx, netfront_nic::tx_fring, and netfront_nic::xendev.

Referenced by netfront_poll().

netfront_poll_rx()

void netfront_poll_rx ( struct net_device * netdev )

static

Poll for received packets.

Parameters

netdev

Network device

Definition at line 843 of file netfront.c.

                                                           {
        struct netfront_nic *netfront = netdev->priv;
        struct xen_device *xendev = netfront->xendev;
        struct netif_rx_response *response;
        struct io_buffer *iobuf;
        int status;
        int more;
        size_t len;
        int rc;
 
        /* Consume any unconsumed responses */
        while ( RING_HAS_UNCONSUMED_RESPONSES ( &netfront->rx_fring ) ) {
 
                /* Get next response */
                response = RING_GET_RESPONSE ( &netfront->rx_fring,
                                               netfront->rx_fring.rsp_cons++ );
 
                /* Retrieve from descriptor ring */
                iobuf = netfront_pull ( netfront, &netfront->rx, response->id );
                status = response->status;
                more = ( response->flags & NETRXF_more_data );
 
                /* Report errors */
                if ( status < 0 ) {
                        rc = -EIO_NETIF_RSP ( status );
                        DBGC2 ( netfront, "NETFRONT %s RX id %d error %d: %s\n",
                                xendev->key, response->id, status,
                                strerror ( rc ) );
                        netfront_discard ( netfront );
                        netdev_rx_err ( netdev, iobuf, rc );
                        continue;
                }
 
                /* Add to partial receive list */
                len = status;
                iob_reserve ( iobuf, response->offset );
                iob_put ( iobuf, len );
                DBGC2 ( netfront, "NETFRONT %s RX id %d complete "
                        "%#08lx+%zx%s\n", xendev->key, response->id,
                        virt_to_phys ( iobuf->data ), len,
                        ( more ? "..." : "" ) );
                list_add_tail ( &iobuf->list, &netfront->rx_partial );
 
                /* Wait until complete packet has been received */
                if ( more )
                        continue;
 
                /* Reassemble complete packet */
                iobuf = iob_concatenate ( &netfront->rx_partial );
                if ( ! iobuf ) {
                        DBGC2 ( netfront, "NETFRONT %s RX reassembly failed\n",
                                xendev->key );
                        netfront_discard ( netfront );
                        netdev_rx_err ( netdev, NULL, -ENOMEM );
                        continue;
                }
 
                /* Hand off to network stack */
                netdev_rx ( netdev, iobuf );
        }
}

References io_buffer::data, DBGC2, EIO_NETIF_RSP, ENOMEM, netif_rx_response::flags, netif_rx_response::id, iob_concatenate(), iob_put, iob_reserve, xen_device::key, len, io_buffer::list, list_add_tail, netdev, netdev_rx(), netdev_rx_err(), netfront_discard(), netfront_pull(), NETRXF_more_data, NULL, netif_rx_response::offset, rc, RING_GET_RESPONSE, RING_HAS_UNCONSUMED_RESPONSES, netfront_nic::rx, netfront_nic::rx_fring, netfront_nic::rx_partial, netif_rx_response::status, status, strerror(), and netfront_nic::xendev.

Referenced by netfront_poll().

netfront_poll()

void netfront_poll ( struct net_device * netdev )

static

Poll for completed and received packets.

Parameters

netdev

Network device

Definition at line 910 of file netfront.c.

                                                        {
 
        /* Poll for TX completions */
        netfront_poll_tx ( netdev );
 
        /* Poll for RX completions */
        netfront_poll_rx ( netdev );
 
        /* Refill RX descriptor ring */
        netfront_refill_rx ( netdev );
}

References netdev, netfront_poll_rx(), netfront_poll_tx(), and netfront_refill_rx().

netfront_probe()

int netfront_probe ( struct xen_device * xendev )

static

Probe Xen device.

Parameters

xendev

Xen device

Return values

rc	Return status code

Definition at line 943 of file netfront.c.

                                                        {
        struct xen_hypervisor *xen = xendev->xen;
        struct net_device *netdev;
        struct netfront_nic *netfront;
        int rc;
 
        /* Allocate and initialise structure */
        netdev = alloc_etherdev ( sizeof ( *netfront ) );
        if ( ! netdev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        netdev_init ( netdev, &netfront_operations );
        netdev->dev = &xendev->dev;
        netfront = netdev->priv;
        netfront->xendev = xendev;
        netfront->netdev = netdev;
        INIT_LIST_HEAD ( &netfront->rx_partial );
        DBGC ( netfront, "NETFRONT %s backend=\"%s\" in domain %ld\n",
               xendev->key, xendev->backend, xendev->backend_id );
 
        /* Allocate grant references and initialise descriptor rings */
        if ( ( rc = xengrant_alloc ( xen, netfront->refs,
                                     NETFRONT_REF_COUNT ) ) != 0 ) {
                DBGC ( netfront, "NETFRONT %s could not allocate grant "
                       "references: %s\n", xendev->key, strerror ( rc ) );
                goto err_grant_alloc;
        }
        netfront_init_ring ( &netfront->tx, "tx-ring-ref",
                             netfront->refs[NETFRONT_REF_TX_RING],
                             NETFRONT_NUM_TX_DESC, netfront->tx_iobufs,
                             &netfront->refs[NETFRONT_REF_TX_BASE],
                             netfront->tx_ids );
        netfront_init_ring ( &netfront->rx, "rx-ring-ref",
                             netfront->refs[NETFRONT_REF_RX_RING],
                             NETFRONT_NUM_RX_DESC, netfront->rx_iobufs,
                             &netfront->refs[NETFRONT_REF_RX_BASE],
                             netfront->rx_ids );
 
        /* Fetch MAC address */
        if ( ( rc = netfront_read_mac ( netfront, netdev->hw_addr ) ) != 0 )
                goto err_read_mac;
 
        /* Reset device.  Ignore failures; allow the device to be
         * registered so that reset errors can be observed by the user
         * when attempting to open the device.
         */
        netfront_reset ( netfront );
 
        /* Register network device */
        if ( ( rc = register_netdev ( netdev ) ) != 0 )
                goto err_register_netdev;
 
        /* Set initial link state */
        netdev_link_down ( netdev );
 
        /* Add to list of netfront devices */
        list_add_tail ( &netfront->list, &netfront_devices );
 
        xen_set_drvdata ( xendev, netdev );
        return 0;
 
        list_del ( &netfront->list );
        unregister_netdev ( netdev );
 err_register_netdev:
 err_read_mac:
        xengrant_free ( xen, netfront->refs, NETFRONT_REF_COUNT );
 err_grant_alloc:
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 err_alloc:
        return rc;
}

References alloc_etherdev(), xen_device::backend, xen_device::backend_id, DBGC, xen_device::dev, ENOMEM, INIT_LIST_HEAD, xen_device::key, netfront_nic::list, list_add_tail, list_del, netdev, netfront_nic::netdev, netdev_init(), netdev_link_down(), netdev_nullify(), netdev_put(), NETFRONT_NUM_RX_DESC, NETFRONT_NUM_TX_DESC, netfront_operations, netfront_read_mac(), NETFRONT_REF_COUNT, NETFRONT_REF_RX_BASE, NETFRONT_REF_RX_RING, NETFRONT_REF_TX_BASE, NETFRONT_REF_TX_RING, netfront_reset(), rc, netfront_nic::refs, register_netdev(), netfront_nic::rx, netfront_nic::rx_ids, netfront_nic::rx_iobufs, netfront_nic::rx_partial, strerror(), netfront_nic::tx, netfront_nic::tx_ids, netfront_nic::tx_iobufs, unregister_netdev(), xen_device::xen, xen_set_drvdata(), netfront_nic::xendev, xengrant_alloc(), and xengrant_free().

netfront_remove()

void netfront_remove ( struct xen_device * xendev )

static

Remove Xen device.

Parameters

xendev

Xen device

Definition at line 1022 of file netfront.c.

                                                          {
        struct net_device *netdev = xen_get_drvdata ( xendev );
        struct netfront_nic *netfront = netdev->priv;
        struct xen_hypervisor *xen = xendev->xen;
 
        /* Remove from list of netfront devices */
        list_del ( &netfront->list );
 
        /* Unregister network device */
        unregister_netdev ( netdev );
 
        /* Free resources */
        xengrant_free ( xen, netfront->refs, NETFRONT_REF_COUNT );
 
        /* Free network device */
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}

References netfront_nic::list, list_del, netdev, netdev_nullify(), netdev_put(), NETFRONT_REF_COUNT, netfront_nic::refs, unregister_netdev(), xen_device::xen, xen_get_drvdata(), and xengrant_free().

XEN_ROM()

XEN_ROM	(	"netfront"	,
		"Xen netfront virtual NIC"	)

netfront_net_probe()

int netfront_net_probe ( struct net_device * netdev, void *priv __unused )

static

Inhibit emulated PCI devices.

Parameters

netdev	Network device
priv	Private data

Return values

rc	Return status code

Definition at line 1066 of file netfront.c.

                                                      {
        struct netfront_nic *netfront;
 
        /* Inhibit emulated PCI devices matching an existing netfront device */
        list_for_each_entry ( netfront, &netfront_devices, list ) {
                if ( ( netdev->dev != netfront->netdev->dev ) &&
                     ( netdev->ll_protocol->ll_addr_len == ETH_ALEN ) &&
                     ( memcmp ( netdev->hw_addr, netfront->netdev->hw_addr,
                                ETH_ALEN ) == 0 ) ) {
                        DBGC ( netfront, "NETFRONT %s inhibiting emulated %s "
                               "%s\n", netfront->xendev->key,
                               netdev->dev->driver_name, netdev->dev->name );
                        return -EEXIST;
                }
        }
 
        return 0;
}

References __unused, DBGC, net_device::dev, EEXIST, ETH_ALEN, net_device::hw_addr, xen_device::key, netfront_nic::list, list_for_each_entry, memcmp(), netdev, netfront_nic::netdev, priv, and netfront_nic::xendev.

Variable Documentation

netfront_operations

struct net_device_operations netfront_operations

static

Initial value:

= {
        .open           = netfront_open,
        .close          = netfront_close,
        .transmit       = netfront_transmit,
        .poll           = netfront_poll,
}

Network device operations.

Definition at line 923 of file netfront.c.

                                                          {
        .open           = netfront_open,
        .close          = netfront_close,
        .transmit       = netfront_transmit,
        .poll           = netfront_poll,
};

Referenced by netfront_probe().

__xen_driver

struct xen_driver netfront_driver __xen_driver

Initial value:

= {
        .name = "netfront",
        .type = "vif",
        .probe = netfront_probe,
        .remove = netfront_remove,
}

Xen netfront driver.

Definition at line 1042 of file netfront.c.

                                                 {
        .name = "netfront",
        .type = "vif",
        .probe = netfront_probe,
        .remove = netfront_remove,
};

__net_driver

struct net_driver netfront_net_driver __net_driver

Initial value:

= {
        .name = "netfront",
        .probe = netfront_net_probe,
}

Emulated PCI device inhibitor driver.

Definition at line 1087 of file netfront.c.

                                                     {
        .name = "netfront",
        .probe = netfront_net_probe,
};