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/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. More...
#define	NEIGHBOUR_MAX_TIMEOUT   ( TICKS_PER_SEC * 3 )
	Neighbour discovery maximum timeout. More...
#define	NEIGHBOUR_DELAY_MAX_BURST   2
	Neighbour discovery maximum burst count for delayed transmissions. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static void	neighbour_expired (struct retry_timer *timer, int fail)
	Handle neighbour timer expiry. More...
static void	neighbour_free (struct refcnt *refcnt)
	Free neighbour cache entry. More...
static struct neighbour *	neighbour_create (struct net_device *netdev, struct net_protocol *net_protocol, const void *net_dest)
	Create neighbour cache entry. More...
static struct neighbour *	neighbour_find (struct net_device *netdev, struct net_protocol *net_protocol, const void *net_dest)
	Find neighbour cache entry. More...
static void	neighbour_discover (struct neighbour *neighbour, struct neighbour_discovery *discovery, const void *net_source)
	Start neighbour discovery. More...
static void	neighbour_tx_queue (struct neighbour *neighbour)
	Transmit deferred packets. More...
static void	neighbour_discovered (struct neighbour *neighbour, const void *ll_dest)
	Complete neighbour discovery. More...
static void	neighbour_destroy (struct neighbour *neighbour, int rc)
	Destroy neighbour cache entry. More...
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. More...
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. More...
int	neighbour_define (struct net_device *netdev, struct net_protocol *net_protocol, const void *net_dest, const void *ll_dest)
	Define neighbour cache entry. More...
static void	neighbour_flush (struct net_device *netdev, void *priv __unused)
	Update neighbour cache on network device state change or removal. More...
static unsigned int	neighbour_discard (void)
	Discard some cached neighbour entries. More...
struct cache_discarder neighbour_discarder	__cache_discarder (CACHE_EXPENSIVE)
	Neighbour cache discarder. More...

Variables
struct list_head	neighbours = LIST_HEAD_INIT ( neighbours )
	The neighbour cache. More...
struct net_driver neighbour_net_driver	__net_driver
	Neighbour driver (for net device notifications) More...

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 47 of file neighbour.c.

NEIGHBOUR_MAX_TIMEOUT

#define NEIGHBOUR_MAX_TIMEOUT   ( TICKS_PER_SEC * 3 )

Neighbour discovery maximum timeout.

Definition at line 50 of file neighbour.c.

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 62 of file neighbour.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

neighbour_expired()

static void neighbour_expired ( struct retry_timer *  timer, int  fail  )

static

Handle neighbour timer expiry.

Parameters

timer	Retry timer
fail	Failure indicator

Definition at line 316 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, net_device::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()

static void neighbour_free ( struct refcnt *  refcnt )

static

Free neighbour cache entry.

Parameters

refcnt

Reference count

Definition at line 74 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()

static 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 96 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, net_device::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()

static 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 131 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()

static 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 159 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_device::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()

static void neighbour_tx_queue ( struct neighbour *  neighbour )

static

Transmit deferred packets.

Parameters

neighbour

Neighbour cache entry

Definition at line 184 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 ) );
                }

                /* 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, net_device::ll_addr, neighbour::ll_dest, net_protocol::name, net_device::name, NEIGHBOUR_DELAY_MAX_BURST, NEIGHBOUR_DELAY_MS, neighbour::net_dest, neighbour::net_protocol, net_tx(), neighbour::netdev, netdev, net_protocol::ntoa, NULL, 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()

static 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 255 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, net_device::ll_protocol, memcpy(), net_protocol::name, ll_protocol::name, net_device::name, neighbour_tx_queue(), neighbour::net_dest, neighbour::net_protocol, neighbour::netdev, netdev, net_protocol::ntoa, ll_protocol::ntoa, and NULL.

Referenced by neighbour_define(), and neighbour_update().

neighbour_destroy()

static 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 280 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 );
                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, neighbour::list, io_buffer::list, list_del, list_first_entry, net_protocol::name, net_device::name, neighbour::net_dest, neighbour::net_protocol, neighbour::netdev, netdev, netdev_tx_err(), net_protocol::ntoa, NULL, 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 367 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();

                        /* 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, net_device::ll_addr, neighbour::ll_dest, net_protocol::name, net_device::name, neighbour_create(), NEIGHBOUR_DELAY_MS, neighbour_discover(), neighbour_find(), neighbour_tx_queue(), net_tx(), netdev, net_protocol::ntoa, 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 428 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 453 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()

static 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 478 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 ENODEV, neighbour::list, list_for_each_entry_safe, neighbour_destroy(), neighbours, netdev, netdev_is_open(), and tmp.

neighbour_discard()

static unsigned int neighbour_discard ( void  )

static

Discard some cached neighbour entries.

Return values

discarded

Number of cached items discarded

Definition at line 501 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.

__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.

Variable Documentation

neighbours

struct list_head neighbours = LIST_HEAD_INIT ( neighbours )

The neighbour cache.

Definition at line 65 of file neighbour.c.

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

__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 490 of file neighbour.c.