2005-01-07 02:30:35 +00:00
|
|
|
/*-
|
1999-11-22 02:45:11 +00:00
|
|
|
* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. Neither the name of the project nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
2007-12-10 16:03:40 +00:00
|
|
|
*
|
|
|
|
* $KAME: nd6.c,v 1.144 2001/05/24 07:44:00 itojun Exp $
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
|
2007-12-10 16:03:40 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
#include "opt_inet.h"
|
|
|
|
#include "opt_inet6.h"
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2001-06-11 12:39:29 +00:00
|
|
|
#include <sys/callout.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/mbuf.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/sockio.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/kernel.h>
|
2000-07-04 16:35:15 +00:00
|
|
|
#include <sys/protosw.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <sys/errno.h>
|
|
|
|
#include <sys/syslog.h>
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/rwlock.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <sys/queue.h>
|
2001-06-11 12:39:29 +00:00
|
|
|
#include <sys/sysctl.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
#include <net/if.h>
|
2003-10-20 15:27:48 +00:00
|
|
|
#include <net/if_arc.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <net/if_dl.h>
|
|
|
|
#include <net/if_types.h>
|
2003-09-14 02:32:31 +00:00
|
|
|
#include <net/iso88025.h>
|
2002-04-06 03:21:46 +00:00
|
|
|
#include <net/fddi.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <net/route.h>
|
2008-12-02 21:37:28 +00:00
|
|
|
#include <net/vnet.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
#include <netinet/in.h>
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
#include <net/if_llatbl.h>
|
|
|
|
#define L3_ADDR_SIN6(le) ((struct sockaddr_in6 *) L3_ADDR(le))
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <netinet/if_ether.h>
|
|
|
|
#include <netinet6/in6_var.h>
|
2000-07-04 16:35:15 +00:00
|
|
|
#include <netinet/ip6.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <netinet6/ip6_var.h>
|
2005-07-25 12:31:43 +00:00
|
|
|
#include <netinet6/scope6_var.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <netinet6/nd6.h>
|
2009-09-12 22:08:20 +00:00
|
|
|
#include <netinet6/in6_ifattach.h>
|
2000-07-04 16:35:15 +00:00
|
|
|
#include <netinet/icmp6.h>
|
2010-08-19 11:31:03 +00:00
|
|
|
#include <netinet6/send.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
#include <sys/limits.h>
|
|
|
|
|
2006-10-22 11:52:19 +00:00
|
|
|
#include <security/mac/mac_framework.h>
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
#define ND6_SLOWTIMER_INTERVAL (60 * 60) /* 1 hour */
|
|
|
|
#define ND6_RECALC_REACHTM_INTERVAL (60 * 120) /* 2 hours */
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
#define SIN6(s) ((struct sockaddr_in6 *)s)
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2010-04-29 11:52:42 +00:00
|
|
|
/* timer values */
|
|
|
|
VNET_DEFINE(int, nd6_prune) = 1; /* walk list every 1 seconds */
|
|
|
|
VNET_DEFINE(int, nd6_delay) = 5; /* delay first probe time 5 second */
|
|
|
|
VNET_DEFINE(int, nd6_umaxtries) = 3; /* maximum unicast query */
|
|
|
|
VNET_DEFINE(int, nd6_mmaxtries) = 3; /* maximum multicast query */
|
|
|
|
VNET_DEFINE(int, nd6_useloopback) = 1; /* use loopback interface for
|
|
|
|
* local traffic */
|
|
|
|
VNET_DEFINE(int, nd6_gctimer) = (60 * 60 * 24); /* 1 day: garbage
|
|
|
|
* collection timer */
|
2000-07-04 16:35:15 +00:00
|
|
|
|
|
|
|
/* preventing too many loops in ND option parsing */
|
2010-11-22 19:32:54 +00:00
|
|
|
static VNET_DEFINE(int, nd6_maxndopt) = 10; /* max # of ND options allowed */
|
2010-04-29 11:52:42 +00:00
|
|
|
|
|
|
|
VNET_DEFINE(int, nd6_maxnudhint) = 0; /* max # of subsequent upper
|
|
|
|
* layer hints */
|
2010-11-22 19:32:54 +00:00
|
|
|
static VNET_DEFINE(int, nd6_maxqueuelen) = 1; /* max pkts cached in unresolved
|
2010-04-29 11:52:42 +00:00
|
|
|
* ND entries */
|
2009-07-16 21:13:04 +00:00
|
|
|
#define V_nd6_maxndopt VNET(nd6_maxndopt)
|
|
|
|
#define V_nd6_maxqueuelen VNET(nd6_maxqueuelen)
|
2000-07-04 16:35:15 +00:00
|
|
|
|
2010-04-29 11:52:42 +00:00
|
|
|
#ifdef ND6_DEBUG
|
|
|
|
VNET_DEFINE(int, nd6_debug) = 1;
|
|
|
|
#else
|
|
|
|
VNET_DEFINE(int, nd6_debug) = 0;
|
|
|
|
#endif
|
2001-06-11 12:39:29 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/* for debugging? */
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
#if 0
|
2000-07-04 16:35:15 +00:00
|
|
|
static int nd6_inuse, nd6_allocated;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
#endif
|
1999-11-22 02:45:11 +00:00
|
|
|
|
Build on Jeff Roberson's linker-set based dynamic per-CPU allocator
(DPCPU), as suggested by Peter Wemm, and implement a new per-virtual
network stack memory allocator. Modify vnet to use the allocator
instead of monolithic global container structures (vinet, ...). This
change solves many binary compatibility problems associated with
VIMAGE, and restores ELF symbols for virtualized global variables.
Each virtualized global variable exists as a "reference copy", and also
once per virtual network stack. Virtualized global variables are
tagged at compile-time, placing the in a special linker set, which is
loaded into a contiguous region of kernel memory. Virtualized global
variables in the base kernel are linked as normal, but those in modules
are copied and relocated to a reserved portion of the kernel's vnet
region with the help of a the kernel linker.
Virtualized global variables exist in per-vnet memory set up when the
network stack instance is created, and are initialized statically from
the reference copy. Run-time access occurs via an accessor macro, which
converts from the current vnet and requested symbol to a per-vnet
address. When "options VIMAGE" is not compiled into the kernel, normal
global ELF symbols will be used instead and indirection is avoided.
This change restores static initialization for network stack global
variables, restores support for non-global symbols and types, eliminates
the need for many subsystem constructors, eliminates large per-subsystem
structures that caused many binary compatibility issues both for
monitoring applications (netstat) and kernel modules, removes the
per-function INIT_VNET_*() macros throughout the stack, eliminates the
need for vnet_symmap ksym(2) munging, and eliminates duplicate
definitions of virtualized globals under VIMAGE_GLOBALS.
Bump __FreeBSD_version and update UPDATING.
Portions submitted by: bz
Reviewed by: bz, zec
Discussed with: gnn, jamie, jeff, jhb, julian, sam
Suggested by: peter
Approved by: re (kensmith)
2009-07-14 22:48:30 +00:00
|
|
|
VNET_DEFINE(struct nd_drhead, nd_defrouter);
|
|
|
|
VNET_DEFINE(struct nd_prhead, nd_prefix);
|
2008-11-19 09:39:34 +00:00
|
|
|
|
2010-04-29 11:52:42 +00:00
|
|
|
VNET_DEFINE(int, nd6_recalc_reachtm_interval) = ND6_RECALC_REACHTM_INTERVAL;
|
2009-07-16 21:13:04 +00:00
|
|
|
#define V_nd6_recalc_reachtm_interval VNET(nd6_recalc_reachtm_interval)
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
static struct sockaddr_in6 all1_sa;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2010-08-19 11:31:03 +00:00
|
|
|
int (*send_sendso_input_hook)(struct mbuf *, struct ifnet *, int, int);
|
|
|
|
|
2004-10-03 00:49:33 +00:00
|
|
|
static int nd6_is_new_addr_neighbor __P((struct sockaddr_in6 *,
|
|
|
|
struct ifnet *));
|
2008-01-08 19:08:58 +00:00
|
|
|
static void nd6_setmtu0(struct ifnet *, struct nd_ifinfo *);
|
|
|
|
static void nd6_slowtimo(void *);
|
|
|
|
static int regen_tmpaddr(struct in6_ifaddr *);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
static struct llentry *nd6_free(struct llentry *, int);
|
2008-01-08 19:08:58 +00:00
|
|
|
static void nd6_llinfo_timer(void *);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
static void clear_llinfo_pqueue(struct llentry *);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2010-11-22 19:32:54 +00:00
|
|
|
static VNET_DEFINE(struct callout, nd6_slowtimo_ch);
|
2009-07-16 21:13:04 +00:00
|
|
|
#define V_nd6_slowtimo_ch VNET(nd6_slowtimo_ch)
|
Build on Jeff Roberson's linker-set based dynamic per-CPU allocator
(DPCPU), as suggested by Peter Wemm, and implement a new per-virtual
network stack memory allocator. Modify vnet to use the allocator
instead of monolithic global container structures (vinet, ...). This
change solves many binary compatibility problems associated with
VIMAGE, and restores ELF symbols for virtualized global variables.
Each virtualized global variable exists as a "reference copy", and also
once per virtual network stack. Virtualized global variables are
tagged at compile-time, placing the in a special linker set, which is
loaded into a contiguous region of kernel memory. Virtualized global
variables in the base kernel are linked as normal, but those in modules
are copied and relocated to a reserved portion of the kernel's vnet
region with the help of a the kernel linker.
Virtualized global variables exist in per-vnet memory set up when the
network stack instance is created, and are initialized statically from
the reference copy. Run-time access occurs via an accessor macro, which
converts from the current vnet and requested symbol to a per-vnet
address. When "options VIMAGE" is not compiled into the kernel, normal
global ELF symbols will be used instead and indirection is avoided.
This change restores static initialization for network stack global
variables, restores support for non-global symbols and types, eliminates
the need for many subsystem constructors, eliminates large per-subsystem
structures that caused many binary compatibility issues both for
monitoring applications (netstat) and kernel modules, removes the
per-function INIT_VNET_*() macros throughout the stack, eliminates the
need for vnet_symmap ksym(2) munging, and eliminates duplicate
definitions of virtualized globals under VIMAGE_GLOBALS.
Bump __FreeBSD_version and update UPDATING.
Portions submitted by: bz
Reviewed by: bz, zec
Discussed with: gnn, jamie, jeff, jhb, julian, sam
Suggested by: peter
Approved by: re (kensmith)
2009-07-14 22:48:30 +00:00
|
|
|
|
|
|
|
VNET_DEFINE(struct callout, nd6_timer_ch);
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
void
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_init(void)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2008-11-19 09:39:34 +00:00
|
|
|
LIST_INIT(&V_nd_prefix);
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
all1_sa.sin6_family = AF_INET6;
|
|
|
|
all1_sa.sin6_len = sizeof(struct sockaddr_in6);
|
|
|
|
for (i = 0; i < sizeof(all1_sa.sin6_addr); i++)
|
|
|
|
all1_sa.sin6_addr.s6_addr[i] = 0xff;
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
/* initialization of the default router list */
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
TAILQ_INIT(&V_nd_defrouter);
|
2010-04-29 11:52:42 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/* start timer */
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
callout_init(&V_nd6_slowtimo_ch, 0);
|
|
|
|
callout_reset(&V_nd6_slowtimo_ch, ND6_SLOWTIMER_INTERVAL * hz,
|
Permit buiding kernels with options VIMAGE, restricted to only a single
active network stack instance. Turning on options VIMAGE at compile
time yields the following changes relative to default kernel build:
1) V_ accessor macros for virtualized variables resolve to structure
fields via base pointers, instead of being resolved as fields in global
structs or plain global variables. As an example, V_ifnet becomes:
options VIMAGE: ((struct vnet_net *) vnet_net)->_ifnet
default build: vnet_net_0._ifnet
options VIMAGE_GLOBALS: ifnet
2) INIT_VNET_* macros will declare and set up base pointers to be used
by V_ accessor macros, instead of resolving to whitespace:
INIT_VNET_NET(ifp->if_vnet); becomes
struct vnet_net *vnet_net = (ifp->if_vnet)->mod_data[VNET_MOD_NET];
3) Memory for vnet modules registered via vnet_mod_register() is now
allocated at run time in sys/kern/kern_vimage.c, instead of per vnet
module structs being declared as globals. If required, vnet modules
can now request the framework to provide them with allocated bzeroed
memory by filling in the vmi_size field in their vmi_modinfo structures.
4) structs socket, ifnet, inpcbinfo, tcpcb and syncache_head are
extended to hold a pointer to the parent vnet. options VIMAGE builds
will fill in those fields as required.
5) curvnet is introduced as a new global variable in options VIMAGE
builds, always pointing to the default and only struct vnet.
6) struct sysctl_oid has been extended with additional two fields to
store major and minor virtualization module identifiers, oid_v_subs and
oid_v_mod. SYSCTL_V_* family of macros will fill in those fields
accordingly, and store the offset in the appropriate vnet container
struct in oid_arg1.
In sysctl handlers dealing with virtualized sysctls, the
SYSCTL_RESOLVE_V_ARG1() macro will compute the address of the target
variable and make it available in arg1 variable for further processing.
Unused fields in structs vnet_inet, vnet_inet6 and vnet_ipfw have
been deleted.
Reviewed by: bz, rwatson
Approved by: julian (mentor)
2009-04-30 13:36:26 +00:00
|
|
|
nd6_slowtimo, curvnet);
|
Introduce an infrastructure for dismantling vnet instances.
Vnet modules and protocol domains may now register destructor
functions to clean up and release per-module state. The destructor
mechanisms can be triggered by invoking "vimage -d", or a future
equivalent command which will be provided via the new jail framework.
While this patch introduces numerous placeholder destructor functions,
many of those are currently incomplete, thus leaking memory or (even
worse) failing to stop all running timers. Many of such issues are
already known and will be incrementaly fixed over the next weeks in
smaller incremental commits.
Apart from introducing new fields in structs ifnet, domain, protosw
and vnet_net, which requires the kernel and modules to be rebuilt, this
change should have no impact on nooptions VIMAGE builds, since vnet
destructors can only be called in VIMAGE kernels. Moreover,
destructor functions should be in general compiled in only in
options VIMAGE builds, except for kernel modules which can be safely
kldunloaded at run time.
Bump __FreeBSD_version to 800097.
Reviewed by: bz, julian
Approved by: rwatson, kib (re), julian (mentor)
2009-06-08 17:15:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef VIMAGE
|
|
|
|
void
|
|
|
|
nd6_destroy()
|
|
|
|
{
|
2008-08-20 01:05:56 +00:00
|
|
|
|
Introduce an infrastructure for dismantling vnet instances.
Vnet modules and protocol domains may now register destructor
functions to clean up and release per-module state. The destructor
mechanisms can be triggered by invoking "vimage -d", or a future
equivalent command which will be provided via the new jail framework.
While this patch introduces numerous placeholder destructor functions,
many of those are currently incomplete, thus leaking memory or (even
worse) failing to stop all running timers. Many of such issues are
already known and will be incrementaly fixed over the next weeks in
smaller incremental commits.
Apart from introducing new fields in structs ifnet, domain, protosw
and vnet_net, which requires the kernel and modules to be rebuilt, this
change should have no impact on nooptions VIMAGE builds, since vnet
destructors can only be called in VIMAGE kernels. Moreover,
destructor functions should be in general compiled in only in
options VIMAGE builds, except for kernel modules which can be safely
kldunloaded at run time.
Bump __FreeBSD_version to 800097.
Reviewed by: bz, julian
Approved by: rwatson, kib (re), julian (mentor)
2009-06-08 17:15:40 +00:00
|
|
|
callout_drain(&V_nd6_slowtimo_ch);
|
|
|
|
callout_drain(&V_nd6_timer_ch);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
Introduce an infrastructure for dismantling vnet instances.
Vnet modules and protocol domains may now register destructor
functions to clean up and release per-module state. The destructor
mechanisms can be triggered by invoking "vimage -d", or a future
equivalent command which will be provided via the new jail framework.
While this patch introduces numerous placeholder destructor functions,
many of those are currently incomplete, thus leaking memory or (even
worse) failing to stop all running timers. Many of such issues are
already known and will be incrementaly fixed over the next weeks in
smaller incremental commits.
Apart from introducing new fields in structs ifnet, domain, protosw
and vnet_net, which requires the kernel and modules to be rebuilt, this
change should have no impact on nooptions VIMAGE builds, since vnet
destructors can only be called in VIMAGE kernels. Moreover,
destructor functions should be in general compiled in only in
options VIMAGE builds, except for kernel modules which can be safely
kldunloaded at run time.
Bump __FreeBSD_version to 800097.
Reviewed by: bz, julian
Approved by: rwatson, kib (re), julian (mentor)
2009-06-08 17:15:40 +00:00
|
|
|
#endif
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-17 15:46:31 +00:00
|
|
|
struct nd_ifinfo *
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_ifattach(struct ifnet *ifp)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
2003-10-17 15:46:31 +00:00
|
|
|
struct nd_ifinfo *nd;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-17 15:46:31 +00:00
|
|
|
nd = (struct nd_ifinfo *)malloc(sizeof(*nd), M_IP6NDP, M_WAITOK);
|
|
|
|
bzero(nd, sizeof(*nd));
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-17 15:46:31 +00:00
|
|
|
nd->initialized = 1;
|
2000-07-04 16:35:15 +00:00
|
|
|
|
2003-10-17 15:46:31 +00:00
|
|
|
nd->chlim = IPV6_DEFHLIM;
|
|
|
|
nd->basereachable = REACHABLE_TIME;
|
|
|
|
nd->reachable = ND_COMPUTE_RTIME(nd->basereachable);
|
|
|
|
nd->retrans = RETRANS_TIMER;
|
2009-09-12 22:08:20 +00:00
|
|
|
|
|
|
|
nd->flags = ND6_IFF_PERFORMNUD;
|
|
|
|
|
|
|
|
/* A loopback interface always has ND6_IFF_AUTO_LINKLOCAL. */
|
|
|
|
if (V_ip6_auto_linklocal || (ifp->if_flags & IFF_LOOPBACK))
|
|
|
|
nd->flags |= ND6_IFF_AUTO_LINKLOCAL;
|
|
|
|
|
|
|
|
/* A loopback interface does not need to accept RTADV. */
|
|
|
|
if (V_ip6_accept_rtadv && !(ifp->if_flags & IFF_LOOPBACK))
|
|
|
|
nd->flags |= ND6_IFF_ACCEPT_RTADV;
|
- Accept Router Advertisement messages even when net.inet6.ip6.forwarding=1.
- A new per-interface knob IFF_ND6_NO_RADR and sysctl IPV6CTL_NO_RADR.
This controls if accepting a route in an RA message as the default route.
The default value for each interface can be set by net.inet6.ip6.no_radr.
The system wide default value is 0.
- A new sysctl: net.inet6.ip6.norbit_raif. This controls if setting R-bit in
NA on RA accepting interfaces. The default is 0 (R-bit is set based on
net.inet6.ip6.forwarding).
Background:
IPv6 host/router model suggests a router sends an RA and a host accepts it for
router discovery. Because of that, KAME implementation does not allow
accepting RAs when net.inet6.ip6.forwarding=1. Accepting RAs on a router can
make the routing table confused since it can change the default router
unintentionally.
However, in practice there are cases where we cannot distinguish a host from
a router clearly. For example, a customer edge router often works as a host
against the ISP, and as a router against the LAN at the same time. Another
example is a complex network configurations like an L2TP tunnel for IPv6
connection to Internet over an Ethernet link with another native IPv6 subnet.
In this case, the physical interface for the native IPv6 subnet works as a
host, and the pseudo-interface for L2TP works as the default IP forwarding
route.
Problem:
Disabling processing RA messages when net.inet6.ip6.forwarding=1 and
accepting them when net.inet6.ip6.forward=0 cause the following practical
issues:
- A router cannot perform SLAAC. It becomes a problem if a box has
multiple interfaces and you want to use SLAAC on some of them, for
example. A customer edge router for IPv6 Internet access service
using an IPv6-over-IPv6 tunnel sometimes needs SLAAC on the
physical interface for administration purpose; updating firmware
and so on (link-local addresses can be used there, but GUAs by
SLAAC are often used for scalability).
- When a host has multiple IPv6 interfaces and it receives multiple RAs on
them, controlling the default route is difficult. Router preferences
defined in RFC 4191 works only when the routers on the links are
under your control.
Details of Implementation Changes:
Router Advertisement messages will be accepted even when
net.inet6.ip6.forwarding=1. More precisely, the conditions are as
follow:
(ACCEPT_RTADV && !NO_RADR && !ip6.forwarding)
=> Normal RA processing on that interface. (as IPv6 host)
(ACCEPT_RTADV && (NO_RADR || ip6.forwarding))
=> Accept RA but add the router to the defroute list with
rtlifetime=0 unconditionally. This effectively prevents
from setting the received router address as the box's
default route.
(!ACCEPT_RTADV)
=> No RA processing on that interface.
ACCEPT_RTADV and NO_RADR are per-interface knob. In short, all interface
are classified as "RA-accepting" or not. An RA-accepting interface always
processes RA messages regardless of ip6.forwarding. The difference caused by
NO_RADR or ip6.forwarding is whether the RA source address is considered as
the default router or not.
R-bit in NA on the RA accepting interfaces is set based on
net.inet6.ip6.forwarding. While RFC 6204 W-1 rule (for CPE case) suggests
a router should disable the R-bit completely even when the box has
net.inet6.ip6.forwarding=1, I believe there is no technical reason with
doing so. This behavior can be set by a new sysctl net.inet6.ip6.norbit_raif
(the default is 0).
Usage:
# ifconfig fxp0 inet6 accept_rtadv
=> accept RA on fxp0
# ifconfig fxp0 inet6 accept_rtadv no_radr
=> accept RA on fxp0 but ignore default route information in it.
# sysctl net.inet6.ip6.norbit_no_radr=1
=> R-bit in NAs on RA accepting interfaces will always be set to 0.
2011-06-06 02:14:23 +00:00
|
|
|
if (V_ip6_no_radr && !(ifp->if_flags & IFF_LOOPBACK))
|
|
|
|
nd->flags |= ND6_IFF_NO_RADR;
|
2003-10-17 15:46:31 +00:00
|
|
|
|
|
|
|
/* XXX: we cannot call nd6_setmtu since ifp is not fully initialized */
|
|
|
|
nd6_setmtu0(ifp, nd);
|
|
|
|
|
|
|
|
return nd;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_ifdetach(struct nd_ifinfo *nd)
|
2003-10-17 15:46:31 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
free(nd, M_IP6NDP);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reset ND level link MTU. This function is called when the physical MTU
|
|
|
|
* changes, which means we might have to adjust the ND level MTU.
|
|
|
|
*/
|
|
|
|
void
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_setmtu(struct ifnet *ifp)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
2003-10-17 15:46:31 +00:00
|
|
|
|
|
|
|
nd6_setmtu0(ifp, ND_IFINFO(ifp));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX todo: do not maintain copy of ifp->if_mtu in ndi->maxmtu */
|
|
|
|
void
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_setmtu0(struct ifnet *ifp, struct nd_ifinfo *ndi)
|
2003-10-17 15:46:31 +00:00
|
|
|
{
|
2003-10-20 15:27:48 +00:00
|
|
|
u_int32_t omaxmtu;
|
2003-10-17 15:46:31 +00:00
|
|
|
|
2003-10-20 15:27:48 +00:00
|
|
|
omaxmtu = ndi->maxmtu;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
switch (ifp->if_type) {
|
2003-10-20 15:27:48 +00:00
|
|
|
case IFT_ARCNET:
|
|
|
|
ndi->maxmtu = MIN(ARC_PHDS_MAXMTU, ifp->if_mtu); /* RFC2497 */
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
|
|
|
case IFT_FDDI:
|
2003-10-20 15:27:48 +00:00
|
|
|
ndi->maxmtu = MIN(FDDIIPMTU, ifp->if_mtu); /* RFC2467 */
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
2005-10-19 10:09:19 +00:00
|
|
|
case IFT_ISO88025:
|
2003-09-14 02:32:31 +00:00
|
|
|
ndi->maxmtu = MIN(ISO88025_MAX_MTU, ifp->if_mtu);
|
|
|
|
break;
|
2001-06-11 12:39:29 +00:00
|
|
|
default:
|
|
|
|
ndi->maxmtu = ifp->if_mtu;
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
2003-10-20 15:27:48 +00:00
|
|
|
/*
|
|
|
|
* Decreasing the interface MTU under IPV6 minimum MTU may cause
|
|
|
|
* undesirable situation. We thus notify the operator of the change
|
|
|
|
* explicitly. The check for omaxmtu is necessary to restrict the
|
|
|
|
* log to the case of changing the MTU, not initializing it.
|
|
|
|
*/
|
|
|
|
if (omaxmtu >= IPV6_MMTU && ndi->maxmtu < IPV6_MMTU) {
|
|
|
|
log(LOG_NOTICE, "nd6_setmtu0: "
|
|
|
|
"new link MTU on %s (%lu) is too small for IPv6\n",
|
|
|
|
if_name(ifp), (unsigned long)ndi->maxmtu);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2003-10-20 15:27:48 +00:00
|
|
|
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
if (ndi->maxmtu > V_in6_maxmtu)
|
2003-10-20 15:27:48 +00:00
|
|
|
in6_setmaxmtu(); /* check all interfaces just in case */
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_option_init(void *opt, int icmp6len, union nd_opts *ndopts)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
2003-10-09 16:13:47 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
bzero(ndopts, sizeof(*ndopts));
|
|
|
|
ndopts->nd_opts_search = (struct nd_opt_hdr *)opt;
|
|
|
|
ndopts->nd_opts_last
|
|
|
|
= (struct nd_opt_hdr *)(((u_char *)opt) + icmp6len);
|
|
|
|
|
|
|
|
if (icmp6len == 0) {
|
|
|
|
ndopts->nd_opts_done = 1;
|
|
|
|
ndopts->nd_opts_search = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Take one ND option.
|
|
|
|
*/
|
|
|
|
struct nd_opt_hdr *
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_option(union nd_opts *ndopts)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
|
|
|
struct nd_opt_hdr *nd_opt;
|
|
|
|
int olen;
|
|
|
|
|
2005-10-19 10:09:19 +00:00
|
|
|
if (ndopts == NULL)
|
2003-04-29 08:43:56 +00:00
|
|
|
panic("ndopts == NULL in nd6_option");
|
2005-10-19 10:09:19 +00:00
|
|
|
if (ndopts->nd_opts_last == NULL)
|
2003-04-29 08:43:56 +00:00
|
|
|
panic("uninitialized ndopts in nd6_option");
|
2005-10-19 10:09:19 +00:00
|
|
|
if (ndopts->nd_opts_search == NULL)
|
1999-11-22 02:45:11 +00:00
|
|
|
return NULL;
|
|
|
|
if (ndopts->nd_opts_done)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
nd_opt = ndopts->nd_opts_search;
|
|
|
|
|
2001-02-26 03:41:13 +00:00
|
|
|
/* make sure nd_opt_len is inside the buffer */
|
|
|
|
if ((caddr_t)&nd_opt->nd_opt_len >= (caddr_t)ndopts->nd_opts_last) {
|
|
|
|
bzero(ndopts, sizeof(*ndopts));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
olen = nd_opt->nd_opt_len << 3;
|
|
|
|
if (olen == 0) {
|
|
|
|
/*
|
|
|
|
* Message validation requires that all included
|
|
|
|
* options have a length that is greater than zero.
|
|
|
|
*/
|
|
|
|
bzero(ndopts, sizeof(*ndopts));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ndopts->nd_opts_search = (struct nd_opt_hdr *)((caddr_t)nd_opt + olen);
|
2001-02-26 03:41:13 +00:00
|
|
|
if (ndopts->nd_opts_search > ndopts->nd_opts_last) {
|
|
|
|
/* option overruns the end of buffer, invalid */
|
|
|
|
bzero(ndopts, sizeof(*ndopts));
|
|
|
|
return NULL;
|
|
|
|
} else if (ndopts->nd_opts_search == ndopts->nd_opts_last) {
|
|
|
|
/* reached the end of options chain */
|
1999-11-22 02:45:11 +00:00
|
|
|
ndopts->nd_opts_done = 1;
|
|
|
|
ndopts->nd_opts_search = NULL;
|
|
|
|
}
|
|
|
|
return nd_opt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse multiple ND options.
|
|
|
|
* This function is much easier to use, for ND routines that do not need
|
|
|
|
* multiple options of the same type.
|
|
|
|
*/
|
|
|
|
int
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_options(union nd_opts *ndopts)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
|
|
|
struct nd_opt_hdr *nd_opt;
|
|
|
|
int i = 0;
|
|
|
|
|
2005-10-19 10:09:19 +00:00
|
|
|
if (ndopts == NULL)
|
2003-04-29 08:43:56 +00:00
|
|
|
panic("ndopts == NULL in nd6_options");
|
2005-10-19 10:09:19 +00:00
|
|
|
if (ndopts->nd_opts_last == NULL)
|
2003-04-29 08:43:56 +00:00
|
|
|
panic("uninitialized ndopts in nd6_options");
|
2005-10-19 10:09:19 +00:00
|
|
|
if (ndopts->nd_opts_search == NULL)
|
1999-11-22 02:45:11 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
nd_opt = nd6_option(ndopts);
|
2005-10-19 10:09:19 +00:00
|
|
|
if (nd_opt == NULL && ndopts->nd_opts_last == NULL) {
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* Message validation requires that all included
|
|
|
|
* options have a length that is greater than zero.
|
|
|
|
*/
|
2009-04-12 13:22:33 +00:00
|
|
|
ICMP6STAT_INC(icp6s_nd_badopt);
|
1999-11-22 02:45:11 +00:00
|
|
|
bzero(ndopts, sizeof(*ndopts));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-10-19 10:09:19 +00:00
|
|
|
if (nd_opt == NULL)
|
1999-11-22 02:45:11 +00:00
|
|
|
goto skip1;
|
|
|
|
|
|
|
|
switch (nd_opt->nd_opt_type) {
|
|
|
|
case ND_OPT_SOURCE_LINKADDR:
|
|
|
|
case ND_OPT_TARGET_LINKADDR:
|
|
|
|
case ND_OPT_MTU:
|
|
|
|
case ND_OPT_REDIRECTED_HEADER:
|
|
|
|
if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
|
2001-06-11 12:39:29 +00:00
|
|
|
nd6log((LOG_INFO,
|
|
|
|
"duplicated ND6 option found (type=%d)\n",
|
|
|
|
nd_opt->nd_opt_type));
|
1999-11-22 02:45:11 +00:00
|
|
|
/* XXX bark? */
|
|
|
|
} else {
|
|
|
|
ndopts->nd_opt_array[nd_opt->nd_opt_type]
|
|
|
|
= nd_opt;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ND_OPT_PREFIX_INFORMATION:
|
|
|
|
if (ndopts->nd_opt_array[nd_opt->nd_opt_type] == 0) {
|
|
|
|
ndopts->nd_opt_array[nd_opt->nd_opt_type]
|
|
|
|
= nd_opt;
|
|
|
|
}
|
|
|
|
ndopts->nd_opts_pi_end =
|
|
|
|
(struct nd_opt_prefix_info *)nd_opt;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* Unknown options must be silently ignored,
|
|
|
|
* to accomodate future extension to the protocol.
|
|
|
|
*/
|
2001-06-11 12:39:29 +00:00
|
|
|
nd6log((LOG_DEBUG,
|
1999-11-22 02:45:11 +00:00
|
|
|
"nd6_options: unsupported option %d - "
|
2001-06-11 12:39:29 +00:00
|
|
|
"option ignored\n", nd_opt->nd_opt_type));
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
skip1:
|
|
|
|
i++;
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
if (i > V_nd6_maxndopt) {
|
2009-04-12 13:22:33 +00:00
|
|
|
ICMP6STAT_INC(icp6s_nd_toomanyopt);
|
2001-06-11 12:39:29 +00:00
|
|
|
nd6log((LOG_INFO, "too many loop in nd opt\n"));
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ndopts->nd_opts_done)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-10-21 16:23:01 +00:00
|
|
|
* ND6 timer routine to handle ND6 entries
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
void
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
nd6_llinfo_settimer_locked(struct llentry *ln, long tick)
|
2005-10-21 16:23:01 +00:00
|
|
|
{
|
2009-11-12 14:48:36 +00:00
|
|
|
int canceled;
|
|
|
|
|
2010-11-29 00:04:08 +00:00
|
|
|
LLE_WLOCK_ASSERT(ln);
|
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
if (tick < 0) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln->la_expire = 0;
|
2005-10-21 16:23:01 +00:00
|
|
|
ln->ln_ntick = 0;
|
2009-11-12 14:48:36 +00:00
|
|
|
canceled = callout_stop(&ln->ln_timer_ch);
|
2005-10-21 16:23:01 +00:00
|
|
|
} else {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln->la_expire = time_second + tick / hz;
|
|
|
|
LLE_ADDREF(ln);
|
2005-10-21 16:23:01 +00:00
|
|
|
if (tick > INT_MAX) {
|
|
|
|
ln->ln_ntick = tick - INT_MAX;
|
2009-11-12 14:48:36 +00:00
|
|
|
canceled = callout_reset(&ln->ln_timer_ch, INT_MAX,
|
2005-10-21 16:23:01 +00:00
|
|
|
nd6_llinfo_timer, ln);
|
|
|
|
} else {
|
|
|
|
ln->ln_ntick = 0;
|
2009-11-12 14:48:36 +00:00
|
|
|
canceled = callout_reset(&ln->ln_timer_ch, tick,
|
2005-10-21 16:23:01 +00:00
|
|
|
nd6_llinfo_timer, ln);
|
|
|
|
}
|
|
|
|
}
|
2009-11-12 14:48:36 +00:00
|
|
|
if (canceled)
|
|
|
|
LLE_REMREF(ln);
|
2005-10-21 16:23:01 +00:00
|
|
|
}
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
void
|
|
|
|
nd6_llinfo_settimer(struct llentry *ln, long tick)
|
|
|
|
{
|
|
|
|
|
|
|
|
LLE_WLOCK(ln);
|
|
|
|
nd6_llinfo_settimer_locked(ln, tick);
|
|
|
|
LLE_WUNLOCK(ln);
|
|
|
|
}
|
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
static void
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_llinfo_timer(void *arg)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct llentry *ln;
|
2005-10-21 16:23:01 +00:00
|
|
|
struct in6_addr *dst;
|
2001-06-11 12:39:29 +00:00
|
|
|
struct ifnet *ifp;
|
2005-10-21 16:23:01 +00:00
|
|
|
struct nd_ifinfo *ndi = NULL;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2010-07-31 21:33:18 +00:00
|
|
|
KASSERT(arg != NULL, ("%s: arg NULL", __func__));
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln = (struct llentry *)arg;
|
2010-11-29 00:04:08 +00:00
|
|
|
LLE_WLOCK_ASSERT(ln);
|
2010-07-31 21:33:18 +00:00
|
|
|
ifp = ln->lle_tbl->llt_ifp;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
|
|
|
|
CURVNET_SET(ifp->if_vnet);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
if (ln->ln_ntick > 0) {
|
|
|
|
if (ln->ln_ntick > INT_MAX) {
|
|
|
|
ln->ln_ntick -= INT_MAX;
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, INT_MAX);
|
2005-10-21 16:23:01 +00:00
|
|
|
} else {
|
|
|
|
ln->ln_ntick = 0;
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, ln->ln_ntick);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
goto done;
|
2005-10-21 16:23:01 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
ndi = ND_IFINFO(ifp);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
dst = &L3_ADDR_SIN6(ln)->sin6_addr;
|
2009-11-06 17:34:26 +00:00
|
|
|
if (ln->la_flags & LLE_STATIC) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
goto done;
|
|
|
|
}
|
2002-04-19 04:46:24 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (ln->la_flags & LLE_DELETED) {
|
|
|
|
(void)nd6_free(ln, 0);
|
2009-11-06 10:07:38 +00:00
|
|
|
ln = NULL;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
goto done;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
switch (ln->ln_state) {
|
|
|
|
case ND6_LLINFO_INCOMPLETE:
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (ln->la_asked < V_nd6_mmaxtries) {
|
|
|
|
ln->la_asked++;
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, (long)ndi->retrans * hz / 1000);
|
|
|
|
LLE_WUNLOCK(ln);
|
2005-10-21 16:23:01 +00:00
|
|
|
nd6_ns_output(ifp, NULL, dst, ln, 0);
|
2010-11-29 00:04:08 +00:00
|
|
|
LLE_WLOCK(ln);
|
2005-10-21 16:23:01 +00:00
|
|
|
} else {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct mbuf *m = ln->la_hold;
|
2005-10-21 16:23:01 +00:00
|
|
|
if (m) {
|
2006-03-24 16:20:12 +00:00
|
|
|
struct mbuf *m0;
|
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
/*
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
* assuming every packet in la_hold has the
|
2010-11-29 00:04:08 +00:00
|
|
|
* same IP header. Send error after unlock.
|
2005-10-21 16:23:01 +00:00
|
|
|
*/
|
2006-03-24 16:20:12 +00:00
|
|
|
m0 = m->m_nextpkt;
|
|
|
|
m->m_nextpkt = NULL;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln->la_hold = m0;
|
2006-03-24 16:20:12 +00:00
|
|
|
clear_llinfo_pqueue(ln);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
(void)nd6_free(ln, 0);
|
2005-10-21 16:23:01 +00:00
|
|
|
ln = NULL;
|
2010-11-29 00:04:08 +00:00
|
|
|
if (m != NULL)
|
|
|
|
icmp6_error2(m, ICMP6_DST_UNREACH,
|
|
|
|
ICMP6_DST_UNREACH_ADDR, 0, ifp);
|
2005-10-21 16:23:01 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ND6_LLINFO_REACHABLE:
|
|
|
|
if (!ND6_LLINFO_PERMANENT(ln)) {
|
|
|
|
ln->ln_state = ND6_LLINFO_STALE;
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, (long)V_nd6_gctimer * hz);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2005-10-21 16:23:01 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ND6_LLINFO_STALE:
|
|
|
|
/* Garbage Collection(RFC 2461 5.3) */
|
|
|
|
if (!ND6_LLINFO_PERMANENT(ln)) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
(void)nd6_free(ln, 1);
|
2005-10-21 16:23:01 +00:00
|
|
|
ln = NULL;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ND6_LLINFO_DELAY:
|
|
|
|
if (ndi && (ndi->flags & ND6_IFF_PERFORMNUD) != 0) {
|
|
|
|
/* We need NUD */
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln->la_asked = 1;
|
2005-10-21 16:23:01 +00:00
|
|
|
ln->ln_state = ND6_LLINFO_PROBE;
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, (long)ndi->retrans * hz / 1000);
|
|
|
|
LLE_WUNLOCK(ln);
|
2005-10-21 16:23:01 +00:00
|
|
|
nd6_ns_output(ifp, dst, dst, ln, 0);
|
2010-11-29 00:04:08 +00:00
|
|
|
LLE_WLOCK(ln);
|
2005-10-21 16:23:01 +00:00
|
|
|
} else {
|
|
|
|
ln->ln_state = ND6_LLINFO_STALE; /* XXX */
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, (long)V_nd6_gctimer * hz);
|
2005-10-21 16:23:01 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ND6_LLINFO_PROBE:
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (ln->la_asked < V_nd6_umaxtries) {
|
|
|
|
ln->la_asked++;
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, (long)ndi->retrans * hz / 1000);
|
|
|
|
LLE_WUNLOCK(ln);
|
2005-10-21 16:23:01 +00:00
|
|
|
nd6_ns_output(ifp, dst, dst, ln, 0);
|
2010-11-29 00:04:08 +00:00
|
|
|
LLE_WLOCK(ln);
|
2005-10-21 16:23:01 +00:00
|
|
|
} else {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
(void)nd6_free(ln, 0);
|
2005-10-21 16:23:01 +00:00
|
|
|
ln = NULL;
|
|
|
|
}
|
|
|
|
break;
|
2010-11-29 00:04:08 +00:00
|
|
|
default:
|
|
|
|
panic("%s: paths in a dark night can be confusing: %d",
|
|
|
|
__func__, ln->ln_state);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
done:
|
|
|
|
if (ln != NULL)
|
2010-11-29 00:04:08 +00:00
|
|
|
LLE_FREE_LOCKED(ln);
|
2009-11-11 08:28:18 +00:00
|
|
|
CURVNET_RESTORE();
|
2005-10-21 16:23:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ND6 timer routine to expire default route list and prefix list
|
|
|
|
*/
|
|
|
|
void
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
nd6_timer(void *arg)
|
2005-10-21 16:23:01 +00:00
|
|
|
{
|
Change the curvnet variable from a global const struct vnet *,
previously always pointing to the default vnet context, to a
dynamically changing thread-local one. The currvnet context
should be set on entry to networking code via CURVNET_SET() macros,
and reverted to previous state via CURVNET_RESTORE(). Recursions
on curvnet are permitted, though strongly discuouraged.
This change should have no functional impact on nooptions VIMAGE
kernel builds, where CURVNET_* macros expand to whitespace.
The curthread->td_vnet (aka curvnet) variable's purpose is to be an
indicator of the vnet context in which the current network-related
operation takes place, in case we cannot deduce the current vnet
context from any other source, such as by looking at mbuf's
m->m_pkthdr.rcvif->if_vnet, sockets's so->so_vnet etc. Moreover, so
far curvnet has turned out to be an invaluable consistency checking
aid: it helps to catch cases when sockets, ifnets or any other
vnet-aware structures may have leaked from one vnet to another.
The exact placement of the CURVNET_SET() / CURVNET_RESTORE() macros
was a result of an empirical iterative process, whith an aim to
reduce recursions on CURVNET_SET() to a minimum, while still reducing
the scope of CURVNET_SET() to networking only operations - the
alternative would be calling CURVNET_SET() on each system call entry.
In general, curvnet has to be set in three typicall cases: when
processing socket-related requests from userspace or from within the
kernel; when processing inbound traffic flowing from device drivers
to upper layers of the networking stack, and when executing
timer-driven networking functions.
This change also introduces a DDB subcommand to show the list of all
vnet instances.
Approved by: julian (mentor)
2009-05-05 10:56:12 +00:00
|
|
|
CURVNET_SET((struct vnet *) arg);
|
2005-10-21 16:23:01 +00:00
|
|
|
int s;
|
2011-12-29 18:25:18 +00:00
|
|
|
struct nd_defrouter *dr, *ndr;
|
|
|
|
struct nd_prefix *pr, *npr;
|
2005-10-21 16:23:01 +00:00
|
|
|
struct in6_ifaddr *ia6, *nia6;
|
|
|
|
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
callout_reset(&V_nd6_timer_ch, V_nd6_prune * hz,
|
Permit buiding kernels with options VIMAGE, restricted to only a single
active network stack instance. Turning on options VIMAGE at compile
time yields the following changes relative to default kernel build:
1) V_ accessor macros for virtualized variables resolve to structure
fields via base pointers, instead of being resolved as fields in global
structs or plain global variables. As an example, V_ifnet becomes:
options VIMAGE: ((struct vnet_net *) vnet_net)->_ifnet
default build: vnet_net_0._ifnet
options VIMAGE_GLOBALS: ifnet
2) INIT_VNET_* macros will declare and set up base pointers to be used
by V_ accessor macros, instead of resolving to whitespace:
INIT_VNET_NET(ifp->if_vnet); becomes
struct vnet_net *vnet_net = (ifp->if_vnet)->mod_data[VNET_MOD_NET];
3) Memory for vnet modules registered via vnet_mod_register() is now
allocated at run time in sys/kern/kern_vimage.c, instead of per vnet
module structs being declared as globals. If required, vnet modules
can now request the framework to provide them with allocated bzeroed
memory by filling in the vmi_size field in their vmi_modinfo structures.
4) structs socket, ifnet, inpcbinfo, tcpcb and syncache_head are
extended to hold a pointer to the parent vnet. options VIMAGE builds
will fill in those fields as required.
5) curvnet is introduced as a new global variable in options VIMAGE
builds, always pointing to the default and only struct vnet.
6) struct sysctl_oid has been extended with additional two fields to
store major and minor virtualization module identifiers, oid_v_subs and
oid_v_mod. SYSCTL_V_* family of macros will fill in those fields
accordingly, and store the offset in the appropriate vnet container
struct in oid_arg1.
In sysctl handlers dealing with virtualized sysctls, the
SYSCTL_RESOLVE_V_ARG1() macro will compute the address of the target
variable and make it available in arg1 variable for further processing.
Unused fields in structs vnet_inet, vnet_inet6 and vnet_ipfw have
been deleted.
Reviewed by: bz, rwatson
Approved by: julian (mentor)
2009-04-30 13:36:26 +00:00
|
|
|
nd6_timer, curvnet);
|
2003-10-09 16:13:47 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
/* expire default router list */
|
2005-10-21 16:23:01 +00:00
|
|
|
s = splnet();
|
2011-12-29 18:25:18 +00:00
|
|
|
TAILQ_FOREACH_SAFE(dr, &V_nd_defrouter, dr_entry, ndr) {
|
|
|
|
if (dr->expire && dr->expire < time_second)
|
1999-11-22 02:45:11 +00:00
|
|
|
defrtrlist_del(dr);
|
|
|
|
}
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* expire interface addresses.
|
|
|
|
* in the past the loop was inside prefix expiry processing.
|
|
|
|
* However, from a stricter speci-confrmance standpoint, we should
|
|
|
|
* rather separate address lifetimes and prefix lifetimes.
|
2009-06-25 16:35:28 +00:00
|
|
|
*
|
|
|
|
* XXXRW: in6_ifaddrhead locking.
|
2001-06-11 12:39:29 +00:00
|
|
|
*/
|
|
|
|
addrloop:
|
2009-06-24 21:00:25 +00:00
|
|
|
TAILQ_FOREACH_SAFE(ia6, &V_in6_ifaddrhead, ia_link, nia6) {
|
2001-06-11 12:39:29 +00:00
|
|
|
/* check address lifetime */
|
|
|
|
if (IFA6_IS_INVALID(ia6)) {
|
|
|
|
int regen = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the expiring address is temporary, try
|
|
|
|
* regenerating a new one. This would be useful when
|
2002-04-19 04:46:24 +00:00
|
|
|
* we suspended a laptop PC, then turned it on after a
|
2001-06-11 12:39:29 +00:00
|
|
|
* period that could invalidate all temporary
|
|
|
|
* addresses. Although we may have to restart the
|
|
|
|
* loop (see below), it must be after purging the
|
|
|
|
* address. Otherwise, we'd see an infinite loop of
|
2003-10-09 16:13:47 +00:00
|
|
|
* regeneration.
|
2001-06-11 12:39:29 +00:00
|
|
|
*/
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
if (V_ip6_use_tempaddr &&
|
2001-06-11 12:39:29 +00:00
|
|
|
(ia6->ia6_flags & IN6_IFF_TEMPORARY) != 0) {
|
|
|
|
if (regen_tmpaddr(ia6) == 0)
|
|
|
|
regen = 1;
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
in6_purgeaddr(&ia6->ia_ifa);
|
|
|
|
|
|
|
|
if (regen)
|
|
|
|
goto addrloop; /* XXX: see below */
|
2006-02-12 15:37:08 +00:00
|
|
|
} else if (IFA6_IS_DEPRECATED(ia6)) {
|
2001-06-11 12:39:29 +00:00
|
|
|
int oldflags = ia6->ia6_flags;
|
|
|
|
|
|
|
|
ia6->ia6_flags |= IN6_IFF_DEPRECATED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a temporary address has just become deprecated,
|
|
|
|
* regenerate a new one if possible.
|
|
|
|
*/
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
if (V_ip6_use_tempaddr &&
|
2001-06-11 12:39:29 +00:00
|
|
|
(ia6->ia6_flags & IN6_IFF_TEMPORARY) != 0 &&
|
|
|
|
(oldflags & IN6_IFF_DEPRECATED) == 0) {
|
|
|
|
|
|
|
|
if (regen_tmpaddr(ia6) == 0) {
|
|
|
|
/*
|
|
|
|
* A new temporary address is
|
|
|
|
* generated.
|
|
|
|
* XXX: this means the address chain
|
|
|
|
* has changed while we are still in
|
|
|
|
* the loop. Although the change
|
|
|
|
* would not cause disaster (because
|
2002-04-19 04:46:24 +00:00
|
|
|
* it's not a deletion, but an
|
|
|
|
* addition,) we'd rather restart the
|
2003-10-09 16:13:47 +00:00
|
|
|
* loop just for safety. Or does this
|
2001-06-11 12:39:29 +00:00
|
|
|
* significantly reduce performance??
|
|
|
|
*/
|
|
|
|
goto addrloop;
|
|
|
|
}
|
|
|
|
}
|
2002-04-24 19:09:48 +00:00
|
|
|
} else {
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* A new RA might have made a deprecated address
|
|
|
|
* preferred.
|
|
|
|
*/
|
|
|
|
ia6->ia6_flags &= ~IN6_IFF_DEPRECATED;
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
/* expire prefix list */
|
2011-12-29 18:25:18 +00:00
|
|
|
LIST_FOREACH_SAFE(pr, &V_nd_prefix, ndpr_entry, npr) {
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* check prefix lifetime.
|
|
|
|
* since pltime is just for autoconf, pltime processing for
|
|
|
|
* prefix is not necessary.
|
|
|
|
*/
|
2005-10-21 16:23:01 +00:00
|
|
|
if (pr->ndpr_vltime != ND6_INFINITE_LIFETIME &&
|
|
|
|
time_second - pr->ndpr_lastupdate > pr->ndpr_vltime) {
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* address expiration and prefix expiration are
|
2001-06-11 12:39:29 +00:00
|
|
|
* separate. NEVER perform in6_purgeaddr here.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
prelist_remove(pr);
|
2011-12-29 18:25:18 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
splx(s);
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
CURVNET_RESTORE();
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
2007-07-05 16:23:49 +00:00
|
|
|
/*
|
|
|
|
* ia6 - deprecated/invalidated temporary address
|
|
|
|
*/
|
2001-06-11 12:39:29 +00:00
|
|
|
static int
|
2007-07-05 16:23:49 +00:00
|
|
|
regen_tmpaddr(struct in6_ifaddr *ia6)
|
2001-06-11 12:39:29 +00:00
|
|
|
{
|
|
|
|
struct ifaddr *ifa;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct in6_ifaddr *public_ifa6 = NULL;
|
|
|
|
|
|
|
|
ifp = ia6->ia_ifa.ifa_ifp;
|
2012-01-05 19:00:36 +00:00
|
|
|
IF_ADDR_RLOCK(ifp);
|
2009-04-20 22:45:21 +00:00
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
|
2001-06-11 12:39:29 +00:00
|
|
|
struct in6_ifaddr *it6;
|
|
|
|
|
|
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
it6 = (struct in6_ifaddr *)ifa;
|
|
|
|
|
|
|
|
/* ignore no autoconf addresses. */
|
|
|
|
if ((it6->ia6_flags & IN6_IFF_AUTOCONF) == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* ignore autoconf addresses with different prefixes. */
|
|
|
|
if (it6->ia6_ndpr == NULL || it6->ia6_ndpr != ia6->ia6_ndpr)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now we are looking at an autoconf address with the same
|
|
|
|
* prefix as ours. If the address is temporary and is still
|
|
|
|
* preferred, do not create another one. It would be rare, but
|
|
|
|
* could happen, for example, when we resume a laptop PC after
|
|
|
|
* a long period.
|
|
|
|
*/
|
|
|
|
if ((it6->ia6_flags & IN6_IFF_TEMPORARY) != 0 &&
|
|
|
|
!IFA6_IS_DEPRECATED(it6)) {
|
|
|
|
public_ifa6 = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is a public autoconf address that has the same prefix
|
|
|
|
* as ours. If it is preferred, keep it. We can't break the
|
|
|
|
* loop here, because there may be a still-preferred temporary
|
|
|
|
* address with the prefix.
|
|
|
|
*/
|
|
|
|
if (!IFA6_IS_DEPRECATED(it6))
|
|
|
|
public_ifa6 = it6;
|
2010-02-27 07:12:25 +00:00
|
|
|
|
|
|
|
if (public_ifa6 != NULL)
|
|
|
|
ifa_ref(&public_ifa6->ia_ifa);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
2012-01-05 19:00:36 +00:00
|
|
|
IF_ADDR_RUNLOCK(ifp);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
if (public_ifa6 != NULL) {
|
|
|
|
int e;
|
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
if ((e = in6_tmpifadd(public_ifa6, 0, 0)) != 0) {
|
2010-02-27 07:12:25 +00:00
|
|
|
ifa_free(&public_ifa6->ia_ifa);
|
2001-06-11 12:39:29 +00:00
|
|
|
log(LOG_NOTICE, "regen_tmpaddr: failed to create a new"
|
|
|
|
" tmp addr,errno=%d\n", e);
|
2003-10-06 14:02:09 +00:00
|
|
|
return (-1);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
2010-02-27 07:12:25 +00:00
|
|
|
ifa_free(&public_ifa6->ia_ifa);
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
|
2003-10-06 14:02:09 +00:00
|
|
|
return (-1);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
/*
|
|
|
|
* Nuke neighbor cache/prefix/default router management table, right before
|
|
|
|
* ifp goes away.
|
|
|
|
*/
|
|
|
|
void
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_purge(struct ifnet *ifp)
|
2000-07-04 16:35:15 +00:00
|
|
|
{
|
2005-10-21 16:23:01 +00:00
|
|
|
struct nd_defrouter *dr, *ndr;
|
2000-07-04 16:35:15 +00:00
|
|
|
struct nd_prefix *pr, *npr;
|
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
/*
|
|
|
|
* Nuke default router list entries toward ifp.
|
|
|
|
* We defer removal of default router list entries that is installed
|
|
|
|
* in the routing table, in order to keep additional side effects as
|
|
|
|
* small as possible.
|
|
|
|
*/
|
2011-12-29 18:25:18 +00:00
|
|
|
TAILQ_FOREACH_SAFE(dr, &V_nd_defrouter, dr_entry, ndr) {
|
2005-10-21 16:23:01 +00:00
|
|
|
if (dr->installed)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (dr->ifp == ifp)
|
|
|
|
defrtrlist_del(dr);
|
|
|
|
}
|
|
|
|
|
2011-12-29 18:25:18 +00:00
|
|
|
TAILQ_FOREACH_SAFE(dr, &V_nd_defrouter, dr_entry, ndr) {
|
2005-10-21 16:23:01 +00:00
|
|
|
if (!dr->installed)
|
|
|
|
continue;
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
if (dr->ifp == ifp)
|
|
|
|
defrtrlist_del(dr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Nuke prefix list entries toward ifp */
|
2011-12-29 18:25:18 +00:00
|
|
|
LIST_FOREACH_SAFE(pr, &V_nd_prefix, ndpr_entry, npr) {
|
2000-07-04 16:35:15 +00:00
|
|
|
if (pr->ndpr_ifp == ifp) {
|
2005-10-21 16:23:01 +00:00
|
|
|
/*
|
|
|
|
* Because if_detach() does *not* release prefixes
|
|
|
|
* while purging addresses the reference count will
|
|
|
|
* still be above zero. We therefore reset it to
|
|
|
|
* make sure that the prefix really gets purged.
|
|
|
|
*/
|
|
|
|
pr->ndpr_refcnt = 0;
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* Previously, pr->ndpr_addr is removed as well,
|
|
|
|
* but I strongly believe we don't have to do it.
|
|
|
|
* nd6_purge() is only called from in6_ifdetach(),
|
|
|
|
* which removes all the associated interface addresses
|
|
|
|
* by itself.
|
|
|
|
* (jinmei@kame.net 20010129)
|
|
|
|
*/
|
2000-07-04 16:35:15 +00:00
|
|
|
prelist_remove(pr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* cancel default outgoing interface setting */
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
if (V_nd6_defifindex == ifp->if_index)
|
2000-07-04 16:35:15 +00:00
|
|
|
nd6_setdefaultiface(0);
|
|
|
|
|
- Accept Router Advertisement messages even when net.inet6.ip6.forwarding=1.
- A new per-interface knob IFF_ND6_NO_RADR and sysctl IPV6CTL_NO_RADR.
This controls if accepting a route in an RA message as the default route.
The default value for each interface can be set by net.inet6.ip6.no_radr.
The system wide default value is 0.
- A new sysctl: net.inet6.ip6.norbit_raif. This controls if setting R-bit in
NA on RA accepting interfaces. The default is 0 (R-bit is set based on
net.inet6.ip6.forwarding).
Background:
IPv6 host/router model suggests a router sends an RA and a host accepts it for
router discovery. Because of that, KAME implementation does not allow
accepting RAs when net.inet6.ip6.forwarding=1. Accepting RAs on a router can
make the routing table confused since it can change the default router
unintentionally.
However, in practice there are cases where we cannot distinguish a host from
a router clearly. For example, a customer edge router often works as a host
against the ISP, and as a router against the LAN at the same time. Another
example is a complex network configurations like an L2TP tunnel for IPv6
connection to Internet over an Ethernet link with another native IPv6 subnet.
In this case, the physical interface for the native IPv6 subnet works as a
host, and the pseudo-interface for L2TP works as the default IP forwarding
route.
Problem:
Disabling processing RA messages when net.inet6.ip6.forwarding=1 and
accepting them when net.inet6.ip6.forward=0 cause the following practical
issues:
- A router cannot perform SLAAC. It becomes a problem if a box has
multiple interfaces and you want to use SLAAC on some of them, for
example. A customer edge router for IPv6 Internet access service
using an IPv6-over-IPv6 tunnel sometimes needs SLAAC on the
physical interface for administration purpose; updating firmware
and so on (link-local addresses can be used there, but GUAs by
SLAAC are often used for scalability).
- When a host has multiple IPv6 interfaces and it receives multiple RAs on
them, controlling the default route is difficult. Router preferences
defined in RFC 4191 works only when the routers on the links are
under your control.
Details of Implementation Changes:
Router Advertisement messages will be accepted even when
net.inet6.ip6.forwarding=1. More precisely, the conditions are as
follow:
(ACCEPT_RTADV && !NO_RADR && !ip6.forwarding)
=> Normal RA processing on that interface. (as IPv6 host)
(ACCEPT_RTADV && (NO_RADR || ip6.forwarding))
=> Accept RA but add the router to the defroute list with
rtlifetime=0 unconditionally. This effectively prevents
from setting the received router address as the box's
default route.
(!ACCEPT_RTADV)
=> No RA processing on that interface.
ACCEPT_RTADV and NO_RADR are per-interface knob. In short, all interface
are classified as "RA-accepting" or not. An RA-accepting interface always
processes RA messages regardless of ip6.forwarding. The difference caused by
NO_RADR or ip6.forwarding is whether the RA source address is considered as
the default router or not.
R-bit in NA on the RA accepting interfaces is set based on
net.inet6.ip6.forwarding. While RFC 6204 W-1 rule (for CPE case) suggests
a router should disable the R-bit completely even when the box has
net.inet6.ip6.forwarding=1, I believe there is no technical reason with
doing so. This behavior can be set by a new sysctl net.inet6.ip6.norbit_raif
(the default is 0).
Usage:
# ifconfig fxp0 inet6 accept_rtadv
=> accept RA on fxp0
# ifconfig fxp0 inet6 accept_rtadv no_radr
=> accept RA on fxp0 but ignore default route information in it.
# sysctl net.inet6.ip6.norbit_no_radr=1
=> R-bit in NAs on RA accepting interfaces will always be set to 0.
2011-06-06 02:14:23 +00:00
|
|
|
if (ND_IFINFO(ifp)->flags & ND6_IFF_ACCEPT_RTADV) {
|
2009-09-12 22:08:20 +00:00
|
|
|
/* Refresh default router list. */
|
2001-06-27 17:56:17 +00:00
|
|
|
defrouter_select();
|
|
|
|
}
|
2000-07-04 16:35:15 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
/* XXXXX
|
|
|
|
* We do not nuke the neighbor cache entries here any more
|
|
|
|
* because the neighbor cache is kept in if_afdata[AF_INET6].
|
|
|
|
* nd6_purge() is invoked by in6_ifdetach() which is called
|
|
|
|
* from if_detach() where everything gets purged. So let
|
|
|
|
* in6_domifdetach() do the actual L2 table purging work.
|
2000-07-04 16:35:15 +00:00
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
/*
|
|
|
|
* the caller acquires and releases the lock on the lltbls
|
|
|
|
* Returns the llentry locked
|
|
|
|
*/
|
|
|
|
struct llentry *
|
|
|
|
nd6_lookup(struct in6_addr *addr6, int flags, struct ifnet *ifp)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
|
|
|
struct sockaddr_in6 sin6;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct llentry *ln;
|
2010-11-17 10:43:20 +00:00
|
|
|
int llflags;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
bzero(&sin6, sizeof(sin6));
|
|
|
|
sin6.sin6_len = sizeof(struct sockaddr_in6);
|
|
|
|
sin6.sin6_family = AF_INET6;
|
|
|
|
sin6.sin6_addr = *addr6;
|
2000-07-04 16:35:15 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
IF_AFDATA_LOCK_ASSERT(ifp);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2010-11-17 10:43:20 +00:00
|
|
|
llflags = 0;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (flags & ND6_CREATE)
|
|
|
|
llflags |= LLE_CREATE;
|
|
|
|
if (flags & ND6_EXCLUSIVE)
|
|
|
|
llflags |= LLE_EXCLUSIVE;
|
|
|
|
|
|
|
|
ln = lla_lookup(LLTABLE6(ifp), llflags, (struct sockaddr *)&sin6);
|
2010-11-17 10:43:20 +00:00
|
|
|
if ((ln != NULL) && (llflags & LLE_CREATE))
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln->ln_state = ND6_LLINFO_NOSTATE;
|
|
|
|
|
|
|
|
return (ln);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2004-10-03 00:49:33 +00:00
|
|
|
* Test whether a given IPv6 address is a neighbor or not, ignoring
|
|
|
|
* the actual neighbor cache. The neighbor cache is ignored in order
|
|
|
|
* to not reenter the routing code from within itself.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
2004-10-03 00:49:33 +00:00
|
|
|
static int
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_is_new_addr_neighbor(struct sockaddr_in6 *addr, struct ifnet *ifp)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
2003-12-08 11:59:21 +00:00
|
|
|
struct nd_prefix *pr;
|
2005-10-21 16:23:01 +00:00
|
|
|
struct ifaddr *dstaddr;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
/*
|
|
|
|
* A link-local address is always a neighbor.
|
2003-12-08 11:59:21 +00:00
|
|
|
* XXX: a link does not necessarily specify a single interface.
|
2000-07-04 16:35:15 +00:00
|
|
|
*/
|
2005-07-25 12:31:43 +00:00
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {
|
|
|
|
struct sockaddr_in6 sin6_copy;
|
|
|
|
u_int32_t zone;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need sin6_copy since sa6_recoverscope() may modify the
|
|
|
|
* content (XXX).
|
|
|
|
*/
|
|
|
|
sin6_copy = *addr;
|
|
|
|
if (sa6_recoverscope(&sin6_copy))
|
|
|
|
return (0); /* XXX: should be impossible */
|
|
|
|
if (in6_setscope(&sin6_copy.sin6_addr, ifp, &zone))
|
|
|
|
return (0);
|
|
|
|
if (sin6_copy.sin6_scope_id == zone)
|
|
|
|
return (1);
|
|
|
|
else
|
|
|
|
return (0);
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the address matches one of our addresses,
|
|
|
|
* it should be a neighbor.
|
2003-12-08 11:59:21 +00:00
|
|
|
* If the address matches one of our on-link prefixes, it should be a
|
|
|
|
* neighbor.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
2011-12-29 18:25:18 +00:00
|
|
|
LIST_FOREACH(pr, &V_nd_prefix, ndpr_entry) {
|
2003-12-08 11:59:21 +00:00
|
|
|
if (pr->ndpr_ifp != ifp)
|
|
|
|
continue;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2009-12-30 21:51:23 +00:00
|
|
|
if (!(pr->ndpr_stateflags & NDPRF_ONLINK)) {
|
|
|
|
struct rtentry *rt;
|
2012-02-03 13:08:44 +00:00
|
|
|
|
|
|
|
/* Always use the default FIB here. */
|
|
|
|
rt = in6_rtalloc1((struct sockaddr *)&pr->ndpr_prefix,
|
|
|
|
0, 0, RT_DEFAULT_FIB);
|
2009-12-30 21:51:23 +00:00
|
|
|
if (rt == NULL)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* This is the case where multiple interfaces
|
|
|
|
* have the same prefix, but only one is installed
|
|
|
|
* into the routing table and that prefix entry
|
|
|
|
* is not the one being examined here. In the case
|
|
|
|
* where RADIX_MPATH is enabled, multiple route
|
|
|
|
* entries (of the same rt_key value) will be
|
|
|
|
* installed because the interface addresses all
|
|
|
|
* differ.
|
|
|
|
*/
|
|
|
|
if (!IN6_ARE_ADDR_EQUAL(&pr->ndpr_prefix.sin6_addr,
|
|
|
|
&((struct sockaddr_in6 *)rt_key(rt))->sin6_addr)) {
|
|
|
|
RTFREE_LOCKED(rt);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
RTFREE_LOCKED(rt);
|
|
|
|
}
|
2003-12-08 11:59:21 +00:00
|
|
|
|
|
|
|
if (IN6_ARE_MASKED_ADDR_EQUAL(&pr->ndpr_prefix.sin6_addr,
|
|
|
|
&addr->sin6_addr, &pr->ndpr_mask))
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
/*
|
|
|
|
* If the address is assigned on the node of the other side of
|
|
|
|
* a p2p interface, the address should be a neighbor.
|
|
|
|
*/
|
|
|
|
dstaddr = ifa_ifwithdstaddr((struct sockaddr *)addr);
|
2009-06-23 20:19:09 +00:00
|
|
|
if (dstaddr != NULL) {
|
|
|
|
if (dstaddr->ifa_ifp == ifp) {
|
|
|
|
ifa_free(dstaddr);
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
ifa_free(dstaddr);
|
|
|
|
}
|
2005-10-21 16:23:01 +00:00
|
|
|
|
2003-12-08 11:59:21 +00:00
|
|
|
/*
|
|
|
|
* If the default router list is empty, all addresses are regarded
|
|
|
|
* as on-link, and thus, as a neighbor.
|
|
|
|
*/
|
- Accept Router Advertisement messages even when net.inet6.ip6.forwarding=1.
- A new per-interface knob IFF_ND6_NO_RADR and sysctl IPV6CTL_NO_RADR.
This controls if accepting a route in an RA message as the default route.
The default value for each interface can be set by net.inet6.ip6.no_radr.
The system wide default value is 0.
- A new sysctl: net.inet6.ip6.norbit_raif. This controls if setting R-bit in
NA on RA accepting interfaces. The default is 0 (R-bit is set based on
net.inet6.ip6.forwarding).
Background:
IPv6 host/router model suggests a router sends an RA and a host accepts it for
router discovery. Because of that, KAME implementation does not allow
accepting RAs when net.inet6.ip6.forwarding=1. Accepting RAs on a router can
make the routing table confused since it can change the default router
unintentionally.
However, in practice there are cases where we cannot distinguish a host from
a router clearly. For example, a customer edge router often works as a host
against the ISP, and as a router against the LAN at the same time. Another
example is a complex network configurations like an L2TP tunnel for IPv6
connection to Internet over an Ethernet link with another native IPv6 subnet.
In this case, the physical interface for the native IPv6 subnet works as a
host, and the pseudo-interface for L2TP works as the default IP forwarding
route.
Problem:
Disabling processing RA messages when net.inet6.ip6.forwarding=1 and
accepting them when net.inet6.ip6.forward=0 cause the following practical
issues:
- A router cannot perform SLAAC. It becomes a problem if a box has
multiple interfaces and you want to use SLAAC on some of them, for
example. A customer edge router for IPv6 Internet access service
using an IPv6-over-IPv6 tunnel sometimes needs SLAAC on the
physical interface for administration purpose; updating firmware
and so on (link-local addresses can be used there, but GUAs by
SLAAC are often used for scalability).
- When a host has multiple IPv6 interfaces and it receives multiple RAs on
them, controlling the default route is difficult. Router preferences
defined in RFC 4191 works only when the routers on the links are
under your control.
Details of Implementation Changes:
Router Advertisement messages will be accepted even when
net.inet6.ip6.forwarding=1. More precisely, the conditions are as
follow:
(ACCEPT_RTADV && !NO_RADR && !ip6.forwarding)
=> Normal RA processing on that interface. (as IPv6 host)
(ACCEPT_RTADV && (NO_RADR || ip6.forwarding))
=> Accept RA but add the router to the defroute list with
rtlifetime=0 unconditionally. This effectively prevents
from setting the received router address as the box's
default route.
(!ACCEPT_RTADV)
=> No RA processing on that interface.
ACCEPT_RTADV and NO_RADR are per-interface knob. In short, all interface
are classified as "RA-accepting" or not. An RA-accepting interface always
processes RA messages regardless of ip6.forwarding. The difference caused by
NO_RADR or ip6.forwarding is whether the RA source address is considered as
the default router or not.
R-bit in NA on the RA accepting interfaces is set based on
net.inet6.ip6.forwarding. While RFC 6204 W-1 rule (for CPE case) suggests
a router should disable the R-bit completely even when the box has
net.inet6.ip6.forwarding=1, I believe there is no technical reason with
doing so. This behavior can be set by a new sysctl net.inet6.ip6.norbit_raif
(the default is 0).
Usage:
# ifconfig fxp0 inet6 accept_rtadv
=> accept RA on fxp0
# ifconfig fxp0 inet6 accept_rtadv no_radr
=> accept RA on fxp0 but ignore default route information in it.
# sysctl net.inet6.ip6.norbit_no_radr=1
=> R-bit in NAs on RA accepting interfaces will always be set to 0.
2011-06-06 02:14:23 +00:00
|
|
|
if (ND_IFINFO(ifp)->flags & ND6_IFF_ACCEPT_RTADV &&
|
2011-12-29 18:25:18 +00:00
|
|
|
TAILQ_EMPTY(&V_nd_defrouter) &&
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
V_nd6_defifindex == ifp->if_index) {
|
2003-10-06 14:02:09 +00:00
|
|
|
return (1);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
2004-10-03 00:49:33 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Detect if a given IPv6 address identifies a neighbor on a given link.
|
|
|
|
* XXX: should take care of the destination of a p2p link?
|
|
|
|
*/
|
|
|
|
int
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_is_addr_neighbor(struct sockaddr_in6 *addr, struct ifnet *ifp)
|
2004-10-03 00:49:33 +00:00
|
|
|
{
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct llentry *lle;
|
|
|
|
int rc = 0;
|
2004-10-03 00:49:33 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
IF_AFDATA_UNLOCK_ASSERT(ifp);
|
2004-10-03 00:49:33 +00:00
|
|
|
if (nd6_is_new_addr_neighbor(addr, ifp))
|
|
|
|
return (1);
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* Even if the address matches none of our addresses, it might be
|
|
|
|
* in the neighbor cache.
|
|
|
|
*/
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
IF_AFDATA_LOCK(ifp);
|
|
|
|
if ((lle = nd6_lookup(&addr->sin6_addr, 0, ifp)) != NULL) {
|
|
|
|
LLE_RUNLOCK(lle);
|
|
|
|
rc = 1;
|
|
|
|
}
|
|
|
|
IF_AFDATA_UNLOCK(ifp);
|
|
|
|
return (rc);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free an nd6 llinfo entry.
|
2005-10-21 16:23:01 +00:00
|
|
|
* Since the function would cause significant changes in the kernel, DO NOT
|
|
|
|
* make it global, unless you have a strong reason for the change, and are sure
|
|
|
|
* that the change is safe.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
static struct llentry *
|
|
|
|
nd6_free(struct llentry *ln, int gc)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct llentry *next;
|
2000-07-04 16:35:15 +00:00
|
|
|
struct nd_defrouter *dr;
|
2010-11-29 00:04:08 +00:00
|
|
|
struct ifnet *ifp;
|
|
|
|
|
|
|
|
LLE_WLOCK_ASSERT(ln);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
/*
|
2003-10-09 16:13:47 +00:00
|
|
|
* we used to have pfctlinput(PRC_HOSTDEAD) here.
|
2001-06-11 12:39:29 +00:00
|
|
|
* even though it is not harmful, it was not really necessary.
|
2000-07-04 16:35:15 +00:00
|
|
|
*/
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
/* cancel timer */
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, -1);
|
|
|
|
|
|
|
|
ifp = ln->lle_tbl->llt_ifp;
|
2005-10-21 16:23:01 +00:00
|
|
|
|
- Accept Router Advertisement messages even when net.inet6.ip6.forwarding=1.
- A new per-interface knob IFF_ND6_NO_RADR and sysctl IPV6CTL_NO_RADR.
This controls if accepting a route in an RA message as the default route.
The default value for each interface can be set by net.inet6.ip6.no_radr.
The system wide default value is 0.
- A new sysctl: net.inet6.ip6.norbit_raif. This controls if setting R-bit in
NA on RA accepting interfaces. The default is 0 (R-bit is set based on
net.inet6.ip6.forwarding).
Background:
IPv6 host/router model suggests a router sends an RA and a host accepts it for
router discovery. Because of that, KAME implementation does not allow
accepting RAs when net.inet6.ip6.forwarding=1. Accepting RAs on a router can
make the routing table confused since it can change the default router
unintentionally.
However, in practice there are cases where we cannot distinguish a host from
a router clearly. For example, a customer edge router often works as a host
against the ISP, and as a router against the LAN at the same time. Another
example is a complex network configurations like an L2TP tunnel for IPv6
connection to Internet over an Ethernet link with another native IPv6 subnet.
In this case, the physical interface for the native IPv6 subnet works as a
host, and the pseudo-interface for L2TP works as the default IP forwarding
route.
Problem:
Disabling processing RA messages when net.inet6.ip6.forwarding=1 and
accepting them when net.inet6.ip6.forward=0 cause the following practical
issues:
- A router cannot perform SLAAC. It becomes a problem if a box has
multiple interfaces and you want to use SLAAC on some of them, for
example. A customer edge router for IPv6 Internet access service
using an IPv6-over-IPv6 tunnel sometimes needs SLAAC on the
physical interface for administration purpose; updating firmware
and so on (link-local addresses can be used there, but GUAs by
SLAAC are often used for scalability).
- When a host has multiple IPv6 interfaces and it receives multiple RAs on
them, controlling the default route is difficult. Router preferences
defined in RFC 4191 works only when the routers on the links are
under your control.
Details of Implementation Changes:
Router Advertisement messages will be accepted even when
net.inet6.ip6.forwarding=1. More precisely, the conditions are as
follow:
(ACCEPT_RTADV && !NO_RADR && !ip6.forwarding)
=> Normal RA processing on that interface. (as IPv6 host)
(ACCEPT_RTADV && (NO_RADR || ip6.forwarding))
=> Accept RA but add the router to the defroute list with
rtlifetime=0 unconditionally. This effectively prevents
from setting the received router address as the box's
default route.
(!ACCEPT_RTADV)
=> No RA processing on that interface.
ACCEPT_RTADV and NO_RADR are per-interface knob. In short, all interface
are classified as "RA-accepting" or not. An RA-accepting interface always
processes RA messages regardless of ip6.forwarding. The difference caused by
NO_RADR or ip6.forwarding is whether the RA source address is considered as
the default router or not.
R-bit in NA on the RA accepting interfaces is set based on
net.inet6.ip6.forwarding. While RFC 6204 W-1 rule (for CPE case) suggests
a router should disable the R-bit completely even when the box has
net.inet6.ip6.forwarding=1, I believe there is no technical reason with
doing so. This behavior can be set by a new sysctl net.inet6.ip6.norbit_raif
(the default is 0).
Usage:
# ifconfig fxp0 inet6 accept_rtadv
=> accept RA on fxp0
# ifconfig fxp0 inet6 accept_rtadv no_radr
=> accept RA on fxp0 but ignore default route information in it.
# sysctl net.inet6.ip6.norbit_no_radr=1
=> R-bit in NAs on RA accepting interfaces will always be set to 0.
2011-06-06 02:14:23 +00:00
|
|
|
if (ND_IFINFO(ifp)->flags & ND6_IFF_ACCEPT_RTADV) {
|
2010-11-29 00:04:08 +00:00
|
|
|
dr = defrouter_lookup(&L3_ADDR_SIN6(ln)->sin6_addr, ifp);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
if (dr != NULL && dr->expire &&
|
|
|
|
ln->ln_state == ND6_LLINFO_STALE && gc) {
|
|
|
|
/*
|
|
|
|
* If the reason for the deletion is just garbage
|
|
|
|
* collection, and the neighbor is an active default
|
|
|
|
* router, do not delete it. Instead, reset the GC
|
|
|
|
* timer using the router's lifetime.
|
|
|
|
* Simply deleting the entry would affect default
|
|
|
|
* router selection, which is not necessarily a good
|
|
|
|
* thing, especially when we're using router preference
|
|
|
|
* values.
|
|
|
|
* XXX: the check for ln_state would be redundant,
|
|
|
|
* but we intentionally keep it just in case.
|
|
|
|
*/
|
|
|
|
if (dr->expire > time_second)
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln,
|
2005-10-21 16:23:01 +00:00
|
|
|
(dr->expire - time_second) * hz);
|
|
|
|
else
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln,
|
|
|
|
(long)V_nd6_gctimer * hz);
|
|
|
|
|
|
|
|
next = LIST_NEXT(ln, lle_next);
|
2009-11-12 14:48:36 +00:00
|
|
|
LLE_REMREF(ln);
|
|
|
|
LLE_WUNLOCK(ln);
|
2010-11-29 00:04:08 +00:00
|
|
|
return (next);
|
2005-10-21 16:23:01 +00:00
|
|
|
}
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
if (dr) {
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
2000-07-04 16:35:15 +00:00
|
|
|
* Unreachablity of a router might affect the default
|
|
|
|
* router selection and on-link detection of advertised
|
|
|
|
* prefixes.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
2000-07-04 16:35:15 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Temporarily fake the state to choose a new default
|
|
|
|
* router and to perform on-link determination of
|
2002-04-19 04:46:24 +00:00
|
|
|
* prefixes correctly.
|
2000-07-04 16:35:15 +00:00
|
|
|
* Below the state will be set correctly,
|
|
|
|
* or the entry itself will be deleted.
|
|
|
|
*/
|
|
|
|
ln->ln_state = ND6_LLINFO_INCOMPLETE;
|
2010-12-07 22:43:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ln->ln_router || dr) {
|
2000-07-04 16:35:15 +00:00
|
|
|
|
2010-12-07 22:43:29 +00:00
|
|
|
/*
|
|
|
|
* We need to unlock to avoid a LOR with rt6_flush() with the
|
|
|
|
* rnh and for the calls to pfxlist_onlink_check() and
|
|
|
|
* defrouter_select() in the block further down for calls
|
|
|
|
* into nd6_lookup(). We still hold a ref.
|
|
|
|
*/
|
|
|
|
LLE_WUNLOCK(ln);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rt6_flush must be called whether or not the neighbor
|
|
|
|
* is in the Default Router List.
|
|
|
|
* See a corresponding comment in nd6_na_input().
|
|
|
|
*/
|
|
|
|
rt6_flush(&L3_ADDR_SIN6(ln)->sin6_addr, ifp);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dr) {
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* Since defrouter_select() does not affect the
|
|
|
|
* on-link determination and MIP6 needs the check
|
|
|
|
* before the default router selection, we perform
|
|
|
|
* the check now.
|
|
|
|
*/
|
|
|
|
pfxlist_onlink_check();
|
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
/*
|
2010-12-07 22:43:29 +00:00
|
|
|
* Refresh default router list.
|
2005-10-21 16:23:01 +00:00
|
|
|
*/
|
|
|
|
defrouter_select();
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2010-12-07 22:43:29 +00:00
|
|
|
|
|
|
|
if (ln->ln_router || dr)
|
|
|
|
LLE_WLOCK(ln);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2000-07-04 16:35:15 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* Before deleting the entry, remember the next entry as the
|
|
|
|
* return value. We need this because pfxlist_onlink_check() above
|
|
|
|
* might have freed other entries (particularly the old next entry) as
|
2002-04-19 04:46:24 +00:00
|
|
|
* a side effect (XXX).
|
2001-06-11 12:39:29 +00:00
|
|
|
*/
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
next = LIST_NEXT(ln, lle_next);
|
2000-07-04 16:35:15 +00:00
|
|
|
|
2010-11-29 00:04:08 +00:00
|
|
|
/*
|
|
|
|
* Save to unlock. We still hold an extra reference and will not
|
|
|
|
* free(9) in llentry_free() if someone else holds one as well.
|
|
|
|
*/
|
|
|
|
LLE_WUNLOCK(ln);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
IF_AFDATA_LOCK(ifp);
|
|
|
|
LLE_WLOCK(ln);
|
2010-04-11 16:04:08 +00:00
|
|
|
LLE_REMREF(ln);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
llentry_free(ln);
|
|
|
|
IF_AFDATA_UNLOCK(ifp);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-06 14:02:09 +00:00
|
|
|
return (next);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Upper-layer reachability hint for Neighbor Unreachability Detection.
|
|
|
|
*
|
2005-08-12 15:27:25 +00:00
|
|
|
* XXX cost-effective methods?
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
void
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_nud_hint(struct rtentry *rt, struct in6_addr *dst6, int force)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct llentry *ln;
|
|
|
|
struct ifnet *ifp;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if ((dst6 == NULL) || (rt == NULL))
|
|
|
|
return;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ifp = rt->rt_ifp;
|
|
|
|
IF_AFDATA_LOCK(ifp);
|
|
|
|
ln = nd6_lookup(dst6, ND6_EXCLUSIVE, NULL);
|
|
|
|
IF_AFDATA_UNLOCK(ifp);
|
|
|
|
if (ln == NULL)
|
1999-11-22 02:45:11 +00:00
|
|
|
return;
|
|
|
|
|
2000-04-17 20:24:06 +00:00
|
|
|
if (ln->ln_state < ND6_LLINFO_REACHABLE)
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
goto done;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
/*
|
|
|
|
* if we get upper-layer reachability confirmation many times,
|
|
|
|
* it is possible we have false information.
|
|
|
|
*/
|
|
|
|
if (!force) {
|
|
|
|
ln->ln_byhint++;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (ln->ln_byhint > V_nd6_maxnudhint) {
|
|
|
|
goto done;
|
|
|
|
}
|
2000-07-04 16:35:15 +00:00
|
|
|
}
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln->ln_state = ND6_LLINFO_REACHABLE;
|
2005-10-21 16:23:01 +00:00
|
|
|
if (!ND6_LLINFO_PERMANENT(ln)) {
|
2010-03-25 10:29:00 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln,
|
2005-10-21 16:23:01 +00:00
|
|
|
(long)ND_IFINFO(rt->rt_ifp)->reachable * hz);
|
|
|
|
}
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
done:
|
|
|
|
LLE_WUNLOCK(ln);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-11-11 23:22:38 +00:00
|
|
|
/*
|
|
|
|
* Rejuvenate this function for routing operations related
|
|
|
|
* processing.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
nd6_rtrequest(int req, struct rtentry *rt, struct rt_addrinfo *info)
|
|
|
|
{
|
|
|
|
struct sockaddr_in6 *gateway = (struct sockaddr_in6 *)rt->rt_gateway;
|
|
|
|
struct nd_defrouter *dr;
|
|
|
|
struct ifnet *ifp = rt->rt_ifp;
|
|
|
|
|
|
|
|
RT_LOCK_ASSERT(rt);
|
|
|
|
|
|
|
|
switch (req) {
|
|
|
|
case RTM_ADD:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case RTM_DELETE:
|
|
|
|
if (!ifp)
|
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* Only indirect routes are interesting.
|
|
|
|
*/
|
|
|
|
if ((rt->rt_flags & RTF_GATEWAY) == 0)
|
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* check for default route
|
|
|
|
*/
|
|
|
|
if (IN6_ARE_ADDR_EQUAL(&in6addr_any,
|
|
|
|
&SIN6(rt_key(rt))->sin6_addr)) {
|
|
|
|
|
|
|
|
dr = defrouter_lookup(&gateway->sin6_addr, ifp);
|
|
|
|
if (dr != NULL)
|
|
|
|
dr->installed = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
int
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_ioctl(u_long cmd, caddr_t data, struct ifnet *ifp)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
|
|
|
struct in6_drlist *drl = (struct in6_drlist *)data;
|
2003-10-24 18:26:30 +00:00
|
|
|
struct in6_oprlist *oprl = (struct in6_oprlist *)data;
|
1999-11-22 02:45:11 +00:00
|
|
|
struct in6_ndireq *ndi = (struct in6_ndireq *)data;
|
|
|
|
struct in6_nbrinfo *nbi = (struct in6_nbrinfo *)data;
|
2000-07-04 16:35:15 +00:00
|
|
|
struct in6_ndifreq *ndif = (struct in6_ndifreq *)data;
|
2005-10-21 16:23:01 +00:00
|
|
|
struct nd_defrouter *dr;
|
1999-11-22 02:45:11 +00:00
|
|
|
struct nd_prefix *pr;
|
|
|
|
int i = 0, error = 0;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case SIOCGDRLST_IN6:
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* obsolete API, use sysctl under net.inet6.icmp6
|
|
|
|
*/
|
1999-11-22 02:45:11 +00:00
|
|
|
bzero(drl, sizeof(*drl));
|
|
|
|
s = splnet();
|
2011-12-29 18:25:18 +00:00
|
|
|
TAILQ_FOREACH(dr, &V_nd_defrouter, dr_entry) {
|
|
|
|
if (i >= DRLSTSIZ)
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
drl->defrouter[i].rtaddr = dr->rtaddr;
|
2003-10-24 18:26:30 +00:00
|
|
|
in6_clearscope(&drl->defrouter[i].rtaddr);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
drl->defrouter[i].flags = dr->flags;
|
|
|
|
drl->defrouter[i].rtlifetime = dr->rtlifetime;
|
|
|
|
drl->defrouter[i].expire = dr->expire;
|
|
|
|
drl->defrouter[i].if_index = dr->ifp->if_index;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
break;
|
|
|
|
case SIOCGPRLST_IN6:
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* obsolete API, use sysctl under net.inet6.icmp6
|
2003-10-24 18:26:30 +00:00
|
|
|
*
|
|
|
|
* XXX the structure in6_prlist was changed in backward-
|
|
|
|
* incompatible manner. in6_oprlist is used for SIOCGPRLST_IN6,
|
|
|
|
* in6_prlist is used for nd6_sysctl() - fill_prlist().
|
2001-06-11 12:39:29 +00:00
|
|
|
*/
|
2000-07-04 16:35:15 +00:00
|
|
|
/*
|
|
|
|
* XXX meaning of fields, especialy "raflags", is very
|
|
|
|
* differnet between RA prefix list and RR/static prefix list.
|
|
|
|
* how about separating ioctls into two?
|
|
|
|
*/
|
2003-10-24 18:26:30 +00:00
|
|
|
bzero(oprl, sizeof(*oprl));
|
1999-11-22 02:45:11 +00:00
|
|
|
s = splnet();
|
2011-12-29 18:25:18 +00:00
|
|
|
LIST_FOREACH(pr, &V_nd_prefix, ndpr_entry) {
|
1999-11-22 02:45:11 +00:00
|
|
|
struct nd_pfxrouter *pfr;
|
|
|
|
int j;
|
|
|
|
|
2011-12-29 18:25:18 +00:00
|
|
|
if (i >= PRLSTSIZ)
|
|
|
|
break;
|
2005-07-25 12:31:43 +00:00
|
|
|
oprl->prefix[i].prefix = pr->ndpr_prefix.sin6_addr;
|
2003-10-24 18:26:30 +00:00
|
|
|
oprl->prefix[i].raflags = pr->ndpr_raf;
|
|
|
|
oprl->prefix[i].prefixlen = pr->ndpr_plen;
|
|
|
|
oprl->prefix[i].vltime = pr->ndpr_vltime;
|
|
|
|
oprl->prefix[i].pltime = pr->ndpr_pltime;
|
|
|
|
oprl->prefix[i].if_index = pr->ndpr_ifp->if_index;
|
2005-10-21 16:23:01 +00:00
|
|
|
if (pr->ndpr_vltime == ND6_INFINITE_LIFETIME)
|
|
|
|
oprl->prefix[i].expire = 0;
|
|
|
|
else {
|
|
|
|
time_t maxexpire;
|
|
|
|
|
|
|
|
/* XXX: we assume time_t is signed. */
|
|
|
|
maxexpire = (-1) &
|
2005-10-22 05:07:16 +00:00
|
|
|
~((time_t)1 <<
|
|
|
|
((sizeof(maxexpire) * 8) - 1));
|
2005-10-21 16:23:01 +00:00
|
|
|
if (pr->ndpr_vltime <
|
|
|
|
maxexpire - pr->ndpr_lastupdate) {
|
|
|
|
oprl->prefix[i].expire =
|
|
|
|
pr->ndpr_lastupdate +
|
|
|
|
pr->ndpr_vltime;
|
|
|
|
} else
|
|
|
|
oprl->prefix[i].expire = maxexpire;
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
j = 0;
|
2011-12-29 18:25:18 +00:00
|
|
|
LIST_FOREACH(pfr, &pr->ndpr_advrtrs, pfr_entry) {
|
1999-11-22 02:45:11 +00:00
|
|
|
if (j < DRLSTSIZ) {
|
2003-10-24 18:26:30 +00:00
|
|
|
#define RTRADDR oprl->prefix[i].advrtr[j]
|
1999-11-22 02:45:11 +00:00
|
|
|
RTRADDR = pfr->router->rtaddr;
|
2003-10-24 18:26:30 +00:00
|
|
|
in6_clearscope(&RTRADDR);
|
1999-11-22 02:45:11 +00:00
|
|
|
#undef RTRADDR
|
|
|
|
}
|
|
|
|
j++;
|
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
oprl->prefix[i].advrtrs = j;
|
|
|
|
oprl->prefix[i].origin = PR_ORIG_RA;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
i++;
|
|
|
|
}
|
2000-07-04 16:35:15 +00:00
|
|
|
splx(s);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
|
|
|
case OSIOCGIFINFO_IN6:
|
2005-10-19 10:09:19 +00:00
|
|
|
#define ND ndi->ndi
|
2003-10-17 15:46:31 +00:00
|
|
|
/* XXX: old ndp(8) assumes a positive value for linkmtu. */
|
2005-10-19 10:09:19 +00:00
|
|
|
bzero(&ND, sizeof(ND));
|
|
|
|
ND.linkmtu = IN6_LINKMTU(ifp);
|
|
|
|
ND.maxmtu = ND_IFINFO(ifp)->maxmtu;
|
|
|
|
ND.basereachable = ND_IFINFO(ifp)->basereachable;
|
|
|
|
ND.reachable = ND_IFINFO(ifp)->reachable;
|
|
|
|
ND.retrans = ND_IFINFO(ifp)->retrans;
|
|
|
|
ND.flags = ND_IFINFO(ifp)->flags;
|
|
|
|
ND.recalctm = ND_IFINFO(ifp)->recalctm;
|
|
|
|
ND.chlim = ND_IFINFO(ifp)->chlim;
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
case SIOCGIFINFO_IN6:
|
2005-10-19 10:09:19 +00:00
|
|
|
ND = *ND_IFINFO(ifp);
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
2005-10-19 15:05:42 +00:00
|
|
|
case SIOCSIFINFO_IN6:
|
|
|
|
/*
|
|
|
|
* used to change host variables from userland.
|
|
|
|
* intented for a use on router to reflect RA configurations.
|
|
|
|
*/
|
|
|
|
/* 0 means 'unspecified' */
|
|
|
|
if (ND.linkmtu != 0) {
|
|
|
|
if (ND.linkmtu < IPV6_MMTU ||
|
|
|
|
ND.linkmtu > IN6_LINKMTU(ifp)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ND_IFINFO(ifp)->linkmtu = ND.linkmtu;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ND.basereachable != 0) {
|
|
|
|
int obasereachable = ND_IFINFO(ifp)->basereachable;
|
|
|
|
|
|
|
|
ND_IFINFO(ifp)->basereachable = ND.basereachable;
|
|
|
|
if (ND.basereachable != obasereachable)
|
|
|
|
ND_IFINFO(ifp)->reachable =
|
|
|
|
ND_COMPUTE_RTIME(ND.basereachable);
|
|
|
|
}
|
|
|
|
if (ND.retrans != 0)
|
|
|
|
ND_IFINFO(ifp)->retrans = ND.retrans;
|
|
|
|
if (ND.chlim != 0)
|
|
|
|
ND_IFINFO(ifp)->chlim = ND.chlim;
|
|
|
|
/* FALLTHROUGH */
|
2000-07-04 16:35:15 +00:00
|
|
|
case SIOCSIFINFO_FLAGS:
|
2009-09-12 22:08:20 +00:00
|
|
|
{
|
|
|
|
struct ifaddr *ifa;
|
|
|
|
struct in6_ifaddr *ia;
|
|
|
|
|
|
|
|
if ((ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED) &&
|
|
|
|
!(ND.flags & ND6_IFF_IFDISABLED)) {
|
|
|
|
/* ifdisabled 1->0 transision */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the interface is marked as ND6_IFF_IFDISABLED and
|
|
|
|
* has an link-local address with IN6_IFF_DUPLICATED,
|
|
|
|
* do not clear ND6_IFF_IFDISABLED.
|
|
|
|
* See RFC 4862, Section 5.4.5.
|
|
|
|
*/
|
|
|
|
int duplicated_linklocal = 0;
|
|
|
|
|
2012-01-05 19:00:36 +00:00
|
|
|
IF_ADDR_RLOCK(ifp);
|
2009-09-12 22:08:20 +00:00
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
|
|
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
|
|
continue;
|
|
|
|
ia = (struct in6_ifaddr *)ifa;
|
|
|
|
if ((ia->ia6_flags & IN6_IFF_DUPLICATED) &&
|
- Accept Router Advertisement messages even when net.inet6.ip6.forwarding=1.
- A new per-interface knob IFF_ND6_NO_RADR and sysctl IPV6CTL_NO_RADR.
This controls if accepting a route in an RA message as the default route.
The default value for each interface can be set by net.inet6.ip6.no_radr.
The system wide default value is 0.
- A new sysctl: net.inet6.ip6.norbit_raif. This controls if setting R-bit in
NA on RA accepting interfaces. The default is 0 (R-bit is set based on
net.inet6.ip6.forwarding).
Background:
IPv6 host/router model suggests a router sends an RA and a host accepts it for
router discovery. Because of that, KAME implementation does not allow
accepting RAs when net.inet6.ip6.forwarding=1. Accepting RAs on a router can
make the routing table confused since it can change the default router
unintentionally.
However, in practice there are cases where we cannot distinguish a host from
a router clearly. For example, a customer edge router often works as a host
against the ISP, and as a router against the LAN at the same time. Another
example is a complex network configurations like an L2TP tunnel for IPv6
connection to Internet over an Ethernet link with another native IPv6 subnet.
In this case, the physical interface for the native IPv6 subnet works as a
host, and the pseudo-interface for L2TP works as the default IP forwarding
route.
Problem:
Disabling processing RA messages when net.inet6.ip6.forwarding=1 and
accepting them when net.inet6.ip6.forward=0 cause the following practical
issues:
- A router cannot perform SLAAC. It becomes a problem if a box has
multiple interfaces and you want to use SLAAC on some of them, for
example. A customer edge router for IPv6 Internet access service
using an IPv6-over-IPv6 tunnel sometimes needs SLAAC on the
physical interface for administration purpose; updating firmware
and so on (link-local addresses can be used there, but GUAs by
SLAAC are often used for scalability).
- When a host has multiple IPv6 interfaces and it receives multiple RAs on
them, controlling the default route is difficult. Router preferences
defined in RFC 4191 works only when the routers on the links are
under your control.
Details of Implementation Changes:
Router Advertisement messages will be accepted even when
net.inet6.ip6.forwarding=1. More precisely, the conditions are as
follow:
(ACCEPT_RTADV && !NO_RADR && !ip6.forwarding)
=> Normal RA processing on that interface. (as IPv6 host)
(ACCEPT_RTADV && (NO_RADR || ip6.forwarding))
=> Accept RA but add the router to the defroute list with
rtlifetime=0 unconditionally. This effectively prevents
from setting the received router address as the box's
default route.
(!ACCEPT_RTADV)
=> No RA processing on that interface.
ACCEPT_RTADV and NO_RADR are per-interface knob. In short, all interface
are classified as "RA-accepting" or not. An RA-accepting interface always
processes RA messages regardless of ip6.forwarding. The difference caused by
NO_RADR or ip6.forwarding is whether the RA source address is considered as
the default router or not.
R-bit in NA on the RA accepting interfaces is set based on
net.inet6.ip6.forwarding. While RFC 6204 W-1 rule (for CPE case) suggests
a router should disable the R-bit completely even when the box has
net.inet6.ip6.forwarding=1, I believe there is no technical reason with
doing so. This behavior can be set by a new sysctl net.inet6.ip6.norbit_raif
(the default is 0).
Usage:
# ifconfig fxp0 inet6 accept_rtadv
=> accept RA on fxp0
# ifconfig fxp0 inet6 accept_rtadv no_radr
=> accept RA on fxp0 but ignore default route information in it.
# sysctl net.inet6.ip6.norbit_no_radr=1
=> R-bit in NAs on RA accepting interfaces will always be set to 0.
2011-06-06 02:14:23 +00:00
|
|
|
IN6_IS_ADDR_LINKLOCAL(IA6_IN6(ia))) {
|
2009-09-12 22:08:20 +00:00
|
|
|
duplicated_linklocal = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-01-05 19:00:36 +00:00
|
|
|
IF_ADDR_RUNLOCK(ifp);
|
2009-09-12 22:08:20 +00:00
|
|
|
|
|
|
|
if (duplicated_linklocal) {
|
|
|
|
ND.flags |= ND6_IFF_IFDISABLED;
|
|
|
|
log(LOG_ERR, "Cannot enable an interface"
|
|
|
|
" with a link-local address marked"
|
|
|
|
" duplicate.\n");
|
|
|
|
} else {
|
|
|
|
ND_IFINFO(ifp)->flags &= ~ND6_IFF_IFDISABLED;
|
2011-10-16 19:46:52 +00:00
|
|
|
if (ifp->if_flags & IFF_UP)
|
|
|
|
in6_if_up(ifp);
|
2009-09-12 22:08:20 +00:00
|
|
|
}
|
|
|
|
} else if (!(ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED) &&
|
|
|
|
(ND.flags & ND6_IFF_IFDISABLED)) {
|
|
|
|
/* ifdisabled 0->1 transision */
|
|
|
|
/* Mark all IPv6 address as tentative. */
|
|
|
|
|
|
|
|
ND_IFINFO(ifp)->flags |= ND6_IFF_IFDISABLED;
|
2012-01-05 19:00:36 +00:00
|
|
|
IF_ADDR_RLOCK(ifp);
|
2009-09-12 22:08:20 +00:00
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
|
|
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
|
|
continue;
|
|
|
|
ia = (struct in6_ifaddr *)ifa;
|
|
|
|
ia->ia6_flags |= IN6_IFF_TENTATIVE;
|
|
|
|
}
|
2012-01-05 19:00:36 +00:00
|
|
|
IF_ADDR_RUNLOCK(ifp);
|
2009-09-12 22:08:20 +00:00
|
|
|
}
|
|
|
|
|
2011-10-16 19:46:52 +00:00
|
|
|
if (ND.flags & ND6_IFF_AUTO_LINKLOCAL) {
|
|
|
|
if (!(ND_IFINFO(ifp)->flags & ND6_IFF_AUTO_LINKLOCAL)) {
|
|
|
|
/* auto_linklocal 0->1 transision */
|
2009-09-12 22:08:20 +00:00
|
|
|
|
2011-10-16 19:46:52 +00:00
|
|
|
/* If no link-local address on ifp, configure */
|
|
|
|
ND_IFINFO(ifp)->flags |= ND6_IFF_AUTO_LINKLOCAL;
|
|
|
|
in6_ifattach(ifp, NULL);
|
|
|
|
} else if (!(ND.flags & ND6_IFF_IFDISABLED) &&
|
|
|
|
ifp->if_flags & IFF_UP) {
|
|
|
|
/*
|
|
|
|
* When the IF already has
|
|
|
|
* ND6_IFF_AUTO_LINKLOCAL, no link-local
|
|
|
|
* address is assigned, and IFF_UP, try to
|
|
|
|
* assign one.
|
|
|
|
*/
|
|
|
|
int haslinklocal = 0;
|
2011-06-06 02:37:38 +00:00
|
|
|
|
2012-01-05 19:00:36 +00:00
|
|
|
IF_ADDR_RLOCK(ifp);
|
2011-10-16 19:46:52 +00:00
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
|
|
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
|
|
continue;
|
|
|
|
ia = (struct in6_ifaddr *)ifa;
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(IA6_IN6(ia))) {
|
|
|
|
haslinklocal = 1;
|
|
|
|
break;
|
|
|
|
}
|
2011-06-06 02:37:38 +00:00
|
|
|
}
|
2012-01-05 19:00:36 +00:00
|
|
|
IF_ADDR_RUNLOCK(ifp);
|
2011-10-16 19:46:52 +00:00
|
|
|
if (!haslinklocal)
|
|
|
|
in6_ifattach(ifp, NULL);
|
2011-06-06 02:37:38 +00:00
|
|
|
}
|
2009-09-12 22:08:20 +00:00
|
|
|
}
|
|
|
|
}
|
2005-10-19 10:09:19 +00:00
|
|
|
ND_IFINFO(ifp)->flags = ND.flags;
|
2000-07-04 16:35:15 +00:00
|
|
|
break;
|
2005-10-19 10:09:19 +00:00
|
|
|
#undef ND
|
2000-07-04 16:35:15 +00:00
|
|
|
case SIOCSNDFLUSH_IN6: /* XXX: the ioctl name is confusing... */
|
2005-10-21 16:23:01 +00:00
|
|
|
/* sync kernel routing table with the default router list */
|
|
|
|
defrouter_reset();
|
2000-07-04 16:35:15 +00:00
|
|
|
defrouter_select();
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
case SIOCSPFXFLUSH_IN6:
|
2003-10-09 16:13:47 +00:00
|
|
|
{
|
1999-11-22 02:45:11 +00:00
|
|
|
/* flush all the prefix advertised by routers */
|
|
|
|
struct nd_prefix *pr, *next;
|
|
|
|
|
|
|
|
s = splnet();
|
2011-12-29 18:25:18 +00:00
|
|
|
LIST_FOREACH_SAFE(pr, &V_nd_prefix, ndpr_entry, next) {
|
2001-06-11 12:39:29 +00:00
|
|
|
struct in6_ifaddr *ia, *ia_next;
|
|
|
|
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&pr->ndpr_prefix.sin6_addr))
|
|
|
|
continue; /* XXX */
|
|
|
|
|
|
|
|
/* do we really have to remove addresses as well? */
|
2009-06-25 16:35:28 +00:00
|
|
|
/* XXXRW: in6_ifaddrhead locking. */
|
2009-06-24 21:00:25 +00:00
|
|
|
TAILQ_FOREACH_SAFE(ia, &V_in6_ifaddrhead, ia_link,
|
|
|
|
ia_next) {
|
2001-06-11 12:39:29 +00:00
|
|
|
if ((ia->ia6_flags & IN6_IFF_AUTOCONF) == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ia->ia6_ndpr == pr)
|
|
|
|
in6_purgeaddr(&ia->ia_ifa);
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
prelist_remove(pr);
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
break;
|
2003-10-09 16:13:47 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
case SIOCSRTRFLUSH_IN6:
|
2003-10-09 16:13:47 +00:00
|
|
|
{
|
1999-11-22 02:45:11 +00:00
|
|
|
/* flush all the default routers */
|
|
|
|
struct nd_defrouter *dr, *next;
|
|
|
|
|
|
|
|
s = splnet();
|
2005-10-21 16:23:01 +00:00
|
|
|
defrouter_reset();
|
2011-12-29 18:25:18 +00:00
|
|
|
TAILQ_FOREACH_SAFE(dr, &V_nd_defrouter, dr_entry, next) {
|
2005-10-21 16:23:01 +00:00
|
|
|
defrtrlist_del(dr);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2005-10-21 16:23:01 +00:00
|
|
|
defrouter_select();
|
1999-11-22 02:45:11 +00:00
|
|
|
splx(s);
|
|
|
|
break;
|
2003-10-09 16:13:47 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
case SIOCGNBRINFO_IN6:
|
2003-10-09 16:13:47 +00:00
|
|
|
{
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct llentry *ln;
|
1999-11-22 02:45:11 +00:00
|
|
|
struct in6_addr nb_addr = nbi->addr; /* make local for safety */
|
|
|
|
|
2005-07-25 12:31:43 +00:00
|
|
|
if ((error = in6_setscope(&nb_addr, ifp, NULL)) != 0)
|
|
|
|
return (error);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
IF_AFDATA_LOCK(ifp);
|
|
|
|
ln = nd6_lookup(&nb_addr, 0, ifp);
|
|
|
|
IF_AFDATA_UNLOCK(ifp);
|
|
|
|
|
|
|
|
if (ln == NULL) {
|
1999-11-22 02:45:11 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
nbi->state = ln->ln_state;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
nbi->asked = ln->la_asked;
|
1999-11-22 02:45:11 +00:00
|
|
|
nbi->isrouter = ln->ln_router;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
nbi->expire = ln->la_expire;
|
|
|
|
LLE_RUNLOCK(ln);
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
2003-10-09 16:13:47 +00:00
|
|
|
}
|
2000-07-04 16:35:15 +00:00
|
|
|
case SIOCGDEFIFACE_IN6: /* XXX: should be implemented as a sysctl? */
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
ndif->ifindex = V_nd6_defifindex;
|
2000-07-04 16:35:15 +00:00
|
|
|
break;
|
|
|
|
case SIOCSDEFIFACE_IN6: /* XXX: should be implemented as a sysctl? */
|
2003-10-06 14:02:09 +00:00
|
|
|
return (nd6_setdefaultiface(ndif->ifindex));
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2003-10-06 14:02:09 +00:00
|
|
|
return (error);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create neighbor cache entry and cache link-layer address,
|
2003-10-09 16:13:47 +00:00
|
|
|
* on reception of inbound ND6 packets. (RS/RA/NS/redirect)
|
2007-07-05 16:23:49 +00:00
|
|
|
*
|
|
|
|
* type - ICMP6 type
|
|
|
|
* code - type dependent information
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
*
|
|
|
|
* XXXXX
|
|
|
|
* The caller of this function already acquired the ndp
|
|
|
|
* cache table lock because the cache entry is returned.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct llentry *
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_cache_lladdr(struct ifnet *ifp, struct in6_addr *from, char *lladdr,
|
|
|
|
int lladdrlen, int type, int code)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct llentry *ln = NULL;
|
1999-11-22 02:45:11 +00:00
|
|
|
int is_newentry;
|
|
|
|
int do_update;
|
|
|
|
int olladdr;
|
|
|
|
int llchange;
|
2010-11-17 10:43:20 +00:00
|
|
|
int flags;
|
1999-11-22 02:45:11 +00:00
|
|
|
int newstate = 0;
|
2008-12-16 01:21:19 +00:00
|
|
|
uint16_t router = 0;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct sockaddr_in6 sin6;
|
2008-12-16 23:06:36 +00:00
|
|
|
struct mbuf *chain = NULL;
|
2008-12-16 01:21:19 +00:00
|
|
|
int static_route = 0;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
|
|
|
|
IF_AFDATA_UNLOCK_ASSERT(ifp);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2005-10-19 10:09:19 +00:00
|
|
|
if (ifp == NULL)
|
1999-11-22 02:45:11 +00:00
|
|
|
panic("ifp == NULL in nd6_cache_lladdr");
|
2005-10-19 10:09:19 +00:00
|
|
|
if (from == NULL)
|
1999-11-22 02:45:11 +00:00
|
|
|
panic("from == NULL in nd6_cache_lladdr");
|
|
|
|
|
|
|
|
/* nothing must be updated for unspecified address */
|
|
|
|
if (IN6_IS_ADDR_UNSPECIFIED(from))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Validation about ifp->if_addrlen and lladdrlen must be done in
|
|
|
|
* the caller.
|
|
|
|
*
|
|
|
|
* XXX If the link does not have link-layer adderss, what should
|
|
|
|
* we do? (ifp->if_addrlen == 0)
|
|
|
|
* Spec says nothing in sections for RA, RS and NA. There's small
|
|
|
|
* description on it in NS section (RFC 2461 7.2.3).
|
|
|
|
*/
|
2010-11-17 10:43:20 +00:00
|
|
|
flags = lladdr ? ND6_EXCLUSIVE : 0;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
IF_AFDATA_LOCK(ifp);
|
|
|
|
ln = nd6_lookup(from, flags, ifp);
|
2008-12-16 02:47:22 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (ln == NULL) {
|
2010-11-17 10:43:20 +00:00
|
|
|
flags |= ND6_EXCLUSIVE;
|
|
|
|
ln = nd6_lookup(from, flags | ND6_CREATE, ifp);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
IF_AFDATA_UNLOCK(ifp);
|
1999-11-22 02:45:11 +00:00
|
|
|
is_newentry = 1;
|
2001-06-11 12:39:29 +00:00
|
|
|
} else {
|
2008-12-16 02:47:22 +00:00
|
|
|
IF_AFDATA_UNLOCK(ifp);
|
2001-06-11 12:39:29 +00:00
|
|
|
/* do nothing if static ndp is set */
|
2008-12-16 01:21:19 +00:00
|
|
|
if (ln->la_flags & LLE_STATIC) {
|
|
|
|
static_route = 1;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
goto done;
|
2008-12-16 01:21:19 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
is_newentry = 0;
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
2005-10-19 10:09:19 +00:00
|
|
|
if (ln == NULL)
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
return (NULL);
|
|
|
|
|
|
|
|
olladdr = (ln->la_flags & LLE_VALID) ? 1 : 0;
|
1999-11-22 02:45:11 +00:00
|
|
|
if (olladdr && lladdr) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
llchange = bcmp(lladdr, &ln->ll_addr,
|
|
|
|
ifp->if_addrlen);
|
1999-11-22 02:45:11 +00:00
|
|
|
} else
|
|
|
|
llchange = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* newentry olladdr lladdr llchange (*=record)
|
|
|
|
* 0 n n -- (1)
|
|
|
|
* 0 y n -- (2)
|
|
|
|
* 0 n y -- (3) * STALE
|
|
|
|
* 0 y y n (4) *
|
|
|
|
* 0 y y y (5) * STALE
|
|
|
|
* 1 -- n -- (6) NOSTATE(= PASSIVE)
|
|
|
|
* 1 -- y -- (7) * STALE
|
|
|
|
*/
|
|
|
|
|
2002-04-19 04:46:24 +00:00
|
|
|
if (lladdr) { /* (3-5) and (7) */
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* Record source link-layer address
|
|
|
|
* XXX is it dependent to ifp->if_type?
|
|
|
|
*/
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
bcopy(lladdr, &ln->ll_addr, ifp->if_addrlen);
|
|
|
|
ln->la_flags |= LLE_VALID;
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_newentry) {
|
2005-10-19 10:09:19 +00:00
|
|
|
if ((!olladdr && lladdr != NULL) || /* (3) */
|
|
|
|
(olladdr && lladdr != NULL && llchange)) { /* (5) */
|
1999-11-22 02:45:11 +00:00
|
|
|
do_update = 1;
|
|
|
|
newstate = ND6_LLINFO_STALE;
|
2002-04-19 04:46:24 +00:00
|
|
|
} else /* (1-2,4) */
|
1999-11-22 02:45:11 +00:00
|
|
|
do_update = 0;
|
|
|
|
} else {
|
|
|
|
do_update = 1;
|
2005-10-19 10:09:19 +00:00
|
|
|
if (lladdr == NULL) /* (6) */
|
1999-11-22 02:45:11 +00:00
|
|
|
newstate = ND6_LLINFO_NOSTATE;
|
2002-04-19 04:46:24 +00:00
|
|
|
else /* (7) */
|
1999-11-22 02:45:11 +00:00
|
|
|
newstate = ND6_LLINFO_STALE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (do_update) {
|
|
|
|
/*
|
|
|
|
* Update the state of the neighbor cache.
|
|
|
|
*/
|
|
|
|
ln->ln_state = newstate;
|
|
|
|
|
|
|
|
if (ln->ln_state == ND6_LLINFO_STALE) {
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* XXX: since nd6_output() below will cause
|
|
|
|
* state tansition to DELAY and reset the timer,
|
|
|
|
* we must set the timer now, although it is actually
|
|
|
|
* meaningless.
|
|
|
|
*/
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, (long)V_nd6_gctimer * hz);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (ln->la_hold) {
|
2005-10-21 16:23:01 +00:00
|
|
|
struct mbuf *m_hold, *m_hold_next;
|
2007-05-05 04:24:01 +00:00
|
|
|
|
|
|
|
/*
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
* reset the la_hold in advance, to explicitly
|
|
|
|
* prevent a la_hold lookup in nd6_output()
|
2007-05-05 04:24:01 +00:00
|
|
|
* (wouldn't happen, though...)
|
|
|
|
*/
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
for (m_hold = ln->la_hold, ln->la_hold = NULL;
|
2007-05-04 02:34:17 +00:00
|
|
|
m_hold; m_hold = m_hold_next) {
|
2005-10-21 16:23:01 +00:00
|
|
|
m_hold_next = m_hold->m_nextpkt;
|
2007-05-04 02:34:17 +00:00
|
|
|
m_hold->m_nextpkt = NULL;
|
2005-10-21 16:23:01 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we assume ifp is not a p2p here, so
|
|
|
|
* just set the 2nd argument as the
|
|
|
|
* 1st one.
|
|
|
|
*/
|
2008-12-16 23:06:36 +00:00
|
|
|
nd6_output_lle(ifp, ifp, m_hold, L3_ADDR_SIN6(ln), NULL, ln, &chain);
|
2005-10-21 16:23:01 +00:00
|
|
|
}
|
2008-12-16 23:06:36 +00:00
|
|
|
/*
|
|
|
|
* If we have mbufs in the chain we need to do
|
|
|
|
* deferred transmit. Copy the address from the
|
|
|
|
* llentry before dropping the lock down below.
|
|
|
|
*/
|
|
|
|
if (chain != NULL)
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
memcpy(&sin6, L3_ADDR_SIN6(ln), sizeof(sin6));
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
} else if (ln->ln_state == ND6_LLINFO_INCOMPLETE) {
|
|
|
|
/* probe right away */
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
nd6_llinfo_settimer_locked((void *)ln, 0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ICMP6 type dependent behavior.
|
|
|
|
*
|
|
|
|
* NS: clear IsRouter if new entry
|
|
|
|
* RS: clear IsRouter
|
|
|
|
* RA: set IsRouter if there's lladdr
|
|
|
|
* redir: clear IsRouter if new entry
|
|
|
|
*
|
|
|
|
* RA case, (1):
|
|
|
|
* The spec says that we must set IsRouter in the following cases:
|
|
|
|
* - If lladdr exist, set IsRouter. This means (1-5).
|
|
|
|
* - If it is old entry (!newentry), set IsRouter. This means (7).
|
|
|
|
* So, based on the spec, in (1-5) and (7) cases we must set IsRouter.
|
|
|
|
* A quetion arises for (1) case. (1) case has no lladdr in the
|
|
|
|
* neighbor cache, this is similar to (6).
|
|
|
|
* This case is rare but we figured that we MUST NOT set IsRouter.
|
|
|
|
*
|
|
|
|
* newentry olladdr lladdr llchange NS RS RA redir
|
|
|
|
* D R
|
|
|
|
* 0 n n -- (1) c ? s
|
|
|
|
* 0 y n -- (2) c s s
|
|
|
|
* 0 n y -- (3) c s s
|
|
|
|
* 0 y y n (4) c s s
|
|
|
|
* 0 y y y (5) c s s
|
2007-07-05 16:29:40 +00:00
|
|
|
* 1 -- n -- (6) c c c s
|
1999-11-22 02:45:11 +00:00
|
|
|
* 1 -- y -- (7) c c s c s
|
|
|
|
*
|
|
|
|
* (c=clear s=set)
|
|
|
|
*/
|
|
|
|
switch (type & 0xff) {
|
|
|
|
case ND_NEIGHBOR_SOLICIT:
|
|
|
|
/*
|
|
|
|
* New entry must have is_router flag cleared.
|
|
|
|
*/
|
2002-04-19 04:46:24 +00:00
|
|
|
if (is_newentry) /* (6-7) */
|
1999-11-22 02:45:11 +00:00
|
|
|
ln->ln_router = 0;
|
|
|
|
break;
|
|
|
|
case ND_REDIRECT:
|
|
|
|
/*
|
|
|
|
* If the icmp is a redirect to a better router, always set the
|
2003-10-09 16:13:47 +00:00
|
|
|
* is_router flag. Otherwise, if the entry is newly created,
|
|
|
|
* clear the flag. [RFC 2461, sec 8.3]
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
if (code == ND_REDIRECT_ROUTER)
|
|
|
|
ln->ln_router = 1;
|
2002-04-19 04:46:24 +00:00
|
|
|
else if (is_newentry) /* (6-7) */
|
1999-11-22 02:45:11 +00:00
|
|
|
ln->ln_router = 0;
|
|
|
|
break;
|
|
|
|
case ND_ROUTER_SOLICIT:
|
|
|
|
/*
|
|
|
|
* is_router flag must always be cleared.
|
|
|
|
*/
|
|
|
|
ln->ln_router = 0;
|
|
|
|
break;
|
|
|
|
case ND_ROUTER_ADVERT:
|
|
|
|
/*
|
|
|
|
* Mark an entry with lladdr as a router.
|
|
|
|
*/
|
2003-10-09 16:13:47 +00:00
|
|
|
if ((!is_newentry && (olladdr || lladdr)) || /* (2-5) */
|
|
|
|
(is_newentry && lladdr)) { /* (7) */
|
1999-11-22 02:45:11 +00:00
|
|
|
ln->ln_router = 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-12-16 02:47:22 +00:00
|
|
|
if (ln != NULL) {
|
2008-12-16 01:21:19 +00:00
|
|
|
static_route = (ln->la_flags & LLE_STATIC);
|
2008-12-16 00:16:51 +00:00
|
|
|
router = ln->ln_router;
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (flags & ND6_EXCLUSIVE)
|
|
|
|
LLE_WUNLOCK(ln);
|
|
|
|
else
|
|
|
|
LLE_RUNLOCK(ln);
|
2008-12-16 00:16:51 +00:00
|
|
|
if (static_route)
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln = NULL;
|
|
|
|
}
|
|
|
|
if (chain)
|
|
|
|
nd6_output_flush(ifp, ifp, chain, &sin6, NULL);
|
|
|
|
|
2001-07-04 11:27:24 +00:00
|
|
|
/*
|
|
|
|
* When the link-layer address of a router changes, select the
|
|
|
|
* best router again. In particular, when the neighbor entry is newly
|
|
|
|
* created, it might affect the selection policy.
|
|
|
|
* Question: can we restrict the first condition to the "is_newentry"
|
|
|
|
* case?
|
|
|
|
* XXX: when we hear an RA from a new router with the link-layer
|
|
|
|
* address option, defrouter_select() is called twice, since
|
|
|
|
* defrtrlist_update called the function as well. However, I believe
|
|
|
|
* we can compromise the overhead, since it only happens the first
|
|
|
|
* time.
|
|
|
|
* XXX: although defrouter_select() should not have a bad effect
|
|
|
|
* for those are not autoconfigured hosts, we explicitly avoid such
|
|
|
|
* cases for safety.
|
|
|
|
*/
|
- Accept Router Advertisement messages even when net.inet6.ip6.forwarding=1.
- A new per-interface knob IFF_ND6_NO_RADR and sysctl IPV6CTL_NO_RADR.
This controls if accepting a route in an RA message as the default route.
The default value for each interface can be set by net.inet6.ip6.no_radr.
The system wide default value is 0.
- A new sysctl: net.inet6.ip6.norbit_raif. This controls if setting R-bit in
NA on RA accepting interfaces. The default is 0 (R-bit is set based on
net.inet6.ip6.forwarding).
Background:
IPv6 host/router model suggests a router sends an RA and a host accepts it for
router discovery. Because of that, KAME implementation does not allow
accepting RAs when net.inet6.ip6.forwarding=1. Accepting RAs on a router can
make the routing table confused since it can change the default router
unintentionally.
However, in practice there are cases where we cannot distinguish a host from
a router clearly. For example, a customer edge router often works as a host
against the ISP, and as a router against the LAN at the same time. Another
example is a complex network configurations like an L2TP tunnel for IPv6
connection to Internet over an Ethernet link with another native IPv6 subnet.
In this case, the physical interface for the native IPv6 subnet works as a
host, and the pseudo-interface for L2TP works as the default IP forwarding
route.
Problem:
Disabling processing RA messages when net.inet6.ip6.forwarding=1 and
accepting them when net.inet6.ip6.forward=0 cause the following practical
issues:
- A router cannot perform SLAAC. It becomes a problem if a box has
multiple interfaces and you want to use SLAAC on some of them, for
example. A customer edge router for IPv6 Internet access service
using an IPv6-over-IPv6 tunnel sometimes needs SLAAC on the
physical interface for administration purpose; updating firmware
and so on (link-local addresses can be used there, but GUAs by
SLAAC are often used for scalability).
- When a host has multiple IPv6 interfaces and it receives multiple RAs on
them, controlling the default route is difficult. Router preferences
defined in RFC 4191 works only when the routers on the links are
under your control.
Details of Implementation Changes:
Router Advertisement messages will be accepted even when
net.inet6.ip6.forwarding=1. More precisely, the conditions are as
follow:
(ACCEPT_RTADV && !NO_RADR && !ip6.forwarding)
=> Normal RA processing on that interface. (as IPv6 host)
(ACCEPT_RTADV && (NO_RADR || ip6.forwarding))
=> Accept RA but add the router to the defroute list with
rtlifetime=0 unconditionally. This effectively prevents
from setting the received router address as the box's
default route.
(!ACCEPT_RTADV)
=> No RA processing on that interface.
ACCEPT_RTADV and NO_RADR are per-interface knob. In short, all interface
are classified as "RA-accepting" or not. An RA-accepting interface always
processes RA messages regardless of ip6.forwarding. The difference caused by
NO_RADR or ip6.forwarding is whether the RA source address is considered as
the default router or not.
R-bit in NA on the RA accepting interfaces is set based on
net.inet6.ip6.forwarding. While RFC 6204 W-1 rule (for CPE case) suggests
a router should disable the R-bit completely even when the box has
net.inet6.ip6.forwarding=1, I believe there is no technical reason with
doing so. This behavior can be set by a new sysctl net.inet6.ip6.norbit_raif
(the default is 0).
Usage:
# ifconfig fxp0 inet6 accept_rtadv
=> accept RA on fxp0
# ifconfig fxp0 inet6 accept_rtadv no_radr
=> accept RA on fxp0 but ignore default route information in it.
# sysctl net.inet6.ip6.norbit_no_radr=1
=> R-bit in NAs on RA accepting interfaces will always be set to 0.
2011-06-06 02:14:23 +00:00
|
|
|
if (do_update && router &&
|
2009-09-12 22:08:20 +00:00
|
|
|
ND_IFINFO(ifp)->flags & ND6_IFF_ACCEPT_RTADV) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
/*
|
|
|
|
* guaranteed recursion
|
|
|
|
*/
|
2001-07-04 11:27:24 +00:00
|
|
|
defrouter_select();
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return (ln);
|
|
|
|
done:
|
2008-12-16 03:12:44 +00:00
|
|
|
if (ln != NULL) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (flags & ND6_EXCLUSIVE)
|
|
|
|
LLE_WUNLOCK(ln);
|
|
|
|
else
|
|
|
|
LLE_RUNLOCK(ln);
|
2008-12-16 01:21:19 +00:00
|
|
|
if (static_route)
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln = NULL;
|
|
|
|
}
|
|
|
|
return (ln);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
nd6_slowtimo(void *arg)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
CURVNET_SET((struct vnet *) arg);
|
2001-06-11 12:39:29 +00:00
|
|
|
struct nd_ifinfo *nd6if;
|
2003-10-17 15:46:31 +00:00
|
|
|
struct ifnet *ifp;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
callout_reset(&V_nd6_slowtimo_ch, ND6_SLOWTIMER_INTERVAL * hz,
|
Permit buiding kernels with options VIMAGE, restricted to only a single
active network stack instance. Turning on options VIMAGE at compile
time yields the following changes relative to default kernel build:
1) V_ accessor macros for virtualized variables resolve to structure
fields via base pointers, instead of being resolved as fields in global
structs or plain global variables. As an example, V_ifnet becomes:
options VIMAGE: ((struct vnet_net *) vnet_net)->_ifnet
default build: vnet_net_0._ifnet
options VIMAGE_GLOBALS: ifnet
2) INIT_VNET_* macros will declare and set up base pointers to be used
by V_ accessor macros, instead of resolving to whitespace:
INIT_VNET_NET(ifp->if_vnet); becomes
struct vnet_net *vnet_net = (ifp->if_vnet)->mod_data[VNET_MOD_NET];
3) Memory for vnet modules registered via vnet_mod_register() is now
allocated at run time in sys/kern/kern_vimage.c, instead of per vnet
module structs being declared as globals. If required, vnet modules
can now request the framework to provide them with allocated bzeroed
memory by filling in the vmi_size field in their vmi_modinfo structures.
4) structs socket, ifnet, inpcbinfo, tcpcb and syncache_head are
extended to hold a pointer to the parent vnet. options VIMAGE builds
will fill in those fields as required.
5) curvnet is introduced as a new global variable in options VIMAGE
builds, always pointing to the default and only struct vnet.
6) struct sysctl_oid has been extended with additional two fields to
store major and minor virtualization module identifiers, oid_v_subs and
oid_v_mod. SYSCTL_V_* family of macros will fill in those fields
accordingly, and store the offset in the appropriate vnet container
struct in oid_arg1.
In sysctl handlers dealing with virtualized sysctls, the
SYSCTL_RESOLVE_V_ARG1() macro will compute the address of the target
variable and make it available in arg1 variable for further processing.
Unused fields in structs vnet_inet, vnet_inet6 and vnet_ipfw have
been deleted.
Reviewed by: bz, rwatson
Approved by: julian (mentor)
2009-04-30 13:36:26 +00:00
|
|
|
nd6_slowtimo, curvnet);
|
2009-08-23 20:40:19 +00:00
|
|
|
IFNET_RLOCK_NOSLEEP();
|
2011-12-29 18:25:18 +00:00
|
|
|
TAILQ_FOREACH(ifp, &V_ifnet, if_list) {
|
2003-10-17 15:46:31 +00:00
|
|
|
nd6if = ND_IFINFO(ifp);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (nd6if->basereachable && /* already initialized */
|
|
|
|
(nd6if->recalctm -= ND6_SLOWTIMER_INTERVAL) <= 0) {
|
|
|
|
/*
|
|
|
|
* Since reachable time rarely changes by router
|
|
|
|
* advertisements, we SHOULD insure that a new random
|
|
|
|
* value gets recomputed at least once every few hours.
|
|
|
|
* (RFC 2461, 6.3.4)
|
|
|
|
*/
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
nd6if->recalctm = V_nd6_recalc_reachtm_interval;
|
1999-11-22 02:45:11 +00:00
|
|
|
nd6if->reachable = ND_COMPUTE_RTIME(nd6if->basereachable);
|
|
|
|
}
|
|
|
|
}
|
2009-08-23 20:40:19 +00:00
|
|
|
IFNET_RUNLOCK_NOSLEEP();
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
CURVNET_RESTORE();
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_output(struct ifnet *ifp, struct ifnet *origifp, struct mbuf *m0,
|
|
|
|
struct sockaddr_in6 *dst, struct rtentry *rt0)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
|
|
|
|
return (nd6_output_lle(ifp, origifp, m0, dst, rt0, NULL, NULL));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that I'm not enforcing any global serialization
|
|
|
|
* lle state or asked changes here as the logic is too
|
|
|
|
* complicated to avoid having to always acquire an exclusive
|
|
|
|
* lock
|
|
|
|
* KMM
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#define senderr(e) { error = (e); goto bad;}
|
|
|
|
|
|
|
|
int
|
|
|
|
nd6_output_lle(struct ifnet *ifp, struct ifnet *origifp, struct mbuf *m0,
|
|
|
|
struct sockaddr_in6 *dst, struct rtentry *rt0, struct llentry *lle,
|
2008-12-16 23:06:36 +00:00
|
|
|
struct mbuf **chain)
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
{
|
2001-06-11 12:39:29 +00:00
|
|
|
struct mbuf *m = m0;
|
2010-08-19 11:31:03 +00:00
|
|
|
struct m_tag *mtag;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct llentry *ln = lle;
|
2010-08-19 11:31:03 +00:00
|
|
|
struct ip6_hdr *ip6;
|
1999-11-22 02:45:11 +00:00
|
|
|
int error = 0;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
int flags = 0;
|
2010-08-19 11:31:03 +00:00
|
|
|
int ip6len;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
#ifdef INVARIANTS
|
2008-12-16 03:12:44 +00:00
|
|
|
if (lle != NULL) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
|
|
|
|
LLE_WLOCK_ASSERT(lle);
|
|
|
|
|
2008-12-16 23:06:36 +00:00
|
|
|
KASSERT(chain != NULL, (" lle locked but no mbuf chain pointer passed"));
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
}
|
|
|
|
#endif
|
1999-11-22 02:45:11 +00:00
|
|
|
if (IN6_IS_ADDR_MULTICAST(&dst->sin6_addr))
|
|
|
|
goto sendpkt;
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
if (nd6_need_cache(ifp) == 0)
|
1999-11-22 02:45:11 +00:00
|
|
|
goto sendpkt;
|
|
|
|
|
|
|
|
/*
|
2005-08-12 15:27:25 +00:00
|
|
|
* next hop determination. This routine is derived from ether_output.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Address resolution or Neighbor Unreachability Detection
|
|
|
|
* for the next hop.
|
|
|
|
* At this point, the destination of the packet must be a unicast
|
|
|
|
* or an anycast address(i.e. not a multicast).
|
|
|
|
*/
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
flags = ((m != NULL) || (lle != NULL)) ? LLE_EXCLUSIVE : 0;
|
|
|
|
if (ln == NULL) {
|
|
|
|
retry:
|
2008-12-17 10:03:49 +00:00
|
|
|
IF_AFDATA_LOCK(ifp);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln = lla_lookup(LLTABLE6(ifp), flags, (struct sockaddr *)dst);
|
2008-12-17 10:03:49 +00:00
|
|
|
IF_AFDATA_UNLOCK(ifp);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if ((ln == NULL) && nd6_is_addr_neighbor(dst, ifp)) {
|
|
|
|
/*
|
|
|
|
* Since nd6_is_addr_neighbor() internally calls nd6_lookup(),
|
|
|
|
* the condition below is not very efficient. But we believe
|
|
|
|
* it is tolerable, because this should be a rare case.
|
|
|
|
*/
|
|
|
|
flags = ND6_CREATE | (m ? ND6_EXCLUSIVE : 0);
|
2008-12-17 10:03:49 +00:00
|
|
|
IF_AFDATA_LOCK(ifp);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln = nd6_lookup(&dst->sin6_addr, flags, ifp);
|
2008-12-17 10:03:49 +00:00
|
|
|
IF_AFDATA_UNLOCK(ifp);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ln == NULL) {
|
2000-07-04 16:35:15 +00:00
|
|
|
if ((ifp->if_flags & IFF_POINTOPOINT) == 0 &&
|
2003-10-17 15:46:31 +00:00
|
|
|
!(ND_IFINFO(ifp)->flags & ND6_IFF_PERFORMNUD)) {
|
2006-12-12 12:17:58 +00:00
|
|
|
char ip6buf[INET6_ADDRSTRLEN];
|
2000-07-04 16:35:15 +00:00
|
|
|
log(LOG_DEBUG,
|
|
|
|
"nd6_output: can't allocate llinfo for %s "
|
2008-12-17 10:03:49 +00:00
|
|
|
"(ln=%p)\n",
|
|
|
|
ip6_sprintf(ip6buf, &dst->sin6_addr), ln);
|
2000-07-04 16:35:15 +00:00
|
|
|
senderr(EIO); /* XXX: good error? */
|
|
|
|
}
|
|
|
|
goto sendpkt; /* send anyway */
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
/* We don't have to do link-layer address resolution on a p2p link. */
|
|
|
|
if ((ifp->if_flags & IFF_POINTOPOINT) != 0 &&
|
2001-06-11 12:39:29 +00:00
|
|
|
ln->ln_state < ND6_LLINFO_REACHABLE) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if ((flags & LLE_EXCLUSIVE) == 0) {
|
|
|
|
flags |= LLE_EXCLUSIVE;
|
|
|
|
goto retry;
|
|
|
|
}
|
2000-07-04 16:35:15 +00:00
|
|
|
ln->ln_state = ND6_LLINFO_STALE;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, (long)V_nd6_gctimer * hz);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The first time we send a packet to a neighbor whose entry is
|
|
|
|
* STALE, we have to change the state to DELAY and a sets a timer to
|
|
|
|
* expire in DELAY_FIRST_PROBE_TIME seconds to ensure do
|
|
|
|
* neighbor unreachability detection on expiration.
|
|
|
|
* (RFC 2461 7.3.3)
|
|
|
|
*/
|
|
|
|
if (ln->ln_state == ND6_LLINFO_STALE) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if ((flags & LLE_EXCLUSIVE) == 0) {
|
|
|
|
flags |= LLE_EXCLUSIVE;
|
|
|
|
LLE_RUNLOCK(ln);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
ln->la_asked = 0;
|
1999-11-22 02:45:11 +00:00
|
|
|
ln->ln_state = ND6_LLINFO_DELAY;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln, (long)V_nd6_delay * hz);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the neighbor cache entry has a state other than INCOMPLETE
|
2002-04-19 04:46:24 +00:00
|
|
|
* (i.e. its link-layer address is already resolved), just
|
1999-11-22 02:45:11 +00:00
|
|
|
* send the packet.
|
|
|
|
*/
|
|
|
|
if (ln->ln_state > ND6_LLINFO_INCOMPLETE)
|
|
|
|
goto sendpkt;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There is a neighbor cache entry, but no ethernet address
|
2005-10-21 16:23:01 +00:00
|
|
|
* response yet. Append this latest packet to the end of the
|
|
|
|
* packet queue in the mbuf, unless the number of the packet
|
|
|
|
* does not exceed nd6_maxqueuelen. When it exceeds nd6_maxqueuelen,
|
|
|
|
* the oldest packet in the queue will be removed.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
2001-06-11 12:39:29 +00:00
|
|
|
if (ln->ln_state == ND6_LLINFO_NOSTATE)
|
1999-11-22 02:45:11 +00:00
|
|
|
ln->ln_state = ND6_LLINFO_INCOMPLETE;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
|
|
|
|
if ((flags & LLE_EXCLUSIVE) == 0) {
|
|
|
|
flags |= LLE_EXCLUSIVE;
|
|
|
|
LLE_RUNLOCK(ln);
|
|
|
|
goto retry;
|
|
|
|
}
|
2010-11-29 00:04:08 +00:00
|
|
|
|
|
|
|
LLE_WLOCK_ASSERT(ln);
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (ln->la_hold) {
|
2005-10-21 16:23:01 +00:00
|
|
|
struct mbuf *m_hold;
|
|
|
|
int i;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
i = 0;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
for (m_hold = ln->la_hold; m_hold; m_hold = m_hold->m_nextpkt) {
|
2005-10-21 16:23:01 +00:00
|
|
|
i++;
|
|
|
|
if (m_hold->m_nextpkt == NULL) {
|
|
|
|
m_hold->m_nextpkt = m;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
while (i >= V_nd6_maxqueuelen) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
m_hold = ln->la_hold;
|
|
|
|
ln->la_hold = ln->la_hold->m_nextpkt;
|
2006-03-24 16:20:12 +00:00
|
|
|
m_freem(m_hold);
|
2005-10-21 16:23:01 +00:00
|
|
|
i--;
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2005-10-21 16:23:01 +00:00
|
|
|
} else {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln->la_hold = m;
|
2005-10-21 16:23:01 +00:00
|
|
|
}
|
2010-11-29 00:04:08 +00:00
|
|
|
|
2005-10-21 16:23:01 +00:00
|
|
|
/*
|
|
|
|
* If there has been no NS for the neighbor after entering the
|
|
|
|
* INCOMPLETE state, send the first solicitation.
|
|
|
|
*/
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (!ND6_LLINFO_PERMANENT(ln) && ln->la_asked == 0) {
|
|
|
|
ln->la_asked++;
|
|
|
|
|
2010-11-29 00:04:08 +00:00
|
|
|
nd6_llinfo_settimer_locked(ln,
|
2005-10-21 16:23:01 +00:00
|
|
|
(long)ND_IFINFO(ifp)->retrans * hz / 1000);
|
2010-11-29 00:04:08 +00:00
|
|
|
LLE_WUNLOCK(ln);
|
2005-10-21 16:23:01 +00:00
|
|
|
nd6_ns_output(ifp, NULL, &dst->sin6_addr, ln, 0);
|
2010-11-29 00:04:08 +00:00
|
|
|
if (lle != NULL && ln == lle)
|
|
|
|
LLE_WLOCK(lle);
|
|
|
|
|
|
|
|
} else if (lle == NULL || ln != lle) {
|
|
|
|
/*
|
|
|
|
* We did the lookup (no lle arg) so we
|
|
|
|
* need to do the unlock here.
|
|
|
|
*/
|
|
|
|
LLE_WUNLOCK(ln);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2010-11-29 00:04:08 +00:00
|
|
|
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
2003-10-09 16:13:47 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
sendpkt:
|
2005-10-19 16:20:18 +00:00
|
|
|
/* discard the packet if IPv6 operation is disabled on the interface */
|
|
|
|
if ((ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED)) {
|
|
|
|
error = ENETDOWN; /* better error? */
|
|
|
|
goto bad;
|
|
|
|
}
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
/*
|
|
|
|
* ln is valid and the caller did not pass in
|
|
|
|
* an llentry
|
|
|
|
*/
|
2008-12-16 02:47:22 +00:00
|
|
|
if ((ln != NULL) && (lle == NULL)) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (flags & LLE_EXCLUSIVE)
|
|
|
|
LLE_WUNLOCK(ln);
|
|
|
|
else
|
|
|
|
LLE_RUNLOCK(ln);
|
|
|
|
}
|
2005-10-19 16:20:18 +00:00
|
|
|
|
2002-08-02 20:49:14 +00:00
|
|
|
#ifdef MAC
|
2007-10-28 15:55:23 +00:00
|
|
|
mac_netinet6_nd6_send(ifp, m);
|
2002-08-02 20:49:14 +00:00
|
|
|
#endif
|
2010-08-19 11:31:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If called from nd6_ns_output() (NS), nd6_na_output() (NA),
|
|
|
|
* icmp6_redirect_output() (REDIRECT) or from rip6_output() (RS, RA
|
|
|
|
* as handled by rtsol and rtadvd), mbufs will be tagged for SeND
|
|
|
|
* to be diverted to user space. When re-injected into the kernel,
|
|
|
|
* send_output() will directly dispatch them to the outgoing interface.
|
|
|
|
*/
|
|
|
|
if (send_sendso_input_hook != NULL) {
|
|
|
|
mtag = m_tag_find(m, PACKET_TAG_ND_OUTGOING, NULL);
|
|
|
|
if (mtag != NULL) {
|
|
|
|
ip6 = mtod(m, struct ip6_hdr *);
|
|
|
|
ip6len = sizeof(struct ip6_hdr) + ntohs(ip6->ip6_plen);
|
|
|
|
/* Use the SEND socket */
|
|
|
|
error = send_sendso_input_hook(m, ifp, SND_OUT,
|
|
|
|
ip6len);
|
|
|
|
/* -1 == no app on SEND socket */
|
|
|
|
if (error == 0 || error != -1)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-16 23:06:36 +00:00
|
|
|
/*
|
|
|
|
* We were passed in a pointer to an lle with the lock held
|
|
|
|
* this means that we can't call if_output as we will
|
|
|
|
* recurse on the lle lock - so what we do is we create
|
|
|
|
* a list of mbufs to send and transmit them in the caller
|
|
|
|
* after the lock is dropped
|
|
|
|
*/
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (lle != NULL) {
|
2008-12-16 23:06:36 +00:00
|
|
|
if (*chain == NULL)
|
|
|
|
*chain = m;
|
|
|
|
else {
|
2011-09-30 18:20:16 +00:00
|
|
|
struct mbuf *mb;
|
2008-12-16 23:06:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* append mbuf to end of deferred chain
|
|
|
|
*/
|
2011-09-30 18:20:16 +00:00
|
|
|
mb = *chain;
|
|
|
|
while (mb->m_nextpkt != NULL)
|
|
|
|
mb = mb->m_nextpkt;
|
|
|
|
mb->m_nextpkt = m;
|
2008-12-16 02:33:53 +00:00
|
|
|
}
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
return (error);
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
if ((ifp->if_flags & IFF_LOOPBACK) != 0) {
|
2003-10-06 14:02:09 +00:00
|
|
|
return ((*ifp->if_output)(origifp, m, (struct sockaddr *)dst,
|
2008-12-17 10:03:49 +00:00
|
|
|
NULL));
|
2000-07-04 16:35:15 +00:00
|
|
|
}
|
2008-12-17 10:03:49 +00:00
|
|
|
error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst, NULL);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
return (error);
|
2000-07-04 16:35:15 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
bad:
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
/*
|
|
|
|
* ln is valid and the caller did not pass in
|
|
|
|
* an llentry
|
|
|
|
*/
|
2008-12-16 02:47:22 +00:00
|
|
|
if ((ln != NULL) && (lle == NULL)) {
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
if (flags & LLE_EXCLUSIVE)
|
|
|
|
LLE_WUNLOCK(ln);
|
|
|
|
else
|
|
|
|
LLE_RUNLOCK(ln);
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
if (m)
|
|
|
|
m_freem(m);
|
|
|
|
return (error);
|
2003-10-09 16:13:47 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
#undef senderr
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
nd6_output_flush(struct ifnet *ifp, struct ifnet *origifp, struct mbuf *chain,
|
2009-04-16 20:30:28 +00:00
|
|
|
struct sockaddr_in6 *dst, struct route *ro)
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
{
|
|
|
|
struct mbuf *m, *m_head;
|
|
|
|
struct ifnet *outifp;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
m_head = chain;
|
|
|
|
if ((ifp->if_flags & IFF_LOOPBACK) != 0)
|
|
|
|
outifp = origifp;
|
|
|
|
else
|
|
|
|
outifp = ifp;
|
|
|
|
|
|
|
|
while (m_head) {
|
|
|
|
m = m_head;
|
|
|
|
m_head = m_head->m_nextpkt;
|
2009-04-16 20:30:28 +00:00
|
|
|
error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst, ro);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
* note that intermediate errors are blindly ignored - but this is
|
|
|
|
* the same convention as used with nd6_output when called by
|
|
|
|
* nd6_cache_lladdr
|
|
|
|
*/
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
int
|
2007-07-05 16:23:49 +00:00
|
|
|
nd6_need_cache(struct ifnet *ifp)
|
2001-06-11 12:39:29 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* XXX: we currently do not make neighbor cache on any interface
|
|
|
|
* other than ARCnet, Ethernet, FDDI and GIF.
|
|
|
|
*
|
|
|
|
* RFC2893 says:
|
|
|
|
* - unidirectional tunnels needs no ND
|
|
|
|
*/
|
|
|
|
switch (ifp->if_type) {
|
|
|
|
case IFT_ARCNET:
|
|
|
|
case IFT_ETHER:
|
|
|
|
case IFT_FDDI:
|
|
|
|
case IFT_IEEE1394:
|
2001-06-19 14:48:02 +00:00
|
|
|
#ifdef IFT_L2VLAN
|
|
|
|
case IFT_L2VLAN:
|
|
|
|
#endif
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef IFT_IEEE80211
|
|
|
|
case IFT_IEEE80211:
|
|
|
|
#endif
|
2011-03-21 09:40:01 +00:00
|
|
|
case IFT_INFINIBAND:
|
2001-06-11 12:39:29 +00:00
|
|
|
case IFT_GIF: /* XXX need more cases? */
|
2005-10-21 15:59:00 +00:00
|
|
|
case IFT_PPP:
|
|
|
|
case IFT_TUNNEL:
|
2005-09-06 21:11:59 +00:00
|
|
|
case IFT_BRIDGE:
|
2007-02-03 09:34:36 +00:00
|
|
|
case IFT_PROPVIRTUAL:
|
2003-10-06 14:02:09 +00:00
|
|
|
return (1);
|
2001-06-11 12:39:29 +00:00
|
|
|
default:
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
/*
|
|
|
|
* the callers of this function need to be re-worked to drop
|
|
|
|
* the lle lock, drop here for now
|
|
|
|
*/
|
1999-11-22 02:45:11 +00:00
|
|
|
int
|
2008-12-17 10:03:49 +00:00
|
|
|
nd6_storelladdr(struct ifnet *ifp, struct mbuf *m,
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct sockaddr *dst, u_char *desten, struct llentry **lle)
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
struct llentry *ln;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
*lle = NULL;
|
|
|
|
IF_AFDATA_UNLOCK_ASSERT(ifp);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (m->m_flags & M_MCAST) {
|
2005-08-09 08:37:28 +00:00
|
|
|
int i;
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
switch (ifp->if_type) {
|
|
|
|
case IFT_ETHER:
|
2001-06-11 12:39:29 +00:00
|
|
|
case IFT_FDDI:
|
2001-06-19 14:48:02 +00:00
|
|
|
#ifdef IFT_L2VLAN
|
2004-04-26 20:31:46 +00:00
|
|
|
case IFT_L2VLAN:
|
2001-06-19 14:48:02 +00:00
|
|
|
#endif
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef IFT_IEEE80211
|
|
|
|
case IFT_IEEE80211:
|
|
|
|
#endif
|
2005-09-06 21:11:59 +00:00
|
|
|
case IFT_BRIDGE:
|
2003-09-14 02:32:31 +00:00
|
|
|
case IFT_ISO88025:
|
1999-11-22 02:45:11 +00:00
|
|
|
ETHER_MAP_IPV6_MULTICAST(&SIN6(dst)->sin6_addr,
|
|
|
|
desten);
|
2004-04-26 20:31:46 +00:00
|
|
|
return (0);
|
2001-06-11 12:39:29 +00:00
|
|
|
case IFT_IEEE1394:
|
2002-04-19 04:46:24 +00:00
|
|
|
/*
|
|
|
|
* netbsd can use if_broadcastaddr, but we don't do so
|
|
|
|
* to reduce # of ifdef.
|
|
|
|
*/
|
2001-06-11 12:39:29 +00:00
|
|
|
for (i = 0; i < ifp->if_addrlen; i++)
|
|
|
|
desten[i] = ~0;
|
2004-04-26 20:31:46 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
case IFT_ARCNET:
|
|
|
|
*desten = 0;
|
2004-04-26 20:31:46 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
default:
|
2001-03-11 05:31:45 +00:00
|
|
|
m_freem(m);
|
2004-04-26 20:31:46 +00:00
|
|
|
return (EAFNOSUPPORT);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
This commit does two things:
1. rt_check() cleanup:
rt_check() is only necessary for some address families to gain access
to the corresponding arp entry, so call it only in/near the *resolve()
routines where it is actually used -- at the moment this is
arpresolve(), nd6_storelladdr() (the call is embedded here),
and atmresolve() (the call is just before atmresolve to reduce
the number of changes).
This change will make it a lot easier to decouple the arp table
from the routing table.
There is an extra call to rt_check() in if_iso88025subr.c to
determine the routing info length. I have left it alone for
the time being.
The interface of arpresolve() and nd6_storelladdr() now changes slightly:
+ the 'rtentry' parameter (really a hint from the upper level layer)
is now passed unchanged from *_output(), so it becomes the route
to the final destination and not to the gateway.
+ the routines will return 0 if resolution is possible, non-zero
otherwise.
+ arpresolve() returns EWOULDBLOCK in case the mbuf is being held
waiting for an arp reply -- in this case the error code is masked
in the caller so the upper layer protocol will not see a failure.
2. arpcom untangling
Where possible, use 'struct ifnet' instead of 'struct arpcom' variables,
and use the IFP2AC macro to access arpcom fields.
This mostly affects the netatalk code.
=== Detailed changes: ===
net/if_arcsubr.c
rt_check() cleanup, remove a useless variable
net/if_atmsubr.c
rt_check() cleanup
net/if_ethersubr.c
rt_check() cleanup, arpcom untangling
net/if_fddisubr.c
rt_check() cleanup, arpcom untangling
net/if_iso88025subr.c
rt_check() cleanup
netatalk/aarp.c
arpcom untangling, remove a block of duplicated code
netatalk/at_extern.h
arpcom untangling
netinet/if_ether.c
rt_check() cleanup (change arpresolve)
netinet6/nd6.c
rt_check() cleanup (change nd6_storelladdr)
2004-04-25 09:24:52 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
/*
|
|
|
|
* the entry should have been created in nd6_store_lladdr
|
|
|
|
*/
|
|
|
|
IF_AFDATA_LOCK(ifp);
|
|
|
|
ln = lla_lookup(LLTABLE6(ifp), 0, dst);
|
|
|
|
IF_AFDATA_UNLOCK(ifp);
|
|
|
|
if ((ln == NULL) || !(ln->la_flags & LLE_VALID)) {
|
2008-12-16 02:33:53 +00:00
|
|
|
if (ln != NULL)
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
LLE_RUNLOCK(ln);
|
|
|
|
/* this could happen, if we could not allocate memory */
|
2001-03-11 05:31:45 +00:00
|
|
|
m_freem(m);
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
return (1);
|
2000-07-04 16:35:15 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
bcopy(&ln->ll_addr, desten, ifp->if_addrlen);
|
|
|
|
*lle = ln;
|
|
|
|
LLE_RUNLOCK(ln);
|
|
|
|
/*
|
|
|
|
* A *small* use after free race exists here
|
|
|
|
*/
|
This commit does two things:
1. rt_check() cleanup:
rt_check() is only necessary for some address families to gain access
to the corresponding arp entry, so call it only in/near the *resolve()
routines where it is actually used -- at the moment this is
arpresolve(), nd6_storelladdr() (the call is embedded here),
and atmresolve() (the call is just before atmresolve to reduce
the number of changes).
This change will make it a lot easier to decouple the arp table
from the routing table.
There is an extra call to rt_check() in if_iso88025subr.c to
determine the routing info length. I have left it alone for
the time being.
The interface of arpresolve() and nd6_storelladdr() now changes slightly:
+ the 'rtentry' parameter (really a hint from the upper level layer)
is now passed unchanged from *_output(), so it becomes the route
to the final destination and not to the gateway.
+ the routines will return 0 if resolution is possible, non-zero
otherwise.
+ arpresolve() returns EWOULDBLOCK in case the mbuf is being held
waiting for an arp reply -- in this case the error code is masked
in the caller so the upper layer protocol will not see a failure.
2. arpcom untangling
Where possible, use 'struct ifnet' instead of 'struct arpcom' variables,
and use the IFP2AC macro to access arpcom fields.
This mostly affects the netatalk code.
=== Detailed changes: ===
net/if_arcsubr.c
rt_check() cleanup, remove a useless variable
net/if_atmsubr.c
rt_check() cleanup
net/if_ethersubr.c
rt_check() cleanup, arpcom untangling
net/if_fddisubr.c
rt_check() cleanup, arpcom untangling
net/if_iso88025subr.c
rt_check() cleanup
netatalk/aarp.c
arpcom untangling, remove a block of duplicated code
netatalk/at_extern.h
arpcom untangling
netinet/if_ether.c
rt_check() cleanup (change arpresolve)
netinet6/nd6.c
rt_check() cleanup (change nd6_storelladdr)
2004-04-25 09:24:52 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
static void
|
|
|
|
clear_llinfo_pqueue(struct llentry *ln)
|
2006-03-24 16:20:12 +00:00
|
|
|
{
|
|
|
|
struct mbuf *m_hold, *m_hold_next;
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
for (m_hold = ln->la_hold; m_hold; m_hold = m_hold_next) {
|
2006-03-24 16:20:12 +00:00
|
|
|
m_hold_next = m_hold->m_nextpkt;
|
|
|
|
m_hold->m_nextpkt = NULL;
|
|
|
|
m_freem(m_hold);
|
|
|
|
}
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
ln->la_hold = NULL;
|
2006-03-24 16:20:12 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
static int nd6_sysctl_drlist(SYSCTL_HANDLER_ARGS);
|
|
|
|
static int nd6_sysctl_prlist(SYSCTL_HANDLER_ARGS);
|
|
|
|
#ifdef SYSCTL_DECL
|
|
|
|
SYSCTL_DECL(_net_inet6_icmp6);
|
|
|
|
#endif
|
|
|
|
SYSCTL_NODE(_net_inet6_icmp6, ICMPV6CTL_ND6_DRLIST, nd6_drlist,
|
|
|
|
CTLFLAG_RD, nd6_sysctl_drlist, "");
|
|
|
|
SYSCTL_NODE(_net_inet6_icmp6, ICMPV6CTL_ND6_PRLIST, nd6_prlist,
|
|
|
|
CTLFLAG_RD, nd6_sysctl_prlist, "");
|
Build on Jeff Roberson's linker-set based dynamic per-CPU allocator
(DPCPU), as suggested by Peter Wemm, and implement a new per-virtual
network stack memory allocator. Modify vnet to use the allocator
instead of monolithic global container structures (vinet, ...). This
change solves many binary compatibility problems associated with
VIMAGE, and restores ELF symbols for virtualized global variables.
Each virtualized global variable exists as a "reference copy", and also
once per virtual network stack. Virtualized global variables are
tagged at compile-time, placing the in a special linker set, which is
loaded into a contiguous region of kernel memory. Virtualized global
variables in the base kernel are linked as normal, but those in modules
are copied and relocated to a reserved portion of the kernel's vnet
region with the help of a the kernel linker.
Virtualized global variables exist in per-vnet memory set up when the
network stack instance is created, and are initialized statically from
the reference copy. Run-time access occurs via an accessor macro, which
converts from the current vnet and requested symbol to a per-vnet
address. When "options VIMAGE" is not compiled into the kernel, normal
global ELF symbols will be used instead and indirection is avoided.
This change restores static initialization for network stack global
variables, restores support for non-global symbols and types, eliminates
the need for many subsystem constructors, eliminates large per-subsystem
structures that caused many binary compatibility issues both for
monitoring applications (netstat) and kernel modules, removes the
per-function INIT_VNET_*() macros throughout the stack, eliminates the
need for vnet_symmap ksym(2) munging, and eliminates duplicate
definitions of virtualized globals under VIMAGE_GLOBALS.
Bump __FreeBSD_version and update UPDATING.
Portions submitted by: bz
Reviewed by: bz, zec
Discussed with: gnn, jamie, jeff, jhb, julian, sam
Suggested by: peter
Approved by: re (kensmith)
2009-07-14 22:48:30 +00:00
|
|
|
SYSCTL_VNET_INT(_net_inet6_icmp6, ICMPV6CTL_ND6_MAXQLEN, nd6_maxqueuelen,
|
|
|
|
CTLFLAG_RW, &VNET_NAME(nd6_maxqueuelen), 1, "");
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
nd6_sysctl_drlist(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error;
|
2007-05-21 14:38:20 +00:00
|
|
|
char buf[1024] __aligned(4);
|
2001-06-11 12:39:29 +00:00
|
|
|
struct in6_defrouter *d, *de;
|
|
|
|
struct nd_defrouter *dr;
|
|
|
|
|
|
|
|
if (req->newptr)
|
|
|
|
return EPERM;
|
|
|
|
error = 0;
|
|
|
|
|
2011-12-29 18:25:18 +00:00
|
|
|
TAILQ_FOREACH(dr, &V_nd_defrouter, dr_entry) {
|
2001-06-11 12:39:29 +00:00
|
|
|
d = (struct in6_defrouter *)buf;
|
|
|
|
de = (struct in6_defrouter *)(buf + sizeof(buf));
|
|
|
|
|
|
|
|
if (d + 1 <= de) {
|
|
|
|
bzero(d, sizeof(*d));
|
|
|
|
d->rtaddr.sin6_family = AF_INET6;
|
|
|
|
d->rtaddr.sin6_len = sizeof(d->rtaddr);
|
2005-07-25 12:31:43 +00:00
|
|
|
d->rtaddr.sin6_addr = dr->rtaddr;
|
2007-07-05 06:27:15 +00:00
|
|
|
error = sa6_recoverscope(&d->rtaddr);
|
|
|
|
if (error != 0)
|
2007-07-03 12:13:45 +00:00
|
|
|
return (error);
|
2001-06-11 12:39:29 +00:00
|
|
|
d->flags = dr->flags;
|
|
|
|
d->rtlifetime = dr->rtlifetime;
|
|
|
|
d->expire = dr->expire;
|
|
|
|
d->if_index = dr->ifp->if_index;
|
|
|
|
} else
|
|
|
|
panic("buffer too short");
|
|
|
|
|
|
|
|
error = SYSCTL_OUT(req, buf, sizeof(*d));
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
}
|
2003-10-09 16:13:47 +00:00
|
|
|
|
|
|
|
return (error);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
nd6_sysctl_prlist(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error;
|
2007-05-21 14:38:20 +00:00
|
|
|
char buf[1024] __aligned(4);
|
2001-06-11 12:39:29 +00:00
|
|
|
struct in6_prefix *p, *pe;
|
|
|
|
struct nd_prefix *pr;
|
2006-12-12 12:17:58 +00:00
|
|
|
char ip6buf[INET6_ADDRSTRLEN];
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
if (req->newptr)
|
|
|
|
return EPERM;
|
|
|
|
error = 0;
|
|
|
|
|
2011-12-29 18:25:18 +00:00
|
|
|
LIST_FOREACH(pr, &V_nd_prefix, ndpr_entry) {
|
2001-06-11 12:39:29 +00:00
|
|
|
u_short advrtrs;
|
|
|
|
size_t advance;
|
|
|
|
struct sockaddr_in6 *sin6, *s6;
|
|
|
|
struct nd_pfxrouter *pfr;
|
|
|
|
|
|
|
|
p = (struct in6_prefix *)buf;
|
|
|
|
pe = (struct in6_prefix *)(buf + sizeof(buf));
|
|
|
|
|
|
|
|
if (p + 1 <= pe) {
|
|
|
|
bzero(p, sizeof(*p));
|
|
|
|
sin6 = (struct sockaddr_in6 *)(p + 1);
|
|
|
|
|
|
|
|
p->prefix = pr->ndpr_prefix;
|
2005-07-25 12:31:43 +00:00
|
|
|
if (sa6_recoverscope(&p->prefix)) {
|
2001-06-11 12:39:29 +00:00
|
|
|
log(LOG_ERR,
|
|
|
|
"scope error in prefix list (%s)\n",
|
2006-12-12 12:17:58 +00:00
|
|
|
ip6_sprintf(ip6buf, &p->prefix.sin6_addr));
|
2005-07-25 12:31:43 +00:00
|
|
|
/* XXX: press on... */
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
p->raflags = pr->ndpr_raf;
|
|
|
|
p->prefixlen = pr->ndpr_plen;
|
|
|
|
p->vltime = pr->ndpr_vltime;
|
|
|
|
p->pltime = pr->ndpr_pltime;
|
|
|
|
p->if_index = pr->ndpr_ifp->if_index;
|
2005-10-21 16:23:01 +00:00
|
|
|
if (pr->ndpr_vltime == ND6_INFINITE_LIFETIME)
|
|
|
|
p->expire = 0;
|
|
|
|
else {
|
|
|
|
time_t maxexpire;
|
|
|
|
|
|
|
|
/* XXX: we assume time_t is signed. */
|
|
|
|
maxexpire = (-1) &
|
2005-10-22 05:07:16 +00:00
|
|
|
~((time_t)1 <<
|
|
|
|
((sizeof(maxexpire) * 8) - 1));
|
2005-10-21 16:23:01 +00:00
|
|
|
if (pr->ndpr_vltime <
|
|
|
|
maxexpire - pr->ndpr_lastupdate) {
|
|
|
|
p->expire = pr->ndpr_lastupdate +
|
|
|
|
pr->ndpr_vltime;
|
|
|
|
} else
|
|
|
|
p->expire = maxexpire;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
p->refcnt = pr->ndpr_refcnt;
|
|
|
|
p->flags = pr->ndpr_stateflags;
|
|
|
|
p->origin = PR_ORIG_RA;
|
|
|
|
advrtrs = 0;
|
2011-12-29 18:25:18 +00:00
|
|
|
LIST_FOREACH(pfr, &pr->ndpr_advrtrs, pfr_entry) {
|
2003-10-09 16:13:47 +00:00
|
|
|
if ((void *)&sin6[advrtrs + 1] > (void *)pe) {
|
2001-06-11 12:39:29 +00:00
|
|
|
advrtrs++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
s6 = &sin6[advrtrs];
|
|
|
|
bzero(s6, sizeof(*s6));
|
|
|
|
s6->sin6_family = AF_INET6;
|
|
|
|
s6->sin6_len = sizeof(*sin6);
|
2005-07-25 12:31:43 +00:00
|
|
|
s6->sin6_addr = pfr->router->rtaddr;
|
|
|
|
if (sa6_recoverscope(s6)) {
|
2001-06-11 12:39:29 +00:00
|
|
|
log(LOG_ERR,
|
|
|
|
"scope error in "
|
|
|
|
"prefix list (%s)\n",
|
2006-12-12 12:17:58 +00:00
|
|
|
ip6_sprintf(ip6buf,
|
|
|
|
&pfr->router->rtaddr));
|
2005-07-25 12:31:43 +00:00
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
advrtrs++;
|
|
|
|
}
|
|
|
|
p->advrtrs = advrtrs;
|
2003-10-09 16:13:47 +00:00
|
|
|
} else
|
2001-06-11 12:39:29 +00:00
|
|
|
panic("buffer too short");
|
|
|
|
|
|
|
|
advance = sizeof(*p) + sizeof(*sin6) * advrtrs;
|
|
|
|
error = SYSCTL_OUT(req, buf, advance);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
}
|
2003-10-09 16:13:47 +00:00
|
|
|
|
|
|
|
return (error);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|