neighbour.c File Reference

Neighbour discovery. More...

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ipxe/iobuf.h>
#include <ipxe/retry.h>
#include <ipxe/timer.h>
#include <ipxe/malloc.h>
#include <ipxe/pending.h>
#include <ipxe/neighbour.h>
#include <config/fault.h>

Go to the source code of this file.

Macros
#define	NEIGHBOUR_MIN_TIMEOUT   ( TICKS_PER_SEC / 8 )
	Neighbour discovery minimum timeout.
#define	NEIGHBOUR_MAX_TIMEOUT   ( TICKS_PER_SEC * 3 )
	Neighbour discovery maximum timeout.
#define	NEIGHBOUR_DELAY_MAX_BURST   2
	Neighbour discovery maximum burst count for delayed transmissions.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static void	neighbour_expired (struct retry_timer *timer, int fail)
	Handle neighbour timer expiry.
static void	neighbour_free (struct refcnt *refcnt)
	Free neighbour cache entry.
static struct neighbour *	neighbour_create (struct net_device *netdev, struct net_protocol *net_protocol, const void *net_dest)
	Create neighbour cache entry.
static struct neighbour *	neighbour_find (struct net_device *netdev, struct net_protocol *net_protocol, const void *net_dest)
	Find neighbour cache entry.
static void	neighbour_discover (struct neighbour *neighbour, struct neighbour_discovery *discovery, const void *net_source)
	Start neighbour discovery.
static void	neighbour_tx_queue (struct neighbour *neighbour)
	Transmit deferred packets.
static void	neighbour_discovered (struct neighbour *neighbour, const void *ll_dest)
	Complete neighbour discovery.
static void	neighbour_destroy (struct neighbour *neighbour, int rc)
	Destroy neighbour cache entry.
int	neighbour_tx (struct io_buffer *iobuf, struct net_device *netdev, struct net_protocol *net_protocol, const void *net_dest, struct neighbour_discovery *discovery, const void *net_source)
	Transmit packet, determining link-layer address via neighbour discovery.
int	neighbour_update (struct net_device *netdev, struct net_protocol *net_protocol, const void *net_dest, const void *ll_dest)
	Update existing neighbour cache entry.
int	neighbour_define (struct net_device *netdev, struct net_protocol *net_protocol, const void *net_dest, const void *ll_dest)
	Define neighbour cache entry.
static void	neighbour_flush (struct net_device *netdev, void *priv __unused)
	Update neighbour cache on network device state change or removal.
static unsigned int	neighbour_discard (void)
	Discard some cached neighbour entries.
struct cache_discarder neighbour_discarder	__cache_discarder (CACHE_EXPENSIVE)
	Neighbour cache discarder.

Variables
struct list_head	neighbours = LIST_HEAD_INIT ( neighbours )
	The neighbour cache.
static struct pending_operation	neighbour_delayed
	Pending operation for delayed transmissions.
struct net_driver neighbour_net_driver	__net_driver
	Neighbour driver (for net device notifications)

Detailed Description

Neighbour discovery.

This file implements the abstract functions of neighbour discovery, independent of the underlying network protocol (e.g. ARP or NDP).

Definition in file neighbour.c.

Macro Definition Documentation

NEIGHBOUR_MIN_TIMEOUT

#define NEIGHBOUR_MIN_TIMEOUT   ( TICKS_PER_SEC / 8 )

Neighbour discovery minimum timeout.

Definition at line 49 of file neighbour.c.

Referenced by neighbour_create().

NEIGHBOUR_MAX_TIMEOUT

#define NEIGHBOUR_MAX_TIMEOUT   ( TICKS_PER_SEC * 3 )

Neighbour discovery maximum timeout.

Definition at line 52 of file neighbour.c.

Referenced by neighbour_create().

NEIGHBOUR_DELAY_MAX_BURST

#define NEIGHBOUR_DELAY_MAX_BURST   2

Neighbour discovery maximum burst count for delayed transmissions.

When using delay injection, timer quantisation can cause a large number of delayed packets to be scheduled at the same time. This can quickly exhaust available transmit descriptors, leading to packets that are dropped completely (not just delayed).

Limit the number of delayed packets that we will attempt to transmit at once, to allow time for transmit completions to occur.

Definition at line 64 of file neighbour.c.

Referenced by neighbour_tx_queue().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

neighbour_expired()

void neighbour_expired ( struct retry_timer * timer, int fail )

static

Handle neighbour timer expiry.

Parameters

timer	Retry timer
fail	Failure indicator

Definition at line 326 of file neighbour.c.

                                                                      {
        struct neighbour *neighbour =
                container_of ( timer, struct neighbour, timer );
        struct net_device *netdev = neighbour->netdev;
        struct net_protocol *net_protocol = neighbour->net_protocol;
        struct neighbour_discovery *discovery =
                neighbour->discovery;
        const void *net_dest = neighbour->net_dest;
        const void *net_source = neighbour->net_source;
        int rc;
 
        /* If the timer is being (ab)used for delay injection, then
         * transmit the deferred packet queue.
         */
        if ( NEIGHBOUR_DELAY_MS && ( ! neighbour->discovery ) ) {
                neighbour_tx_queue ( neighbour );
                return;
        }
 
        /* If we have failed, destroy the cache entry */
        if ( fail ) {
                neighbour_destroy ( neighbour, -ETIMEDOUT );
                return;
        }
 
        /* Restart the timer */
        start_timer ( &neighbour->timer );
 
        /* Transmit neighbour request */
        if ( ( rc = discovery->tx_request ( netdev, net_protocol, net_dest,
                                            net_source ) ) != 0 ) {
                DBGC ( neighbour, "NEIGHBOUR %s %s %s could not transmit %s "
                       "request: %s\n", netdev->name, net_protocol->name,
                       net_protocol->ntoa ( neighbour->net_dest ),
                       neighbour->discovery->name, strerror ( rc ) );
                /* Retransmit when timer expires */
                return;
        }
}

References container_of, DBGC, neighbour::discovery, ETIMEDOUT, neighbour_discovery::name, net_protocol::name, NEIGHBOUR_DELAY_MS, neighbour_destroy(), neighbour_tx_queue(), neighbour::net_dest, neighbour::net_protocol, neighbour::net_source, neighbour::netdev, netdev, net_protocol::ntoa, rc, start_timer(), strerror(), neighbour::timer, and neighbour_discovery::tx_request.

Referenced by neighbour_create().

neighbour_free()

void neighbour_free ( struct refcnt * refcnt )

static

Free neighbour cache entry.

Parameters

refcnt

Reference count

Definition at line 79 of file neighbour.c.

                                                     {
        struct neighbour *neighbour =
                container_of ( refcnt, struct neighbour, refcnt );
 
        /* Sanity check */
        assert ( list_empty ( &neighbour->tx_queue ) );
 
        /* Drop reference to network device */
        netdev_put ( neighbour->netdev );
 
        /* Free neighbour */
        free ( neighbour );
}

References assert, container_of, free, list_empty, neighbour::netdev, netdev_put(), and neighbour::tx_queue.

Referenced by neighbour_create().

neighbour_create()

struct neighbour * neighbour_create ( struct net_device * netdev, struct net_protocol * net_protocol, const void * net_dest )

static

Create neighbour cache entry.

Parameters

netdev	Network device
net_protocol	Network-layer protocol
net_dest	Destination network-layer address

Return values

neighbour

Neighbour cache entry, or NULL if allocation failed

Definition at line 101 of file neighbour.c.

                                                                    {
        struct neighbour *neighbour;
 
        /* Allocate and initialise entry */
        neighbour = zalloc ( sizeof ( *neighbour ) );
        if ( ! neighbour )
                return NULL;
        ref_init ( &neighbour->refcnt, neighbour_free );
        neighbour->netdev = netdev_get ( netdev );
        neighbour->net_protocol = net_protocol;
        memcpy ( neighbour->net_dest, net_dest,
                 net_protocol->net_addr_len );
        timer_init ( &neighbour->timer, neighbour_expired, &neighbour->refcnt );
        set_timer_limits ( &neighbour->timer, NEIGHBOUR_MIN_TIMEOUT,
                           NEIGHBOUR_MAX_TIMEOUT );
        INIT_LIST_HEAD ( &neighbour->tx_queue );
 
        /* Transfer ownership to cache */
        list_add ( &neighbour->list, &neighbours );
 
        DBGC ( neighbour, "NEIGHBOUR %s %s %s created\n", netdev->name,
               net_protocol->name, net_protocol->ntoa ( net_dest ) );
        return neighbour;
}

References DBGC, INIT_LIST_HEAD, neighbour::list, list_add, memcpy(), net_protocol::name, neighbour_expired(), neighbour_free(), NEIGHBOUR_MAX_TIMEOUT, NEIGHBOUR_MIN_TIMEOUT, neighbours, net_protocol::net_addr_len, neighbour::net_dest, neighbour::net_protocol, neighbour::netdev, netdev, netdev_get(), net_protocol::ntoa, NULL, ref_init, neighbour::refcnt, neighbour::timer, neighbour::tx_queue, and zalloc().

Referenced by neighbour_define(), and neighbour_tx().

neighbour_find()

struct neighbour * neighbour_find ( struct net_device * netdev, struct net_protocol * net_protocol, const void * net_dest )

static

Find neighbour cache entry.

Parameters

netdev	Network device
net_protocol	Network-layer protocol
net_dest	Destination network-layer address

Return values

neighbour

Neighbour cache entry, or NULL if not found

Definition at line 136 of file neighbour.c.

                                                                  {
        struct neighbour *neighbour;
 
        list_for_each_entry ( neighbour, &neighbours, list ) {
                if ( ( neighbour->netdev == netdev ) &&
                     ( neighbour->net_protocol == net_protocol ) &&
                     ( memcmp ( neighbour->net_dest, net_dest,
                                net_protocol->net_addr_len ) == 0 ) ) {
 
                        /* Move to start of cache */
                        list_del ( &neighbour->list );
                        list_add ( &neighbour->list, &neighbours );
 
                        return neighbour;
                }
        }
        return NULL;
}

References neighbour::list, list_add, list_del, list_for_each_entry, memcmp(), neighbours, net_protocol::net_addr_len, neighbour::net_dest, neighbour::net_protocol, neighbour::netdev, netdev, and NULL.

Referenced by neighbour_define(), neighbour_tx(), and neighbour_update().

neighbour_discover()

void neighbour_discover ( struct neighbour * neighbour, struct neighbour_discovery * discovery, const void * net_source )

static

Start neighbour discovery.

Parameters

neighbour	Neighbour cache entry
discovery	Neighbour discovery protocol
net_source	Source network-layer address

Definition at line 164 of file neighbour.c.

                                                          {
        struct net_device *netdev = neighbour->netdev;
        struct net_protocol *net_protocol = neighbour->net_protocol;
 
        /* Record discovery protocol and source network-layer address */
        neighbour->discovery = discovery;
        memcpy ( neighbour->net_source, net_source,
                 net_protocol->net_addr_len );
 
        /* Start timer to trigger neighbour discovery */
        start_timer_nodelay ( &neighbour->timer );
 
        DBGC ( neighbour, "NEIGHBOUR %s %s %s discovering via %s\n",
               netdev->name, net_protocol->name,
               net_protocol->ntoa ( neighbour->net_dest ),
               neighbour->discovery->name );
}

References DBGC, neighbour::discovery, memcpy(), neighbour_discovery::name, net_protocol::name, net_protocol::net_addr_len, neighbour::net_dest, neighbour::net_protocol, neighbour::net_source, neighbour::netdev, netdev, net_protocol::ntoa, start_timer_nodelay(), and neighbour::timer.

Referenced by neighbour_tx().

neighbour_tx_queue()

void neighbour_tx_queue ( struct neighbour * neighbour )

static

Transmit deferred packets.

Parameters

neighbour

Neighbour cache entry

Definition at line 189 of file neighbour.c.

                                                               {
        struct net_device *netdev = neighbour->netdev;
        struct net_protocol *net_protocol = neighbour->net_protocol;
        const void *ll_dest = neighbour->ll_dest;
        struct neighbour_delay *delay;
        struct io_buffer *iobuf;
        unsigned long elapsed;
        unsigned long threshold;
        unsigned int count = 0;
        int rc;
 
        /* Stop retransmission timer */
        stop_timer ( &neighbour->timer );
 
        /* Transmit any packets in queue.  Take out a temporary
         * reference on the entry to prevent it from going out of
         * scope during the call to net_tx().
         */
        ref_get ( &neighbour->refcnt );
        while ( ( iobuf = list_first_entry ( &neighbour->tx_queue,
                                             struct io_buffer, list )) != NULL){
 
                /* Handle delay injection */
                if ( NEIGHBOUR_DELAY_MS ) {
 
                        /* Determine elapsed time since transmission attempt */
                        delay = iobuf->data;
                        elapsed = ( currticks() - delay->start );
                        threshold = ( NEIGHBOUR_DELAY_MS * TICKS_PER_MS );
 
                        /* Defer transmission if not yet scheduled */
                        if ( elapsed < threshold ) {
                                start_timer_fixed ( &neighbour->timer,
                                                    ( threshold - elapsed ) );
                                break;
                        }
 
                        /* Defer transmission if maximum burst count reached */
                        if ( ++count >= NEIGHBOUR_DELAY_MAX_BURST ) {
                                start_timer_nodelay ( &neighbour->timer );
                                break;
                        }
 
                        /* Strip pseudo-header */
                        iob_pull ( iobuf, sizeof ( *delay ) );
 
                        /* Remove pending operation */
                        pending_put ( &neighbour_delayed );
                }
 
                /* Transmit deferred packet */
                DBGC2 ( neighbour, "NEIGHBOUR %s %s %s transmitting deferred "
                        "packet\n", netdev->name, net_protocol->name,
                        net_protocol->ntoa ( neighbour->net_dest ) );
                list_del ( &iobuf->list );
                if ( ( rc = net_tx ( iobuf, netdev, net_protocol, ll_dest,
                                     netdev->ll_addr ) ) != 0 ) {
                        DBGC ( neighbour, "NEIGHBOUR %s %s %s could not "
                               "transmit deferred packet: %s\n",
                               netdev->name, net_protocol->name,
                               net_protocol->ntoa ( neighbour->net_dest ),
                               strerror ( rc ) );
                        /* Ignore error and continue */
                }
        }
        ref_put ( &neighbour->refcnt );
}

References count, currticks(), io_buffer::data, DBGC, DBGC2, delay, iob_pull, io_buffer::list, list_del, list_first_entry, neighbour::ll_dest, net_protocol::name, NEIGHBOUR_DELAY_MAX_BURST, NEIGHBOUR_DELAY_MS, neighbour_delayed, neighbour::net_dest, neighbour::net_protocol, net_tx(), neighbour::netdev, netdev, net_protocol::ntoa, NULL, pending_put(), rc, ref_get, ref_put, neighbour::refcnt, start_timer_fixed(), start_timer_nodelay(), stop_timer(), strerror(), TICKS_PER_MS, neighbour::timer, and neighbour::tx_queue.

Referenced by neighbour_discovered(), neighbour_expired(), and neighbour_tx().

neighbour_discovered()

void neighbour_discovered ( struct neighbour * neighbour, const void * ll_dest )

static

Complete neighbour discovery.

Parameters

neighbour	Neighbour cache entry
ll_dest	Destination link-layer address

Definition at line 263 of file neighbour.c.

                                                         {
        struct net_device *netdev = neighbour->netdev;
        struct ll_protocol *ll_protocol = netdev->ll_protocol;
        struct net_protocol *net_protocol = neighbour->net_protocol;
 
        /* Fill in link-layer address */
        memcpy ( neighbour->ll_dest, ll_dest, ll_protocol->ll_addr_len );
        DBGC ( neighbour, "NEIGHBOUR %s %s %s is %s %s\n", netdev->name,
               net_protocol->name, net_protocol->ntoa ( neighbour->net_dest ),
               ll_protocol->name, ll_protocol->ntoa ( neighbour->ll_dest ) );
 
        /* Mark discovery as complete */
        neighbour->discovery = NULL;
 
        /* Transmit any deferred packets */
        neighbour_tx_queue ( neighbour );
}

References DBGC, neighbour::discovery, ll_protocol::ll_addr_len, neighbour::ll_dest, memcpy(), ll_protocol::name, net_protocol::name, neighbour_tx_queue(), neighbour::net_dest, neighbour::net_protocol, neighbour::netdev, netdev, ll_protocol::ntoa, net_protocol::ntoa, and NULL.

Referenced by neighbour_define(), and neighbour_update().

neighbour_destroy()

void neighbour_destroy ( struct neighbour * neighbour, int rc )

static

Destroy neighbour cache entry.

Parameters

neighbour	Neighbour cache entry
rc	Reason for destruction

Definition at line 288 of file neighbour.c.

                                                                      {
        struct net_device *netdev = neighbour->netdev;
        struct net_protocol *net_protocol = neighbour->net_protocol;
        struct io_buffer *iobuf;
 
        /* Take ownership from cache */
        list_del ( &neighbour->list );
 
        /* Stop timer */
        stop_timer ( &neighbour->timer );
 
        /* Discard any outstanding I/O buffers */
        while ( ( iobuf = list_first_entry ( &neighbour->tx_queue,
                                             struct io_buffer, list )) != NULL){
                DBGC2 ( neighbour, "NEIGHBOUR %s %s %s discarding deferred "
                        "packet: %s\n", netdev->name, net_protocol->name,
                        net_protocol->ntoa ( neighbour->net_dest ),
                        strerror ( rc ) );
                list_del ( &iobuf->list );
                if ( NEIGHBOUR_DELAY_MS )
                        pending_put ( &neighbour_delayed );
                netdev_tx_err ( neighbour->netdev, iobuf, rc );
        }
 
        DBGC ( neighbour, "NEIGHBOUR %s %s %s destroyed: %s\n", netdev->name,
               net_protocol->name, net_protocol->ntoa ( neighbour->net_dest ),
               strerror ( rc ) );
 
        /* Drop remaining reference */
        ref_put ( &neighbour->refcnt );
}

References DBGC, DBGC2, io_buffer::list, neighbour::list, list_del, list_first_entry, net_protocol::name, NEIGHBOUR_DELAY_MS, neighbour_delayed, neighbour::net_dest, neighbour::net_protocol, neighbour::netdev, netdev, netdev_tx_err(), net_protocol::ntoa, NULL, pending_put(), rc, ref_put, neighbour::refcnt, stop_timer(), strerror(), neighbour::timer, and neighbour::tx_queue.

Referenced by neighbour_discard(), neighbour_expired(), and neighbour_flush().

neighbour_tx()

int neighbour_tx	(	struct io_buffer *	iobuf,
		struct net_device *	netdev,
		struct net_protocol *	net_protocol,
		const void *	net_dest,
		struct neighbour_discovery *	discovery,
		const void *	net_source )

Transmit packet, determining link-layer address via neighbour discovery.

Parameters

iobuf	I/O buffer
netdev	Network device
discovery	Neighbour discovery protocol
net_protocol	Network-layer protocol
net_dest	Destination network-layer address
net_source	Source network-layer address

Return values

rc	Return status code

Definition at line 377 of file neighbour.c.

                                            {
        struct neighbour *neighbour;
        struct neighbour_delay *delay;
        int rc;
 
        /* Find or create neighbour cache entry */
        neighbour = neighbour_find ( netdev, net_protocol, net_dest );
        if ( ! neighbour ) {
                neighbour = neighbour_create ( netdev, net_protocol, net_dest );
                if ( ! neighbour )
                        return -ENOMEM;
                neighbour_discover ( neighbour, discovery, net_source );
        }
 
        /* If discovery is still in progress or if delay injection is
         * in use, then queue for later transmission.
         */
        if ( NEIGHBOUR_DELAY_MS || neighbour->discovery ) {
 
                /* Add to deferred packet queue */
                DBGC2 ( neighbour, "NEIGHBOUR %s %s %s deferring packet\n",
                        netdev->name, net_protocol->name,
                        net_protocol->ntoa ( net_dest ) );
                list_add_tail ( &iobuf->list, &neighbour->tx_queue );
 
                /* Handle delay injection, if applicable */
                if ( NEIGHBOUR_DELAY_MS ) {
 
                        /* Record original transmission time */
                        delay = iob_push ( iobuf, sizeof ( *delay ) );
                        delay->start = currticks();
 
                        /* Add pending operation */
                        pending_get ( &neighbour_delayed );
 
                        /* Process deferred packet queue, if possible */
                        if ( ! neighbour->discovery )
                                neighbour_tx_queue ( neighbour );
                }
 
                return 0;
        }
 
        /* Otherwise, transmit immediately */
        if ( ( rc = net_tx ( iobuf, netdev, net_protocol, neighbour->ll_dest,
                             netdev->ll_addr ) ) != 0 ) {
                return rc;
        }
 
        return 0;
}

References currticks(), DBGC2, delay, neighbour::discovery, ENOMEM, iob_push, io_buffer::list, list_add_tail, neighbour::ll_dest, net_protocol::name, neighbour_create(), NEIGHBOUR_DELAY_MS, neighbour_delayed, neighbour_discover(), neighbour_find(), neighbour_tx_queue(), net_tx(), netdev, net_protocol::ntoa, pending_get(), rc, and neighbour::tx_queue.

Referenced by arp_tx(), and ndp_tx().

neighbour_update()

int neighbour_update	(	struct net_device *	netdev,
		struct net_protocol *	net_protocol,
		const void *	net_dest,
		const void *	ll_dest )

Update existing neighbour cache entry.

Parameters

netdev	Network device
net_protocol	Network-layer protocol
net_dest	Destination network-layer address
ll_dest	Destination link-layer address

Return values

rc	Return status code

Definition at line 441 of file neighbour.c.

                                                                   {
        struct neighbour *neighbour;
 
        /* Find neighbour cache entry */
        neighbour = neighbour_find ( netdev, net_protocol, net_dest );
        if ( ! neighbour )
                return -ENOENT;
 
        /* Set destination address */
        neighbour_discovered ( neighbour, ll_dest );
 
        return 0;
}

References ENOENT, neighbour::ll_dest, neighbour_discovered(), neighbour_find(), neighbour::net_dest, and netdev.

Referenced by arp_rx(), and ndp_rx_neighbour_advertisement_ll_target().

neighbour_define()

int neighbour_define	(	struct net_device *	netdev,
		struct net_protocol *	net_protocol,
		const void *	net_dest,
		const void *	ll_dest )

Define neighbour cache entry.

Parameters

netdev	Network device
net_protocol	Network-layer protocol
net_dest	Destination network-layer address
ll_dest	Destination link-layer address, if known

Return values

rc	Return status code

Definition at line 466 of file neighbour.c.

                                                                   {
        struct neighbour *neighbour;
 
        /* Find or create neighbour cache entry */
        neighbour = neighbour_find ( netdev, net_protocol, net_dest );
        if ( ! neighbour ) {
                neighbour = neighbour_create ( netdev, net_protocol, net_dest );
                if ( ! neighbour )
                        return -ENOMEM;
        }
 
        /* Set destination address */
        neighbour_discovered ( neighbour, ll_dest );
 
        return 0;
}

References ENOMEM, neighbour::ll_dest, neighbour_create(), neighbour_discovered(), neighbour_find(), neighbour::net_dest, and netdev.

Referenced by ndp_rx_neighbour_solicitation_ll_source(), and ndp_rx_router_advertisement_ll_source().

neighbour_flush()

void neighbour_flush ( struct net_device * netdev, void *priv __unused )

static

Update neighbour cache on network device state change or removal.

Parameters

netdev	Network device
priv	Private data

Definition at line 491 of file neighbour.c.

                                                                               {
        struct neighbour *neighbour;
        struct neighbour *tmp;
 
        /* Remove all neighbour cache entries when a network device is closed */
        if ( ! netdev_is_open ( netdev ) ) {
                list_for_each_entry_safe ( neighbour, tmp, &neighbours, list )
                        neighbour_destroy ( neighbour, -ENODEV );
        }
}

References __unused, ENODEV, neighbour::list, list_for_each_entry_safe, neighbour_destroy(), neighbours, netdev, netdev_is_open(), priv, and tmp.

neighbour_discard()

unsigned int neighbour_discard ( void )

static

Discard some cached neighbour entries.

Return values

discarded

Number of cached items discarded

Definition at line 514 of file neighbour.c.

                                               {
        struct neighbour *neighbour;
 
        /* Drop oldest cache entry, if any */
        neighbour = list_last_entry ( &neighbours, struct neighbour, list );
        if ( neighbour ) {
                neighbour_destroy ( neighbour, -ENOBUFS );
                return 1;
        } else {
                return 0;
        }
}

References ENOBUFS, neighbour::list, list_last_entry, neighbour_destroy(), and neighbours.

Referenced by __cache_discarder().

__cache_discarder()

struct cache_discarder neighbour_discarder __cache_discarder

(

CACHE_EXPENSIVE

)

Neighbour cache discarder.

Neighbour cache entries are deemed to have a high replacement cost, since flushing an active neighbour cache entry midway through a TCP transfer will cause substantial disruption.

References __cache_discarder, CACHE_EXPENSIVE, and neighbour_discard().

Variable Documentation

neighbours

struct list_head neighbours = LIST_HEAD_INIT ( neighbours )

The neighbour cache.

Definition at line 67 of file neighbour.c.

Referenced by neighbour_create(), neighbour_discard(), neighbour_find(), neighbour_flush(), and nstat().

neighbour_delayed

struct pending_operation neighbour_delayed

static

Pending operation for delayed transmissions.

Definition at line 70 of file neighbour.c.

Referenced by neighbour_destroy(), neighbour_tx(), and neighbour_tx_queue().

__net_driver

struct net_driver neighbour_net_driver __net_driver

Initial value:

= {
        .name = "Neighbour",
        .notify = neighbour_flush,
        .remove = neighbour_flush,
}

Neighbour driver (for net device notifications)

Definition at line 503 of file neighbour.c.

                                                      {
        .name = "Neighbour",
        .notify = neighbour_flush,
        .remove = neighbour_flush,
};