D16147.id45599.diff
No OneTemporary
Actions

Size

94 KB

Referenced Files

None

Subscribers

None

D16147.id45599.diff
View Options

	Index: share/man/man9/vnet.9
	===================================================================
	--- share/man/man9/vnet.9
	+++ share/man/man9/vnet.9
	@@ -66,6 +66,10 @@
	.Fa "type" "name"
	.Fc
	.\"
	+.Fo VNET_DEFINE_STATIC
	+.Fa "type" "name"
	+.Fc
	+.\"
	.Bd -literal
	#define V_name VNET(name)
	.Ed
	@@ -208,11 +212,15 @@
	.Fn VNET_DEFINE
	macro rather than writing them out as
	.Em type name .
	-One can still use static initialization or storage class specifiers, e.g.,
	+One can still use static initialization, e.g.,
	.Pp
	-.Dl Li static VNET_DEFINE(int, foo) = 1;
	-or
	-.Dl Li static VNET_DEFINE(SLIST_HEAD(, bar), bars);
	+.Dl Li VNET_DEFINE(int, foo) = 1;
	+.Pp
	+Variables declared with the static keyword can use the
	+.Fn VNET_DEFINE_STATIC
	+macro, e.g.,
	+.Pp
	+.Dl Li VNET_DEFINE_STATIC(SLIST_HEAD(, bar), bars);
	.Pp
	Static initialization is not possible when the virtualized variable
	would need to be referenced, e.g., with
	Index: sys/contrib/ipfilter/netinet/ip_rpcb_pxy.c
	===================================================================
	--- sys/contrib/ipfilter/netinet/ip_rpcb_pxy.c
	+++ sys/contrib/ipfilter/netinet/ip_rpcb_pxy.c
	@@ -80,7 +80,7 @@
	*/
	static frentry_t rpcbfr; /* Skeleton rule for reference by entities
	this proxy creates. */
	-static VNET_DEFINE(int, rpcbcnt);
	+VNET_DEFINE_STATIC(int, rpcbcnt);
	#define V_rpcbcnt VNET(rpcbcnt)
	/* Upper bound of allocated RPCB sessions. */
	/* XXX rpcbcnt still requires locking. */
	Index: sys/net/bpf.c
	===================================================================
	--- sys/net/bpf.c
	+++ sys/net/bpf.c
	@@ -213,7 +213,7 @@
	static SYSCTL_NODE(_net_bpf, OID_AUTO, stats, CTLFLAG_MPSAFE \| CTLFLAG_RW,
	bpf_stats_sysctl, "bpf statistics portal");

	-static VNET_DEFINE(int, bpf_optimize_writers) = 0;
	+VNET_DEFINE_STATIC(int, bpf_optimize_writers) = 0;
	#define V_bpf_optimize_writers VNET(bpf_optimize_writers)
	SYSCTL_INT(_net_bpf, OID_AUTO, optimize_writers, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(bpf_optimize_writers), 0,
	Index: sys/net/ieee8023ad_lacp.c
	===================================================================
	--- sys/net/ieee8023ad_lacp.c
	+++ sys/net/ieee8023ad_lacp.c
	@@ -194,13 +194,13 @@
	static void lacp_dprintf(const struct lacp_port , const char , ...)
	__attribute__((__format__(__printf__, 2, 3)));

	-static VNET_DEFINE(int, lacp_debug);
	+VNET_DEFINE_STATIC(int, lacp_debug);
	#define V_lacp_debug VNET(lacp_debug)
	SYSCTL_NODE(_net_link_lagg, OID_AUTO, lacp, CTLFLAG_RD, 0, "ieee802.3ad");
	SYSCTL_INT(_net_link_lagg_lacp, OID_AUTO, debug, CTLFLAG_RWTUN \| CTLFLAG_VNET,
	&VNET_NAME(lacp_debug), 0, "Enable LACP debug logging (1=debug, 2=trace)");

	-static VNET_DEFINE(int, lacp_default_strict_mode) = 1;
	+VNET_DEFINE_STATIC(int, lacp_default_strict_mode) = 1;
	SYSCTL_INT(_net_link_lagg_lacp, OID_AUTO, default_strict_mode,
	CTLFLAG_RWTUN \| CTLFLAG_VNET, &VNET_NAME(lacp_default_strict_mode), 0,
	"LACP strict protocol compliance default");
	Index: sys/net/if.c
	===================================================================
	--- sys/net/if.c
	+++ sys/net/if.c
	@@ -293,7 +293,7 @@
	VNET_DEFINE(struct ifnethead, ifnet); /* depend on static init XXX */
	VNET_DEFINE(struct ifgrouphead, ifg_head);

	-static VNET_DEFINE(int, if_indexlim) = 8;
	+VNET_DEFINE_STATIC(int, if_indexlim) = 8;

	/* Table of ifnet by index. */
	VNET_DEFINE(struct ifnet **, ifindex_table);
	Index: sys/net/if_bridge.c
	===================================================================
	--- sys/net/if_bridge.c
	+++ sys/net/if_bridge.c
	@@ -229,7 +229,7 @@
	u_char sc_defaddr[6]; /* Default MAC address */
	};

	-static VNET_DEFINE(struct mtx, bridge_list_mtx);
	+VNET_DEFINE_STATIC(struct mtx, bridge_list_mtx);
	#define V_bridge_list_mtx VNET(bridge_list_mtx)
	static eventhandler_tag bridge_detach_cookie;

	@@ -354,59 +354,59 @@
	static SYSCTL_NODE(_net_link, IFT_BRIDGE, bridge, CTLFLAG_RW, 0, "Bridge");

	/* only pass IP[46] packets when pfil is enabled */
	-static VNET_DEFINE(int, pfil_onlyip) = 1;
	+VNET_DEFINE_STATIC(int, pfil_onlyip) = 1;
	#define V_pfil_onlyip VNET(pfil_onlyip)
	SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_onlyip,
	CTLFLAG_RWTUN \| CTLFLAG_VNET, &VNET_NAME(pfil_onlyip), 0,
	"Only pass IP packets when pfil is enabled");

	/* run pfil hooks on the bridge interface */
	-static VNET_DEFINE(int, pfil_bridge) = 1;
	+VNET_DEFINE_STATIC(int, pfil_bridge) = 1;
	#define V_pfil_bridge VNET(pfil_bridge)
	SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_bridge,
	CTLFLAG_RWTUN \| CTLFLAG_VNET, &VNET_NAME(pfil_bridge), 0,
	"Packet filter on the bridge interface");

	/* layer2 filter with ipfw */
	-static VNET_DEFINE(int, pfil_ipfw);
	+VNET_DEFINE_STATIC(int, pfil_ipfw);
	#define V_pfil_ipfw VNET(pfil_ipfw)

	/* layer2 ARP filter with ipfw */
	-static VNET_DEFINE(int, pfil_ipfw_arp);
	+VNET_DEFINE_STATIC(int, pfil_ipfw_arp);
	#define V_pfil_ipfw_arp VNET(pfil_ipfw_arp)
	SYSCTL_INT(_net_link_bridge, OID_AUTO, ipfw_arp,
	CTLFLAG_RWTUN \| CTLFLAG_VNET, &VNET_NAME(pfil_ipfw_arp), 0,
	"Filter ARP packets through IPFW layer2");

	/* run pfil hooks on the member interface */
	-static VNET_DEFINE(int, pfil_member) = 1;
	+VNET_DEFINE_STATIC(int, pfil_member) = 1;
	#define V_pfil_member VNET(pfil_member)
	SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_member,
	CTLFLAG_RWTUN \| CTLFLAG_VNET, &VNET_NAME(pfil_member), 0,
	"Packet filter on the member interface");

	/* run pfil hooks on the physical interface for locally destined packets */
	-static VNET_DEFINE(int, pfil_local_phys);
	+VNET_DEFINE_STATIC(int, pfil_local_phys);
	#define V_pfil_local_phys VNET(pfil_local_phys)
	SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_local_phys,
	CTLFLAG_RWTUN \| CTLFLAG_VNET, &VNET_NAME(pfil_local_phys), 0,
	"Packet filter on the physical interface for locally destined packets");

	/* log STP state changes */
	-static VNET_DEFINE(int, log_stp);
	+VNET_DEFINE_STATIC(int, log_stp);
	#define V_log_stp VNET(log_stp)
	SYSCTL_INT(_net_link_bridge, OID_AUTO, log_stp,
	CTLFLAG_RWTUN \| CTLFLAG_VNET, &VNET_NAME(log_stp), 0,
	"Log STP state changes");

	/* share MAC with first bridge member */
	-static VNET_DEFINE(int, bridge_inherit_mac);
	+VNET_DEFINE_STATIC(int, bridge_inherit_mac);
	#define V_bridge_inherit_mac VNET(bridge_inherit_mac)
	SYSCTL_INT(_net_link_bridge, OID_AUTO, inherit_mac,
	CTLFLAG_RWTUN \| CTLFLAG_VNET, &VNET_NAME(bridge_inherit_mac), 0,
	"Inherit MAC address from the first bridge member");

	-static VNET_DEFINE(int, allow_llz_overlap) = 0;
	+VNET_DEFINE_STATIC(int, allow_llz_overlap) = 0;
	#define V_allow_llz_overlap VNET(allow_llz_overlap)
	SYSCTL_INT(_net_link_bridge, OID_AUTO, allow_llz_overlap,
	CTLFLAG_RW \| CTLFLAG_VNET, &VNET_NAME(allow_llz_overlap), 0,
	@@ -510,7 +510,7 @@
	};
	const int bridge_control_table_size = nitems(bridge_control_table);

	-static VNET_DEFINE(LIST_HEAD(, bridge_softc), bridge_list);
	+VNET_DEFINE_STATIC(LIST_HEAD(, bridge_softc), bridge_list);
	#define V_bridge_list VNET(bridge_list)
	#define BRIDGE_LIST_LOCK_INIT(x) mtx_init(&V_bridge_list_mtx, \
	"if_bridge list", NULL, MTX_DEF)
	@@ -518,7 +518,7 @@
	#define BRIDGE_LIST_LOCK(x) mtx_lock(&V_bridge_list_mtx)
	#define BRIDGE_LIST_UNLOCK(x) mtx_unlock(&V_bridge_list_mtx)

	-static VNET_DEFINE(struct if_clone *, bridge_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, bridge_cloner);
	#define V_bridge_cloner VNET(bridge_cloner)

	static const char bridge_name[] = "bridge";
	Index: sys/net/if_clone.c
	===================================================================
	--- sys/net/if_clone.c
	+++ sys/net/if_clone.c
	@@ -108,7 +108,7 @@

	static struct mtx if_cloners_mtx;
	MTX_SYSINIT(if_cloners_lock, &if_cloners_mtx, "if_cloners lock", MTX_DEF);
	-static VNET_DEFINE(int, if_cloners_count);
	+VNET_DEFINE_STATIC(int, if_cloners_count);
	VNET_DEFINE(LIST_HEAD(, if_clone), if_cloners);

	#define V_if_cloners_count VNET(if_cloners_count)
	Index: sys/net/if_disc.c
	===================================================================
	--- sys/net/if_disc.c
	+++ sys/net/if_disc.c
	@@ -76,7 +76,7 @@
	static const char discname[] = "disc";
	static MALLOC_DEFINE(M_DISC, discname, "Discard interface");

	-static VNET_DEFINE(struct if_clone *, disc_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, disc_cloner);
	#define V_disc_cloner VNET(disc_cloner)

	static int
	Index: sys/net/if_edsc.c
	===================================================================
	--- sys/net/if_edsc.c
	+++ sys/net/if_edsc.c
	@@ -72,7 +72,7 @@
	/*
	* Attach to the interface cloning framework.
	*/
	-static VNET_DEFINE(struct if_clone *, edsc_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, edsc_cloner);
	#define V_edsc_cloner VNET(edsc_cloner)
	static int edsc_clone_create(struct if_clone *, int, caddr_t);
	static void edsc_clone_destroy(struct ifnet *);
	Index: sys/net/if_enc.c
	===================================================================
	--- sys/net/if_enc.c
	+++ sys/net/if_enc.c
	@@ -86,9 +86,9 @@
	struct enc_softc {
	struct ifnet *sc_ifp;
	};
	-static VNET_DEFINE(struct enc_softc *, enc_sc);
	+VNET_DEFINE_STATIC(struct enc_softc *, enc_sc);
	#define V_enc_sc VNET(enc_sc)
	-static VNET_DEFINE(struct if_clone *, enc_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, enc_cloner);
	#define V_enc_cloner VNET(enc_cloner)

	static int enc_ioctl(struct ifnet *, u_long, caddr_t);
	@@ -111,10 +111,10 @@
	* some changes to the packet, e.g. address translation. If PFIL hook
	* consumes mbuf, nothing will be captured.
	*/
	-static VNET_DEFINE(int, filter_mask_in) = IPSEC_ENC_BEFORE;
	-static VNET_DEFINE(int, bpf_mask_in) = IPSEC_ENC_BEFORE;
	-static VNET_DEFINE(int, filter_mask_out) = IPSEC_ENC_BEFORE;
	-static VNET_DEFINE(int, bpf_mask_out) = IPSEC_ENC_BEFORE \| IPSEC_ENC_AFTER;
	+VNET_DEFINE_STATIC(int, filter_mask_in) = IPSEC_ENC_BEFORE;
	+VNET_DEFINE_STATIC(int, bpf_mask_in) = IPSEC_ENC_BEFORE;
	+VNET_DEFINE_STATIC(int, filter_mask_out) = IPSEC_ENC_BEFORE;
	+VNET_DEFINE_STATIC(int, bpf_mask_out) = IPSEC_ENC_BEFORE \| IPSEC_ENC_AFTER;
	#define V_filter_mask_in VNET(filter_mask_in)
	#define V_bpf_mask_in VNET(bpf_mask_in)
	#define V_filter_mask_out VNET(filter_mask_out)
	Index: sys/net/if_epair.c
	===================================================================
	--- sys/net/if_epair.c
	+++ sys/net/if_epair.c
	@@ -179,7 +179,7 @@
	static MALLOC_DEFINE(M_EPAIR, epairname,
	"Pair of virtual cross-over connected Ethernet-like interfaces");

	-static VNET_DEFINE(struct if_clone *, epair_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, epair_cloner);
	#define V_epair_cloner VNET(epair_cloner)

	/*
	Index: sys/net/if_ethersubr.c
	===================================================================
	--- sys/net/if_ethersubr.c
	+++ sys/net/if_ethersubr.c
	@@ -1291,7 +1291,7 @@
	static SYSCTL_NODE(_net_link_vlan, PF_LINK, link, CTLFLAG_RW, 0,
	"for consistency");

	-static VNET_DEFINE(int, soft_pad);
	+VNET_DEFINE_STATIC(int, soft_pad);
	#define V_soft_pad VNET(soft_pad)
	SYSCTL_INT(_net_link_vlan, OID_AUTO, soft_pad, CTLFLAG_RW \| CTLFLAG_VNET,
	&VNET_NAME(soft_pad), 0,
	Index: sys/net/if_gif.c
	===================================================================
	--- sys/net/if_gif.c
	+++ sys/net/if_gif.c
	@@ -110,7 +110,7 @@
	static void gif_qflush(struct ifnet *);
	static int gif_clone_create(struct if_clone *, int, caddr_t);
	static void gif_clone_destroy(struct ifnet *);
	-static VNET_DEFINE(struct if_clone *, gif_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, gif_cloner);
	#define V_gif_cloner VNET(gif_cloner)

	SYSCTL_DECL(_net_link);
	@@ -127,7 +127,7 @@
	*/
	#define MAX_GIF_NEST 1
	#endif
	-static VNET_DEFINE(int, max_gif_nesting) = MAX_GIF_NEST;
	+VNET_DEFINE_STATIC(int, max_gif_nesting) = MAX_GIF_NEST;
	#define V_max_gif_nesting VNET(max_gif_nesting)
	SYSCTL_INT(_net_link_gif, OID_AUTO, max_nesting, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(max_gif_nesting), 0, "Max nested tunnels");
	Index: sys/net/if_gre.c
	===================================================================
	--- sys/net/if_gre.c
	+++ sys/net/if_gre.c
	@@ -94,7 +94,7 @@

	static int gre_clone_create(struct if_clone *, int, caddr_t);
	static void gre_clone_destroy(struct ifnet *);
	-static VNET_DEFINE(struct if_clone *, gre_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, gre_cloner);
	#define V_gre_cloner VNET(gre_cloner)

	static void gre_qflush(struct ifnet *);
	@@ -119,7 +119,7 @@
	#define MAX_GRE_NEST 1
	#endif

	-static VNET_DEFINE(int, max_gre_nesting) = MAX_GRE_NEST;
	+VNET_DEFINE_STATIC(int, max_gre_nesting) = MAX_GRE_NEST;
	#define V_max_gre_nesting VNET(max_gre_nesting)
	SYSCTL_INT(_net_link_gre, OID_AUTO, max_nesting, CTLFLAG_RW \| CTLFLAG_VNET,
	&VNET_NAME(max_gre_nesting), 0, "Max nested tunnels");
	Index: sys/net/if_ipsec.c
	===================================================================
	--- sys/net/if_ipsec.c
	+++ sys/net/if_ipsec.c
	@@ -120,9 +120,9 @@
	#define IPSEC_SC_WLOCK_ASSERT() rm_assert(&ipsec_sc_lock, RA_WLOCKED)

	LIST_HEAD(ipsec_iflist, ipsec_softc);
	-static VNET_DEFINE(struct ipsec_iflist, ipsec_sc_list);
	-static VNET_DEFINE(struct ipsec_iflist *, ipsec_sc_htbl);
	-static VNET_DEFINE(u_long, ipsec_sc_hmask);
	+VNET_DEFINE_STATIC(struct ipsec_iflist, ipsec_sc_list);
	+VNET_DEFINE_STATIC(struct ipsec_iflist *, ipsec_sc_htbl);
	+VNET_DEFINE_STATIC(u_long, ipsec_sc_hmask);
	#define V_ipsec_sc_list VNET(ipsec_sc_list)
	#define V_ipsec_sc_htbl VNET(ipsec_sc_htbl)
	#define V_ipsec_sc_hmask VNET(ipsec_sc_hmask)
	@@ -162,7 +162,7 @@
	static int ipsec_clone_create(struct if_clone *, int, caddr_t);
	static void ipsec_clone_destroy(struct ifnet *);

	-static VNET_DEFINE(struct if_clone *, ipsec_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, ipsec_cloner);
	#define V_ipsec_cloner VNET(ipsec_cloner)

	static int
	Index: sys/net/if_lagg.c
	===================================================================
	--- sys/net/if_lagg.c
	+++ sys/net/if_lagg.c
	@@ -97,7 +97,7 @@

	VNET_DEFINE(SLIST_HEAD(__trhead, lagg_softc), lagg_list); /* list of laggs */
	#define V_lagg_list VNET(lagg_list)
	-static VNET_DEFINE(struct mtx, lagg_list_mtx);
	+VNET_DEFINE_STATIC(struct mtx, lagg_list_mtx);
	#define V_lagg_list_mtx VNET(lagg_list_mtx)
	#define LAGG_LIST_LOCK_INIT(x) mtx_init(&V_lagg_list_mtx, \
	"if_lagg list", NULL, MTX_DEF)
	@@ -108,7 +108,7 @@

	static int lagg_clone_create(struct if_clone *, int, caddr_t);
	static void lagg_clone_destroy(struct ifnet *);
	-static VNET_DEFINE(struct if_clone *, lagg_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, lagg_cloner);
	#define V_lagg_cloner VNET(lagg_cloner)
	static const char laggname[] = "lagg";

	@@ -249,21 +249,21 @@
	"Link Aggregation");

	/* Allow input on any failover links */
	-static VNET_DEFINE(int, lagg_failover_rx_all);
	+VNET_DEFINE_STATIC(int, lagg_failover_rx_all);
	#define V_lagg_failover_rx_all VNET(lagg_failover_rx_all)
	SYSCTL_INT(_net_link_lagg, OID_AUTO, failover_rx_all, CTLFLAG_RW \| CTLFLAG_VNET,
	&VNET_NAME(lagg_failover_rx_all), 0,
	"Accept input from any interface in a failover lagg");

	/* Default value for using flowid */
	-static VNET_DEFINE(int, def_use_flowid) = 0;
	+VNET_DEFINE_STATIC(int, def_use_flowid) = 0;
	#define V_def_use_flowid VNET(def_use_flowid)
	SYSCTL_INT(_net_link_lagg, OID_AUTO, default_use_flowid, CTLFLAG_RWTUN,
	&VNET_NAME(def_use_flowid), 0,
	"Default setting for using flow id for load sharing");

	/* Default value for flowid shift */
	-static VNET_DEFINE(int, def_flowid_shift) = 16;
	+VNET_DEFINE_STATIC(int, def_flowid_shift) = 16;
	#define V_def_flowid_shift VNET(def_flowid_shift)
	SYSCTL_INT(_net_link_lagg, OID_AUTO, default_flowid_shift, CTLFLAG_RWTUN,
	&VNET_NAME(def_flowid_shift), 0,
	Index: sys/net/if_llatbl.c
	===================================================================
	--- sys/net/if_llatbl.c
	+++ sys/net/if_llatbl.c
	@@ -64,7 +64,7 @@

	MALLOC_DEFINE(M_LLTABLE, "lltable", "link level address tables");

	-static VNET_DEFINE(SLIST_HEAD(, lltable), lltables) =
	+VNET_DEFINE_STATIC(SLIST_HEAD(, lltable), lltables) =
	SLIST_HEAD_INITIALIZER(lltables);
	#define V_lltables VNET(lltables)

	Index: sys/net/if_loop.c
	===================================================================
	--- sys/net/if_loop.c
	+++ sys/net/if_loop.c
	@@ -99,7 +99,7 @@
	VNET_DEFINE(struct ifnet , loif); / Used externally */

	#ifdef VIMAGE
	-static VNET_DEFINE(struct if_clone *, lo_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, lo_cloner);
	#define V_lo_cloner VNET(lo_cloner)
	#endif

	Index: sys/net/if_me.c
	===================================================================
	--- sys/net/if_me.c
	+++ sys/net/if_me.c
	@@ -94,7 +94,7 @@
	#ifndef ME_HASH_SIZE
	#define ME_HASH_SIZE (1 << 4)
	#endif
	-static VNET_DEFINE(struct me_list *, me_hashtbl) = NULL;
	+VNET_DEFINE_STATIC(struct me_list *, me_hashtbl) = NULL;
	#define V_me_hashtbl VNET(me_hashtbl)
	#define ME_HASH(src, dst) (V_me_hashtbl[\
	me_hashval((src), (dst)) & (ME_HASH_SIZE - 1)])
	@@ -104,7 +104,7 @@

	static int me_clone_create(struct if_clone *, int, caddr_t);
	static void me_clone_destroy(struct ifnet *);
	-static VNET_DEFINE(struct if_clone *, me_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, me_cloner);
	#define V_me_cloner VNET(me_cloner)

	static void me_qflush(struct ifnet *);
	@@ -124,7 +124,7 @@
	#define MAX_ME_NEST 1
	#endif

	-static VNET_DEFINE(int, max_me_nesting) = MAX_ME_NEST;
	+VNET_DEFINE_STATIC(int, max_me_nesting) = MAX_ME_NEST;
	#define V_max_me_nesting VNET(max_me_nesting)
	SYSCTL_INT(_net_link_me, OID_AUTO, max_nesting, CTLFLAG_RW \| CTLFLAG_VNET,
	&VNET_NAME(max_me_nesting), 0, "Max nested tunnels");
	Index: sys/net/if_vlan.c
	===================================================================
	--- sys/net/if_vlan.c
	+++ sys/net/if_vlan.c
	@@ -335,7 +335,7 @@
	static struct if_clone *vlan_cloner;

	#ifdef VIMAGE
	-static VNET_DEFINE(struct if_clone *, vlan_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, vlan_cloner);
	#define V_vlan_cloner VNET(vlan_cloner)
	#endif

	Index: sys/net/netisr.c
	===================================================================
	--- sys/net/netisr.c
	+++ sys/net/netisr.c
	@@ -225,7 +225,7 @@
	* mechanism to stop netisr processing for vnet teardown.
	* Apart from that we expect a VNET to always be enabled.
	*/
	-static VNET_DEFINE(u_int, netisr_enable[NETISR_MAXPROT]);
	+VNET_DEFINE_STATIC(u_int, netisr_enable[NETISR_MAXPROT]);
	#define V_netisr_enable VNET(netisr_enable)
	#endif

	Index: sys/net/route.c
	===================================================================
	--- sys/net/route.c
	+++ sys/net/route.c
	@@ -137,7 +137,7 @@
	*/
	#define RNTORT(p) ((struct rtentry *)(p))

	-static VNET_DEFINE(uma_zone_t, rtzone); /* Routing table UMA zone. */
	+VNET_DEFINE_STATIC(uma_zone_t, rtzone); /* Routing table UMA zone. */
	#define V_rtzone VNET(rtzone)

	static int rtrequest1_fib_change(struct rib_head , struct rt_addrinfo ,
	Index: sys/net/rtsock.c
	===================================================================
	--- sys/net/rtsock.c
	+++ sys/net/rtsock.c
	@@ -140,7 +140,7 @@
	int ip6_count; /* attached w/ AF_INET6 */
	int any_count; /* total attached */
	} route_cb_t;
	-static VNET_DEFINE(route_cb_t, route_cb);
	+VNET_DEFINE_STATIC(route_cb_t, route_cb);
	#define V_route_cb VNET(route_cb)

	struct mtx rtsock_mtx;
	Index: sys/net/vnet.h
	===================================================================
	--- sys/net/vnet.h
	+++ sys/net/vnet.h
	@@ -93,6 +93,8 @@

	#define VNET_PCPUSTAT_DEFINE(type, name) \
	VNET_DEFINE(counter_u64_t, name[sizeof(type) / sizeof(uint64_t)])
	+#define VNET_PCPUSTAT_DEFINE_STATIC(type, name) \
	+ VNET_DEFINE_STATIC(counter_u64_t, name[sizeof(type) / sizeof(uint64_t)])

	#define VNET_PCPUSTAT_ALLOC(name, wait) \
	COUNTER_ARRAY_ALLOC(VNET(name), \
	@@ -268,7 +270,11 @@
	*/
	#define VNET_NAME(n) vnet_entry_##n
	#define VNET_DECLARE(t, n) extern t VNET_NAME(n)
	-#define VNET_DEFINE(t, n) t VNET_NAME(n) __section(VNET_SETNAME) __used
	+/* struct _hack is to stop this from being used with static data */
	+#define VNET_DEFINE(t, n) \
	+ struct _hack; t VNET_NAME(n) __section(VNET_SETNAME) __used
	+#define VNET_DEFINE_STATIC(t, n) \
	+ static t VNET_NAME(n) __section(VNET_SETNAME) __used
	#define _VNET_PTR(b, n) (__typeof(VNET_NAME(n))*) \
	((b) + (uintptr_t)&VNET_NAME(n))

	@@ -400,7 +406,8 @@
	*/
	#define VNET_NAME(n) n
	#define VNET_DECLARE(t, n) extern t n
	-#define VNET_DEFINE(t, n) t n
	+#define VNET_DEFINE(t, n) struct _hack; t n
	+#define VNET_DEFINE_STATIC(t, n) static t n
	#define _VNET_PTR(b, n) &VNET_NAME(n)

	/*
	Index: sys/net/vnet.c
	===================================================================
	--- sys/net/vnet.c
	+++ sys/net/vnet.c
	@@ -178,7 +178,7 @@
	* Space to store virtualized global variables from loadable kernel modules,
	* and the free list to manage it.
	*/
	-static VNET_DEFINE(char, modspace[VNET_MODMIN]);
	+VNET_DEFINE_STATIC(char, modspace[VNET_MODMIN]);

	/*
	* Global lists of subsystem constructor and destructors for vnets. They are
	Index: sys/netgraph/ng_base.c
	===================================================================
	--- sys/netgraph/ng_base.c
	+++ sys/netgraph/ng_base.c
	@@ -179,12 +179,12 @@

	/* Hash related definitions. */
	LIST_HEAD(nodehash, ng_node);
	-static VNET_DEFINE(struct nodehash *, ng_ID_hash);
	-static VNET_DEFINE(u_long, ng_ID_hmask);
	-static VNET_DEFINE(u_long, ng_nodes);
	-static VNET_DEFINE(struct nodehash *, ng_name_hash);
	-static VNET_DEFINE(u_long, ng_name_hmask);
	-static VNET_DEFINE(u_long, ng_named_nodes);
	+VNET_DEFINE_STATIC(struct nodehash *, ng_ID_hash);
	+VNET_DEFINE_STATIC(u_long, ng_ID_hmask);
	+VNET_DEFINE_STATIC(u_long, ng_nodes);
	+VNET_DEFINE_STATIC(struct nodehash *, ng_name_hash);
	+VNET_DEFINE_STATIC(u_long, ng_name_hmask);
	+VNET_DEFINE_STATIC(u_long, ng_named_nodes);
	#define V_ng_ID_hash VNET(ng_ID_hash)
	#define V_ng_ID_hmask VNET(ng_ID_hmask)
	#define V_ng_nodes VNET(ng_nodes)
	@@ -377,7 +377,7 @@
	#define TRAP_ERROR()
	#endif

	-static VNET_DEFINE(ng_ID_t, nextID) = 1;
	+VNET_DEFINE_STATIC(ng_ID_t, nextID) = 1;
	#define V_nextID VNET(nextID)

	#ifdef INVARIANTS
	Index: sys/netgraph/ng_eiface.c
	===================================================================
	--- sys/netgraph/ng_eiface.c
	+++ sys/netgraph/ng_eiface.c
	@@ -122,7 +122,7 @@
	};
	NETGRAPH_INIT(eiface, &typestruct);

	-static VNET_DEFINE(struct unrhdr *, ng_eiface_unit);
	+VNET_DEFINE_STATIC(struct unrhdr *, ng_eiface_unit);
	#define V_ng_eiface_unit VNET(ng_eiface_unit)

	/************************************************************************
	Index: sys/netgraph/ng_iface.c
	===================================================================
	--- sys/netgraph/ng_iface.c
	+++ sys/netgraph/ng_iface.c
	@@ -199,7 +199,7 @@
	};
	NETGRAPH_INIT(iface, &typestruct);

	-static VNET_DEFINE(struct unrhdr *, ng_iface_unit);
	+VNET_DEFINE_STATIC(struct unrhdr *, ng_iface_unit);
	#define V_ng_iface_unit VNET(ng_iface_unit)

	/************************************************************************
	Index: sys/netinet/cc/cc_cdg.c
	===================================================================
	--- sys/netinet/cc/cc_cdg.c
	+++ sys/netinet/cc/cc_cdg.c
	@@ -205,13 +205,13 @@

	static int ertt_id;

	-static VNET_DEFINE(uint32_t, cdg_alpha_inc);
	-static VNET_DEFINE(uint32_t, cdg_beta_delay);
	-static VNET_DEFINE(uint32_t, cdg_beta_loss);
	-static VNET_DEFINE(uint32_t, cdg_smoothing_factor);
	-static VNET_DEFINE(uint32_t, cdg_exp_backoff_scale);
	-static VNET_DEFINE(uint32_t, cdg_consec_cong);
	-static VNET_DEFINE(uint32_t, cdg_hold_backoff);
	+VNET_DEFINE_STATIC(uint32_t, cdg_alpha_inc);
	+VNET_DEFINE_STATIC(uint32_t, cdg_beta_delay);
	+VNET_DEFINE_STATIC(uint32_t, cdg_beta_loss);
	+VNET_DEFINE_STATIC(uint32_t, cdg_smoothing_factor);
	+VNET_DEFINE_STATIC(uint32_t, cdg_exp_backoff_scale);
	+VNET_DEFINE_STATIC(uint32_t, cdg_consec_cong);
	+VNET_DEFINE_STATIC(uint32_t, cdg_hold_backoff);
	#define V_cdg_alpha_inc VNET(cdg_alpha_inc)
	#define V_cdg_beta_delay VNET(cdg_beta_delay)
	#define V_cdg_beta_loss VNET(cdg_beta_loss)
	Index: sys/netinet/cc/cc_chd.c
	===================================================================
	--- sys/netinet/cc/cc_chd.c
	+++ sys/netinet/cc/cc_chd.c
	@@ -117,11 +117,11 @@

	static int ertt_id;

	-static VNET_DEFINE(uint32_t, chd_qmin) = 5;
	-static VNET_DEFINE(uint32_t, chd_pmax) = 50;
	-static VNET_DEFINE(uint32_t, chd_loss_fair) = 1;
	-static VNET_DEFINE(uint32_t, chd_use_max) = 1;
	-static VNET_DEFINE(uint32_t, chd_qthresh) = 20;
	+VNET_DEFINE_STATIC(uint32_t, chd_qmin) = 5;
	+VNET_DEFINE_STATIC(uint32_t, chd_pmax) = 50;
	+VNET_DEFINE_STATIC(uint32_t, chd_loss_fair) = 1;
	+VNET_DEFINE_STATIC(uint32_t, chd_use_max) = 1;
	+VNET_DEFINE_STATIC(uint32_t, chd_qthresh) = 20;
	#define V_chd_qthresh VNET(chd_qthresh)
	#define V_chd_qmin VNET(chd_qmin)
	#define V_chd_pmax VNET(chd_pmax)
	Index: sys/netinet/cc/cc_dctcp.c
	===================================================================
	--- sys/netinet/cc/cc_dctcp.c
	+++ sys/netinet/cc/cc_dctcp.c
	@@ -59,11 +59,11 @@
	#define CAST_PTR_INT(X) (((int)(X)))

	#define MAX_ALPHA_VALUE 1024
	-static VNET_DEFINE(uint32_t, dctcp_alpha) = 0;
	+VNET_DEFINE_STATIC(uint32_t, dctcp_alpha) = 0;
	#define V_dctcp_alpha VNET(dctcp_alpha)
	-static VNET_DEFINE(uint32_t, dctcp_shift_g) = 4;
	+VNET_DEFINE_STATIC(uint32_t, dctcp_shift_g) = 4;
	#define V_dctcp_shift_g VNET(dctcp_shift_g)
	-static VNET_DEFINE(uint32_t, dctcp_slowstart) = 0;
	+VNET_DEFINE_STATIC(uint32_t, dctcp_slowstart) = 0;
	#define V_dctcp_slowstart VNET(dctcp_slowstart)

	struct dctcp {
	Index: sys/netinet/cc/cc_hd.c
	===================================================================
	--- sys/netinet/cc/cc_hd.c
	+++ sys/netinet/cc/cc_hd.c
	@@ -89,9 +89,9 @@

	static int ertt_id;

	-static VNET_DEFINE(uint32_t, hd_qthresh) = 20;
	-static VNET_DEFINE(uint32_t, hd_qmin) = 5;
	-static VNET_DEFINE(uint32_t, hd_pmax) = 5;
	+VNET_DEFINE_STATIC(uint32_t, hd_qthresh) = 20;
	+VNET_DEFINE_STATIC(uint32_t, hd_qmin) = 5;
	+VNET_DEFINE_STATIC(uint32_t, hd_pmax) = 5;
	#define V_hd_qthresh VNET(hd_qthresh)
	#define V_hd_qmin VNET(hd_qmin)
	#define V_hd_pmax VNET(hd_pmax)
	Index: sys/netinet/cc/cc_htcp.c
	===================================================================
	--- sys/netinet/cc/cc_htcp.c
	+++ sys/netinet/cc/cc_htcp.c
	@@ -170,8 +170,8 @@
	static int htcp_max_diff = INT_MAX / ((1 << HTCP_ALPHA_INC_SHIFT) * 10);

	/* Per-netstack vars. */
	-static VNET_DEFINE(u_int, htcp_adaptive_backoff) = 0;
	-static VNET_DEFINE(u_int, htcp_rtt_scaling) = 0;
	+VNET_DEFINE_STATIC(u_int, htcp_adaptive_backoff) = 0;
	+VNET_DEFINE_STATIC(u_int, htcp_rtt_scaling) = 0;
	#define V_htcp_adaptive_backoff VNET(htcp_adaptive_backoff)
	#define V_htcp_rtt_scaling VNET(htcp_rtt_scaling)

	Index: sys/netinet/cc/cc_newreno.c
	===================================================================
	--- sys/netinet/cc/cc_newreno.c
	+++ sys/netinet/cc/cc_newreno.c
	@@ -88,8 +88,8 @@
	static void newreno_post_recovery(struct cc_var *ccv);
	static int newreno_ctl_output(struct cc_var ccv, struct sockopt sopt, void *buf);

	-static VNET_DEFINE(uint32_t, newreno_beta) = 50;
	-static VNET_DEFINE(uint32_t, newreno_beta_ecn) = 80;
	+VNET_DEFINE_STATIC(uint32_t, newreno_beta) = 50;
	+VNET_DEFINE_STATIC(uint32_t, newreno_beta_ecn) = 80;
	#define V_newreno_beta VNET(newreno_beta)
	#define V_newreno_beta_ecn VNET(newreno_beta_ecn)

	Index: sys/netinet/cc/cc_vegas.c
	===================================================================
	--- sys/netinet/cc/cc_vegas.c
	+++ sys/netinet/cc/cc_vegas.c
	@@ -100,8 +100,8 @@

	static int32_t ertt_id;

	-static VNET_DEFINE(uint32_t, vegas_alpha) = 1;
	-static VNET_DEFINE(uint32_t, vegas_beta) = 3;
	+VNET_DEFINE_STATIC(uint32_t, vegas_alpha) = 1;
	+VNET_DEFINE_STATIC(uint32_t, vegas_beta) = 3;
	#define V_vegas_alpha VNET(vegas_alpha)
	#define V_vegas_beta VNET(vegas_beta)

	Index: sys/netinet/if_ether.c
	===================================================================
	--- sys/netinet/if_ether.c
	+++ sys/netinet/if_ether.c
	@@ -94,13 +94,13 @@
	static SYSCTL_NODE(_net_link_ether, PF_ARP, arp, CTLFLAG_RW, 0, "");

	/* timer values */
	-static VNET_DEFINE(int, arpt_keep) = (2060); / once resolved, good for 20
	+VNET_DEFINE_STATIC(int, arpt_keep) = (2060); / once resolved, good for 20
	* minutes */
	-static VNET_DEFINE(int, arp_maxtries) = 5;
	-static VNET_DEFINE(int, arp_proxyall) = 0;
	-static VNET_DEFINE(int, arpt_down) = 20; /* keep incomplete entries for
	+VNET_DEFINE_STATIC(int, arp_maxtries) = 5;
	+VNET_DEFINE_STATIC(int, arp_proxyall) = 0;
	+VNET_DEFINE_STATIC(int, arpt_down) = 20; /* keep incomplete entries for
	* 20 seconds */
	-static VNET_DEFINE(int, arpt_rexmit) = 1; /* retransmit arp entries, sec*/
	+VNET_DEFINE_STATIC(int, arpt_rexmit) = 1; /* retransmit arp entries, sec*/
	VNET_PCPUSTAT_DEFINE(struct arpstat, arpstat); /* ARP statistics, see if_arp.h */
	VNET_PCPUSTAT_SYSINIT(arpstat);

	@@ -108,7 +108,7 @@
	VNET_PCPUSTAT_SYSUNINIT(arpstat);
	#endif /* VIMAGE */

	-static VNET_DEFINE(int, arp_maxhold) = 1;
	+VNET_DEFINE_STATIC(int, arp_maxhold) = 1;

	#define V_arpt_keep VNET(arpt_keep)
	#define V_arpt_down VNET(arpt_down)
	Index: sys/netinet/igmp.c
	===================================================================
	--- sys/netinet/igmp.c
	+++ sys/netinet/igmp.c
	@@ -217,11 +217,11 @@
	* FUTURE: Stop using IFP_TO_IA/INADDR_ANY, and use source address selection
	* policy to control the address used by IGMP on the link.
	*/
	-static VNET_DEFINE(int, interface_timers_running); /* IGMPv3 general
	+VNET_DEFINE_STATIC(int, interface_timers_running); /* IGMPv3 general
	* query response */
	-static VNET_DEFINE(int, state_change_timers_running); /* IGMPv3 state-change
	+VNET_DEFINE_STATIC(int, state_change_timers_running); /* IGMPv3 state-change
	* retransmit */
	-static VNET_DEFINE(int, current_state_timers_running); /* IGMPv1/v2 host
	+VNET_DEFINE_STATIC(int, current_state_timers_running); /* IGMPv1/v2 host
	* report; IGMPv3 g/sg
	* query response */

	@@ -229,25 +229,25 @@
	#define V_state_change_timers_running VNET(state_change_timers_running)
	#define V_current_state_timers_running VNET(current_state_timers_running)

	-static VNET_DEFINE(LIST_HEAD(, igmp_ifsoftc), igi_head) =
	+VNET_DEFINE_STATIC(LIST_HEAD(, igmp_ifsoftc), igi_head) =
	LIST_HEAD_INITIALIZER(igi_head);
	-static VNET_DEFINE(struct igmpstat, igmpstat) = {
	+VNET_DEFINE_STATIC(struct igmpstat, igmpstat) = {
	.igps_version = IGPS_VERSION_3,
	.igps_len = sizeof(struct igmpstat),
	};
	-static VNET_DEFINE(struct timeval, igmp_gsrdelay) = {10, 0};
	+VNET_DEFINE_STATIC(struct timeval, igmp_gsrdelay) = {10, 0};

	#define V_igi_head VNET(igi_head)
	#define V_igmpstat VNET(igmpstat)
	#define V_igmp_gsrdelay VNET(igmp_gsrdelay)

	-static VNET_DEFINE(int, igmp_recvifkludge) = 1;
	-static VNET_DEFINE(int, igmp_sendra) = 1;
	-static VNET_DEFINE(int, igmp_sendlocal) = 1;
	-static VNET_DEFINE(int, igmp_v1enable) = 1;
	-static VNET_DEFINE(int, igmp_v2enable) = 1;
	-static VNET_DEFINE(int, igmp_legacysupp);
	-static VNET_DEFINE(int, igmp_default_version) = IGMP_VERSION_3;
	+VNET_DEFINE_STATIC(int, igmp_recvifkludge) = 1;
	+VNET_DEFINE_STATIC(int, igmp_sendra) = 1;
	+VNET_DEFINE_STATIC(int, igmp_sendlocal) = 1;
	+VNET_DEFINE_STATIC(int, igmp_v1enable) = 1;
	+VNET_DEFINE_STATIC(int, igmp_v2enable) = 1;
	+VNET_DEFINE_STATIC(int, igmp_legacysupp);
	+VNET_DEFINE_STATIC(int, igmp_default_version) = IGMP_VERSION_3;

	#define V_igmp_recvifkludge VNET(igmp_recvifkludge)
	#define V_igmp_sendra VNET(igmp_sendra)
	Index: sys/netinet/in.c
	===================================================================
	--- sys/netinet/in.c
	+++ sys/netinet/in.c
	@@ -78,7 +78,7 @@
	static void in_socktrim(struct sockaddr_in *);
	static void in_purgemaddrs(struct ifnet *);

	-static VNET_DEFINE(int, nosameprefix);
	+VNET_DEFINE_STATIC(int, nosameprefix);
	#define V_nosameprefix VNET(nosameprefix)
	SYSCTL_INT(_net_inet_ip, OID_AUTO, no_same_prefix, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(nosameprefix), 0,
	Index: sys/netinet/in_gif.c
	===================================================================
	--- sys/netinet/in_gif.c
	+++ sys/netinet/in_gif.c
	@@ -72,7 +72,7 @@
	#include <net/if_gif.h>

	#define GIF_TTL 30
	-static VNET_DEFINE(int, ip_gif_ttl) = GIF_TTL;
	+VNET_DEFINE_STATIC(int, ip_gif_ttl) = GIF_TTL;
	#define V_ip_gif_ttl VNET(ip_gif_ttl)
	SYSCTL_INT(_net_inet_ip, IPCTL_GIF_TTL, gifttl, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(ip_gif_ttl), 0, "Default TTL value for encapsulated packets");
	@@ -81,8 +81,8 @@
	* We keep interfaces in a hash table using src+dst as key.
	* Interfaces with GIF_IGNORE_SOURCE flag are linked into plain list.
	*/
	-static VNET_DEFINE(struct gif_list *, ipv4_hashtbl) = NULL;
	-static VNET_DEFINE(struct gif_list, ipv4_list) = CK_LIST_HEAD_INITIALIZER();
	+VNET_DEFINE_STATIC(struct gif_list *, ipv4_hashtbl) = NULL;
	+VNET_DEFINE_STATIC(struct gif_list, ipv4_list) = CK_LIST_HEAD_INITIALIZER();
	#define V_ipv4_hashtbl VNET(ipv4_hashtbl)
	#define V_ipv4_list VNET(ipv4_list)

	Index: sys/netinet/in_pcb.c
	===================================================================
	--- sys/netinet/in_pcb.c
	+++ sys/netinet/in_pcb.c
	@@ -138,7 +138,7 @@
	VNET_DEFINE(int, ipport_randomtime) = 45; /* user controlled via sysctl */
	VNET_DEFINE(int, ipport_stoprandom); /* toggled by ipport_tick */
	VNET_DEFINE(int, ipport_tcpallocs);
	-static VNET_DEFINE(int, ipport_tcplastcount);
	+VNET_DEFINE_STATIC(int, ipport_tcplastcount);

	#define V_ipport_tcplastcount VNET(ipport_tcplastcount)

	Index: sys/netinet/ip_carp.c
	===================================================================
	--- sys/netinet/ip_carp.c
	+++ sys/netinet/ip_carp.c
	@@ -187,31 +187,31 @@
	*/

	/* Accept incoming CARP packets. */
	-static VNET_DEFINE(int, carp_allow) = 1;
	+VNET_DEFINE_STATIC(int, carp_allow) = 1;
	#define V_carp_allow VNET(carp_allow)

	/* Set DSCP in outgoing CARP packets. */
	-static VNET_DEFINE(int, carp_dscp) = 56;
	+VNET_DEFINE_STATIC(int, carp_dscp) = 56;
	#define V_carp_dscp VNET(carp_dscp)

	/* Preempt slower nodes. */
	-static VNET_DEFINE(int, carp_preempt) = 0;
	+VNET_DEFINE_STATIC(int, carp_preempt) = 0;
	#define V_carp_preempt VNET(carp_preempt)

	/* Log level. */
	-static VNET_DEFINE(int, carp_log) = 1;
	+VNET_DEFINE_STATIC(int, carp_log) = 1;
	#define V_carp_log VNET(carp_log)

	/* Global advskew demotion. */
	-static VNET_DEFINE(int, carp_demotion) = 0;
	+VNET_DEFINE_STATIC(int, carp_demotion) = 0;
	#define V_carp_demotion VNET(carp_demotion)

	/* Send error demotion factor. */
	-static VNET_DEFINE(int, carp_senderr_adj) = CARP_MAXSKEW;
	+VNET_DEFINE_STATIC(int, carp_senderr_adj) = CARP_MAXSKEW;
	#define V_carp_senderr_adj VNET(carp_senderr_adj)

	/* Iface down demotion factor. */
	-static VNET_DEFINE(int, carp_ifdown_adj) = CARP_MAXSKEW;
	+VNET_DEFINE_STATIC(int, carp_ifdown_adj) = CARP_MAXSKEW;
	#define V_carp_ifdown_adj VNET(carp_ifdown_adj)

	static int carp_allow_sysctl(SYSCTL_HANDLER_ARGS);
	Index: sys/netinet/ip_divert.c
	===================================================================
	--- sys/netinet/ip_divert.c
	+++ sys/netinet/ip_divert.c
	@@ -111,8 +111,8 @@
	*/

	/* Internal variables. */
	-static VNET_DEFINE(struct inpcbhead, divcb);
	-static VNET_DEFINE(struct inpcbinfo, divcbinfo);
	+VNET_DEFINE_STATIC(struct inpcbhead, divcb);
	+VNET_DEFINE_STATIC(struct inpcbinfo, divcbinfo);

	#define V_divcb VNET(divcb)
	#define V_divcbinfo VNET(divcbinfo)
	Index: sys/netinet/ip_gre.c
	===================================================================
	--- sys/netinet/ip_gre.c
	+++ sys/netinet/ip_gre.c
	@@ -74,7 +74,7 @@
	SYSCTL_INT(_net_inet_ip, OID_AUTO, grettl, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(ip_gre_ttl), 0, "Default TTL value for encapsulated packets");

	-static VNET_DEFINE(struct gre_list *, ipv4_hashtbl) = NULL;
	+VNET_DEFINE_STATIC(struct gre_list *, ipv4_hashtbl) = NULL;
	#define V_ipv4_hashtbl VNET(ipv4_hashtbl)
	#define GRE_HASH(src, dst) (V_ipv4_hashtbl[\
	in_gre_hashval((src), (dst)) & (GRE_HASH_SIZE - 1)])
	Index: sys/netinet/ip_icmp.c
	===================================================================
	--- sys/netinet/ip_icmp.c
	+++ sys/netinet/ip_icmp.c
	@@ -82,13 +82,13 @@
	* routines to turnaround packets back to the originator, and
	* host table maintenance routines.
	*/
	-static VNET_DEFINE(int, icmplim) = 200;
	+VNET_DEFINE_STATIC(int, icmplim) = 200;
	#define V_icmplim VNET(icmplim)
	SYSCTL_INT(_net_inet_icmp, ICMPCTL_ICMPLIM, icmplim, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(icmplim), 0,
	"Maximum number of ICMP responses per second");

	-static VNET_DEFINE(int, icmplim_output) = 1;
	+VNET_DEFINE_STATIC(int, icmplim_output) = 1;
	#define V_icmplim_output VNET(icmplim_output)
	SYSCTL_INT(_net_inet_icmp, OID_AUTO, icmplim_output, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(icmplim_output), 0,
	@@ -104,13 +104,13 @@
	VNET_PCPUSTAT_SYSUNINIT(icmpstat);
	#endif /* VIMAGE */

	-static VNET_DEFINE(int, icmpmaskrepl) = 0;
	+VNET_DEFINE_STATIC(int, icmpmaskrepl) = 0;
	#define V_icmpmaskrepl VNET(icmpmaskrepl)
	SYSCTL_INT(_net_inet_icmp, ICMPCTL_MASKREPL, maskrepl, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(icmpmaskrepl), 0,
	"Reply to ICMP Address Mask Request packets");

	-static VNET_DEFINE(u_int, icmpmaskfake) = 0;
	+VNET_DEFINE_STATIC(u_int, icmpmaskfake) = 0;
	#define V_icmpmaskfake VNET(icmpmaskfake)
	SYSCTL_UINT(_net_inet_icmp, OID_AUTO, maskfake, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(icmpmaskfake), 0,
	@@ -122,37 +122,37 @@
	&VNET_NAME(drop_redirect), 0,
	"Ignore ICMP redirects");

	-static VNET_DEFINE(int, log_redirect) = 0;
	+VNET_DEFINE_STATIC(int, log_redirect) = 0;
	#define V_log_redirect VNET(log_redirect)
	SYSCTL_INT(_net_inet_icmp, OID_AUTO, log_redirect, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(log_redirect), 0,
	"Log ICMP redirects to the console");

	-static VNET_DEFINE(char, reply_src[IFNAMSIZ]);
	+VNET_DEFINE_STATIC(char, reply_src[IFNAMSIZ]);
	#define V_reply_src VNET(reply_src)
	SYSCTL_STRING(_net_inet_icmp, OID_AUTO, reply_src, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(reply_src), IFNAMSIZ,
	"ICMP reply source for non-local packets");

	-static VNET_DEFINE(int, icmp_rfi) = 0;
	+VNET_DEFINE_STATIC(int, icmp_rfi) = 0;
	#define V_icmp_rfi VNET(icmp_rfi)
	SYSCTL_INT(_net_inet_icmp, OID_AUTO, reply_from_interface, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(icmp_rfi), 0,
	"ICMP reply from incoming interface for non-local packets");
	/* Router requirements RFC 1812 section 4.3.2.3 requires 576 - 28. */
	-static VNET_DEFINE(int, icmp_quotelen) = 548;
	+VNET_DEFINE_STATIC(int, icmp_quotelen) = 8;
	#define V_icmp_quotelen VNET(icmp_quotelen)
	SYSCTL_INT(_net_inet_icmp, OID_AUTO, quotelen, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(icmp_quotelen), 0,
	"Number of bytes from original packet to quote in ICMP reply");

	-static VNET_DEFINE(int, icmpbmcastecho) = 0;
	+VNET_DEFINE_STATIC(int, icmpbmcastecho) = 0;
	#define V_icmpbmcastecho VNET(icmpbmcastecho)
	SYSCTL_INT(_net_inet_icmp, OID_AUTO, bmcastecho, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(icmpbmcastecho), 0,
	"Reply to multicast ICMP Echo Request and Timestamp packets");

	-static VNET_DEFINE(int, icmptstamprepl) = 1;
	+VNET_DEFINE_STATIC(int, icmptstamprepl) = 1;
	#define V_icmptstamprepl VNET(icmptstamprepl)
	SYSCTL_INT(_net_inet_icmp, OID_AUTO, tstamprepl, CTLFLAG_RW,
	&VNET_NAME(icmptstamprepl), 0,
	@@ -1001,7 +1001,7 @@
	const char *descr;
	struct counter_rate cr;
	};
	-static VNET_DEFINE(struct icmp_rate, icmp_rates[BANDLIM_MAX]) = {
	+VNET_DEFINE_STATIC(struct icmp_rate, icmp_rates[BANDLIM_MAX]) = {
	{ "icmp unreach response" },
	{ "icmp ping response" },
	{ "icmp tstamp response" },
	Index: sys/netinet/ip_id.c
	===================================================================
	--- sys/netinet/ip_id.c
	+++ sys/netinet/ip_id.c
	@@ -98,8 +98,8 @@
	* suggested by RFC6864. We use per-CPU counter for that, or if
	* user wants to, we can turn on random ID generation.
	*/
	-static VNET_DEFINE(int, ip_rfc6864) = 1;
	-static VNET_DEFINE(int, ip_do_randomid) = 0;
	+VNET_DEFINE_STATIC(int, ip_rfc6864) = 1;
	+VNET_DEFINE_STATIC(int, ip_do_randomid) = 0;
	#define V_ip_rfc6864 VNET(ip_rfc6864)
	#define V_ip_do_randomid VNET(ip_do_randomid)

	@@ -107,13 +107,13 @@
	* Random ID state engine.
	*/
	static MALLOC_DEFINE(M_IPID, "ipid", "randomized ip id state");
	-static VNET_DEFINE(uint16_t *, id_array);
	-static VNET_DEFINE(bitstr_t *, id_bits);
	-static VNET_DEFINE(int, array_ptr);
	-static VNET_DEFINE(int, array_size);
	-static VNET_DEFINE(int, random_id_collisions);
	-static VNET_DEFINE(int, random_id_total);
	-static VNET_DEFINE(struct mtx, ip_id_mtx);
	+VNET_DEFINE_STATIC(uint16_t *, id_array);
	+VNET_DEFINE_STATIC(bitstr_t *, id_bits);
	+VNET_DEFINE_STATIC(int, array_ptr);
	+VNET_DEFINE_STATIC(int, array_size);
	+VNET_DEFINE_STATIC(int, random_id_collisions);
	+VNET_DEFINE_STATIC(int, random_id_total);
	+VNET_DEFINE_STATIC(struct mtx, ip_id_mtx);
	#define V_id_array VNET(id_array)
	#define V_id_bits VNET(id_bits)
	#define V_array_ptr VNET(array_ptr)
	@@ -125,7 +125,7 @@
	/*
	* Non-random ID state engine is simply a per-cpu counter.
	*/
	-static VNET_DEFINE(counter_u64_t, ip_id);
	+VNET_DEFINE_STATIC(counter_u64_t, ip_id);
	#define V_ip_id VNET(ip_id)

	static int sysctl_ip_randomid(SYSCTL_HANDLER_ARGS);
	Index: sys/netinet/ip_input.c
	===================================================================
	--- sys/netinet/ip_input.c
	+++ sys/netinet/ip_input.c
	@@ -109,7 +109,7 @@
	&VNET_NAME(ipforwarding), 0,
	"Enable IP forwarding between interfaces");

	-static VNET_DEFINE(int, ipsendredirects) = 1; /* XXX */
	+VNET_DEFINE_STATIC(int, ipsendredirects) = 1; /* XXX */
	#define V_ipsendredirects VNET(ipsendredirects)
	SYSCTL_INT(_net_inet_ip, IPCTL_SENDREDIRECTS, redirect, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(ipsendredirects), 0,
	@@ -128,7 +128,7 @@
	* to the loopback interface instead of the interface where the
	* packets for those addresses are received.
	*/
	-static VNET_DEFINE(int, ip_checkinterface);
	+VNET_DEFINE_STATIC(int, ip_checkinterface);
	#define V_ip_checkinterface VNET(ip_checkinterface)
	SYSCTL_INT(_net_inet_ip, OID_AUTO, check_interface, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(ip_checkinterface), 0,
	@@ -1347,7 +1347,7 @@
	* locking. This code remains in ip_input.c as ip_mroute.c is optionally
	* compiled.
	*/
	-static VNET_DEFINE(int, ip_rsvp_on);
	+VNET_DEFINE_STATIC(int, ip_rsvp_on);
	VNET_DEFINE(struct socket *, ip_rsvpd);

	#define V_ip_rsvp_on VNET(ip_rsvp_on)
	Index: sys/netinet/ip_mroute.c
	===================================================================
	--- sys/netinet/ip_mroute.c
	+++ sys/netinet/ip_mroute.c
	@@ -125,7 +125,7 @@

	#define VIFI_INVALID ((vifi_t) -1)

	-static VNET_DEFINE(uint32_t, last_tv_sec); /* last time we processed this */
	+VNET_DEFINE_STATIC(uint32_t, last_tv_sec); /* last time we processed this */
	#define V_last_tv_sec VNET(last_tv_sec)

	static MALLOC_DEFINE(M_MRTABLE, "mroutetbl", "multicast forwarding cache");
	@@ -149,14 +149,14 @@
	static int ip_mrouter_cnt; /* # of vnets with active mrouters */
	static int ip_mrouter_unloading; /* Allow no more V_ip_mrouter sockets */

	-static VNET_PCPUSTAT_DEFINE(struct mrtstat, mrtstat);
	+VNET_PCPUSTAT_DEFINE_STATIC(struct mrtstat, mrtstat);
	VNET_PCPUSTAT_SYSINIT(mrtstat);
	VNET_PCPUSTAT_SYSUNINIT(mrtstat);
	SYSCTL_VNET_PCPUSTAT(_net_inet_ip, OID_AUTO, mrtstat, struct mrtstat,
	mrtstat, "IPv4 Multicast Forwarding Statistics (struct mrtstat, "
	"netinet/ip_mroute.h)");

	-static VNET_DEFINE(u_long, mfchash);
	+VNET_DEFINE_STATIC(u_long, mfchash);
	#define V_mfchash VNET(mfchash)
	#define MFCHASH(a, g) \
	((((a).s_addr >> 20) ^ ((a).s_addr >> 10) ^ (a).s_addr ^ \
	@@ -164,9 +164,9 @@
	#define MFCHASHSIZE 256

	static u_long mfchashsize; /* Hash size */
	-static VNET_DEFINE(u_char , nexpire); / 0..mfchashsize-1 */
	+VNET_DEFINE_STATIC(u_char , nexpire); / 0..mfchashsize-1 */
	#define V_nexpire VNET(nexpire)
	-static VNET_DEFINE(LIST_HEAD(mfchashhdr, mfc)*, mfchashtbl);
	+VNET_DEFINE_STATIC(LIST_HEAD(mfchashhdr, mfc)*, mfchashtbl);
	#define V_mfchashtbl VNET(mfchashtbl)

	static struct mtx mfc_mtx;
	@@ -177,9 +177,9 @@
	mtx_init(&mfc_mtx, "IPv4 multicast forwarding cache", NULL, MTX_DEF)
	#define MFC_LOCK_DESTROY() mtx_destroy(&mfc_mtx)

	-static VNET_DEFINE(vifi_t, numvifs);
	+VNET_DEFINE_STATIC(vifi_t, numvifs);
	#define V_numvifs VNET(numvifs)
	-static VNET_DEFINE(struct vif, viftable[MAXVIFS]);
	+VNET_DEFINE_STATIC(struct vif, viftable[MAXVIFS]);
	#define V_viftable VNET(viftable)
	SYSCTL_OPAQUE(_net_inet_ip, OID_AUTO, viftable, CTLFLAG_VNET \| CTLFLAG_RD,
	&VNET_NAME(viftable), sizeof(V_viftable), "S,vif[MAXVIFS]",
	@@ -195,7 +195,7 @@

	static eventhandler_tag if_detach_event_tag = NULL;

	-static VNET_DEFINE(struct callout, expire_upcalls_ch);
	+VNET_DEFINE_STATIC(struct callout, expire_upcalls_ch);
	#define V_expire_upcalls_ch VNET(expire_upcalls_ch)

	#define EXPIRE_TIMEOUT (hz / 4) /* 4x / second */
	@@ -210,9 +210,9 @@
	* expiration time. Periodically, the entries are analysed and processed.
	*/
	#define BW_METER_BUCKETS 1024
	-static VNET_DEFINE(struct bw_meter*, bw_meter_timers[BW_METER_BUCKETS]);
	+VNET_DEFINE_STATIC(struct bw_meter*, bw_meter_timers[BW_METER_BUCKETS]);
	#define V_bw_meter_timers VNET(bw_meter_timers)
	-static VNET_DEFINE(struct callout, bw_meter_ch);
	+VNET_DEFINE_STATIC(struct callout, bw_meter_ch);
	#define V_bw_meter_ch VNET(bw_meter_ch)
	#define BW_METER_PERIOD (hz) /* periodical handling of bw meters */

	@@ -220,16 +220,16 @@
	* Pending upcalls are stored in a vector which is flushed when
	* full, or periodically
	*/
	-static VNET_DEFINE(struct bw_upcall, bw_upcalls[BW_UPCALLS_MAX]);
	+VNET_DEFINE_STATIC(struct bw_upcall, bw_upcalls[BW_UPCALLS_MAX]);
	#define V_bw_upcalls VNET(bw_upcalls)
	-static VNET_DEFINE(u_int, bw_upcalls_n); /* # of pending upcalls */
	+VNET_DEFINE_STATIC(u_int, bw_upcalls_n); /* # of pending upcalls */
	#define V_bw_upcalls_n VNET(bw_upcalls_n)
	-static VNET_DEFINE(struct callout, bw_upcalls_ch);
	+VNET_DEFINE_STATIC(struct callout, bw_upcalls_ch);
	#define V_bw_upcalls_ch VNET(bw_upcalls_ch)

	#define BW_UPCALLS_PERIOD (hz) /* periodical flush of bw upcalls */

	-static VNET_PCPUSTAT_DEFINE(struct pimstat, pimstat);
	+VNET_PCPUSTAT_DEFINE_STATIC(struct pimstat, pimstat);
	VNET_PCPUSTAT_SYSINIT(pimstat);
	VNET_PCPUSTAT_SYSUNINIT(pimstat);

	@@ -297,9 +297,9 @@
	0 /* flags */
	};

	-static VNET_DEFINE(vifi_t, reg_vif_num) = VIFI_INVALID;
	+VNET_DEFINE_STATIC(vifi_t, reg_vif_num) = VIFI_INVALID;
	#define V_reg_vif_num VNET(reg_vif_num)
	-static VNET_DEFINE(struct ifnet, multicast_register_if);
	+VNET_DEFINE_STATIC(struct ifnet, multicast_register_if);
	#define V_multicast_register_if VNET(multicast_register_if)

	/*
	@@ -368,9 +368,9 @@
	MRT_MFC_FLAGS_BORDER_VIF \|
	MRT_MFC_RP \|
	MRT_MFC_BW_UPCALL);
	-static VNET_DEFINE(uint32_t, mrt_api_config);
	+VNET_DEFINE_STATIC(uint32_t, mrt_api_config);
	#define V_mrt_api_config VNET(mrt_api_config)
	-static VNET_DEFINE(int, pim_assert_enabled);
	+VNET_DEFINE_STATIC(int, pim_assert_enabled);
	#define V_pim_assert_enabled VNET(pim_assert_enabled)
	static struct timeval pim_assert_interval = { 3, 0 }; /* Rate limit */

	Index: sys/netinet/ip_options.c
	===================================================================
	--- sys/netinet/ip_options.c
	+++ sys/netinet/ip_options.c
	@@ -68,13 +68,13 @@

	#include <sys/socketvar.h>

	-static VNET_DEFINE(int, ip_dosourceroute);
	+VNET_DEFINE_STATIC(int, ip_dosourceroute);
	SYSCTL_INT(_net_inet_ip, IPCTL_SOURCEROUTE, sourceroute,
	CTLFLAG_VNET \| CTLFLAG_RW, &VNET_NAME(ip_dosourceroute), 0,
	"Enable forwarding source routed IP packets");
	#define V_ip_dosourceroute VNET(ip_dosourceroute)

	-static VNET_DEFINE(int, ip_acceptsourceroute);
	+VNET_DEFINE_STATIC(int, ip_acceptsourceroute);
	SYSCTL_INT(_net_inet_ip, IPCTL_ACCEPTSOURCEROUTE, accept_sourceroute,
	CTLFLAG_VNET \| CTLFLAG_RW, &VNET_NAME(ip_acceptsourceroute), 0,
	"Enable accepting source routed IP packets");
	Index: sys/netinet/ip_reass.c
	===================================================================
	--- sys/netinet/ip_reass.c
	+++ sys/netinet/ip_reass.c
	@@ -72,9 +72,9 @@
	struct mtx lock;
	};

	-static VNET_DEFINE(struct ipqbucket, ipq[IPREASS_NHASH]);
	+VNET_DEFINE_STATIC(struct ipqbucket, ipq[IPREASS_NHASH]);
	#define V_ipq VNET(ipq)
	-static VNET_DEFINE(uint32_t, ipq_hashseed);
	+VNET_DEFINE_STATIC(uint32_t, ipq_hashseed);
	#define V_ipq_hashseed VNET(ipq_hashseed)

	#define IPQ_LOCK(i) mtx_lock(&V_ipq[i].lock)
	@@ -110,7 +110,7 @@
	ipq_free(head, fp);
	}

	-static VNET_DEFINE(uma_zone_t, ipq_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, ipq_zone);
	#define V_ipq_zone VNET(ipq_zone)
	SYSCTL_PROC(_net_inet_ip, OID_AUTO, maxfragpackets, CTLFLAG_VNET \|
	CTLTYPE_INT \| CTLFLAG_RW, NULL, 0, sysctl_maxfragpackets, "I",
	@@ -119,10 +119,10 @@
	&VNET_NAME(ipq_zone),
	"Current number of IPv4 fragment reassembly queue entries");

	-static VNET_DEFINE(int, noreass);
	+VNET_DEFINE_STATIC(int, noreass);
	#define V_noreass VNET(noreass)

	-static VNET_DEFINE(int, maxfragsperpacket);
	+VNET_DEFINE_STATIC(int, maxfragsperpacket);
	#define V_maxfragsperpacket VNET(maxfragsperpacket)
	SYSCTL_INT(_net_inet_ip, OID_AUTO, maxfragsperpacket, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(maxfragsperpacket), 0,
	Index: sys/netinet/tcp_fastopen.c
	===================================================================
	--- sys/netinet/tcp_fastopen.c
	+++ sys/netinet/tcp_fastopen.c
	@@ -257,13 +257,13 @@

	SYSCTL_NODE(_net_inet_tcp, OID_AUTO, fastopen, CTLFLAG_RW, 0, "TCP Fast Open");

	-static VNET_DEFINE(int, tcp_fastopen_acceptany) = 0;
	+VNET_DEFINE_STATIC(int, tcp_fastopen_acceptany) = 0;
	#define V_tcp_fastopen_acceptany VNET(tcp_fastopen_acceptany)
	SYSCTL_INT(_net_inet_tcp_fastopen, OID_AUTO, acceptany,
	CTLFLAG_VNET \| CTLFLAG_RW, &VNET_NAME(tcp_fastopen_acceptany), 0,
	"Accept any non-empty cookie");

	-static VNET_DEFINE(unsigned int, tcp_fastopen_autokey) = 120;
	+VNET_DEFINE_STATIC(unsigned int, tcp_fastopen_autokey) = 120;
	#define V_tcp_fastopen_autokey VNET(tcp_fastopen_autokey)
	static int sysctl_net_inet_tcp_fastopen_autokey(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, autokey,
	@@ -277,7 +277,7 @@
	&sysctl_net_inet_tcp_fastopen_ccache_bucket_limit, "IU",
	"Max entries per bucket in client cookie cache");

	-static VNET_DEFINE(unsigned int, tcp_fastopen_ccache_buckets) =
	+VNET_DEFINE_STATIC(unsigned int, tcp_fastopen_ccache_buckets) =
	TCP_FASTOPEN_CCACHE_BUCKETS_DEFAULT;
	#define V_tcp_fastopen_ccache_buckets VNET(tcp_fastopen_ccache_buckets)
	SYSCTL_UINT(_net_inet_tcp_fastopen, OID_AUTO, ccache_buckets,
	@@ -303,26 +303,26 @@
	CTLFLAG_RD, SYSCTL_NULL_INT_PTR, TCP_FASTOPEN_MAX_PSKS,
	"Maximum number of pre-shared keys supported");

	-static VNET_DEFINE(unsigned int, tcp_fastopen_numkeys) = 0;
	+VNET_DEFINE_STATIC(unsigned int, tcp_fastopen_numkeys) = 0;
	#define V_tcp_fastopen_numkeys VNET(tcp_fastopen_numkeys)
	SYSCTL_UINT(_net_inet_tcp_fastopen, OID_AUTO, numkeys,
	CTLFLAG_VNET \| CTLFLAG_RD, &VNET_NAME(tcp_fastopen_numkeys), 0,
	"Number of keys installed");

	-static VNET_DEFINE(unsigned int, tcp_fastopen_numpsks) = 0;
	+VNET_DEFINE_STATIC(unsigned int, tcp_fastopen_numpsks) = 0;
	#define V_tcp_fastopen_numpsks VNET(tcp_fastopen_numpsks)
	SYSCTL_UINT(_net_inet_tcp_fastopen, OID_AUTO, numpsks,
	CTLFLAG_VNET \| CTLFLAG_RD, &VNET_NAME(tcp_fastopen_numpsks), 0,
	"Number of pre-shared keys installed");

	-static VNET_DEFINE(unsigned int, tcp_fastopen_path_disable_time) =
	+VNET_DEFINE_STATIC(unsigned int, tcp_fastopen_path_disable_time) =
	TCP_FASTOPEN_PATH_DISABLE_TIME_DEFAULT;
	#define V_tcp_fastopen_path_disable_time VNET(tcp_fastopen_path_disable_time)
	SYSCTL_UINT(_net_inet_tcp_fastopen, OID_AUTO, path_disable_time,
	CTLFLAG_VNET \| CTLFLAG_RW, &VNET_NAME(tcp_fastopen_path_disable_time), 0,
	"Seconds a TFO failure disables a {client_ip, server_ip, server_port} path");

	-static VNET_DEFINE(unsigned int, tcp_fastopen_psk_enable) = 0;
	+VNET_DEFINE_STATIC(unsigned int, tcp_fastopen_psk_enable) = 0;
	#define V_tcp_fastopen_psk_enable VNET(tcp_fastopen_psk_enable)
	static int sysctl_net_inet_tcp_fastopen_psk_enable(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, psk_enable,
	@@ -355,7 +355,7 @@
	sysctl_net_inet_tcp_fastopen_ccache_list, "A",
	"List of all client cookie cache entries");

	-static VNET_DEFINE(struct rmlock, tcp_fastopen_keylock);
	+VNET_DEFINE_STATIC(struct rmlock, tcp_fastopen_keylock);
	#define V_tcp_fastopen_keylock VNET(tcp_fastopen_keylock)

	#define TCP_FASTOPEN_KEYS_RLOCK(t) rm_rlock(&V_tcp_fastopen_keylock, (t))
	@@ -363,18 +363,18 @@
	#define TCP_FASTOPEN_KEYS_WLOCK() rm_wlock(&V_tcp_fastopen_keylock)
	#define TCP_FASTOPEN_KEYS_WUNLOCK() rm_wunlock(&V_tcp_fastopen_keylock)

	-static VNET_DEFINE(struct tcp_fastopen_keylist, tcp_fastopen_keys);
	+VNET_DEFINE_STATIC(struct tcp_fastopen_keylist, tcp_fastopen_keys);
	#define V_tcp_fastopen_keys VNET(tcp_fastopen_keys)

	-static VNET_DEFINE(struct tcp_fastopen_callout, tcp_fastopen_autokey_ctx);
	+VNET_DEFINE_STATIC(struct tcp_fastopen_callout, tcp_fastopen_autokey_ctx);
	#define V_tcp_fastopen_autokey_ctx VNET(tcp_fastopen_autokey_ctx)

	-static VNET_DEFINE(uma_zone_t, counter_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, counter_zone);
	#define V_counter_zone VNET(counter_zone)

	static MALLOC_DEFINE(M_TCP_FASTOPEN_CCACHE, "tfo_ccache", "TFO client cookie cache buckets");

	-static VNET_DEFINE(struct tcp_fastopen_ccache, tcp_fastopen_ccache);
	+VNET_DEFINE_STATIC(struct tcp_fastopen_ccache, tcp_fastopen_ccache);
	#define V_tcp_fastopen_ccache VNET(tcp_fastopen_ccache)

	#define CCB_LOCK(ccb) mtx_lock(&(ccb)->ccb_mtx)
	Index: sys/netinet/tcp_hostcache.c
	===================================================================
	--- sys/netinet/tcp_hostcache.c
	+++ sys/netinet/tcp_hostcache.c
	@@ -112,10 +112,10 @@
	#define TCP_HOSTCACHE_EXPIRE 6060 / one hour */
	#define TCP_HOSTCACHE_PRUNE 560 / every 5 minutes */

	-static VNET_DEFINE(struct tcp_hostcache, tcp_hostcache);
	+VNET_DEFINE_STATIC(struct tcp_hostcache, tcp_hostcache);
	#define V_tcp_hostcache VNET(tcp_hostcache)

	-static VNET_DEFINE(struct callout, tcp_hc_callout);
	+VNET_DEFINE_STATIC(struct callout, tcp_hc_callout);
	#define V_tcp_hc_callout VNET(tcp_hc_callout)

	static struct hc_metrics tcp_hc_lookup(struct in_conninfo );
	Index: sys/netinet/tcp_subr.c
	===================================================================
	--- sys/netinet/tcp_subr.c
	+++ sys/netinet/tcp_subr.c
	@@ -210,13 +210,13 @@
	SYSCTL_UINT(_net_inet_tcp, OID_AUTO, pcbcount, CTLFLAG_VNET \| CTLFLAG_RD,
	&VNET_NAME(tcbinfo.ipi_count), 0, "Number of active PCBs");

	-static VNET_DEFINE(int, icmp_may_rst) = 1;
	+VNET_DEFINE_STATIC(int, icmp_may_rst) = 1;
	#define V_icmp_may_rst VNET(icmp_may_rst)
	SYSCTL_INT(_net_inet_tcp, OID_AUTO, icmp_may_rst, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(icmp_may_rst), 0,
	"Certain ICMP unreachable messages may abort connections in SYN_SENT");

	-static VNET_DEFINE(int, tcp_isn_reseed_interval) = 0;
	+VNET_DEFINE_STATIC(int, tcp_isn_reseed_interval) = 0;
	#define V_tcp_isn_reseed_interval VNET(tcp_isn_reseed_interval)
	SYSCTL_INT(_net_inet_tcp, OID_AUTO, isn_reseed_interval, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(tcp_isn_reseed_interval), 0,
	@@ -695,7 +695,7 @@
	#endif
	};

	-static VNET_DEFINE(uma_zone_t, tcpcb_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, tcpcb_zone);
	#define V_tcpcb_zone VNET(tcpcb_zone)

	MALLOC_DEFINE(M_TCPLOG, "tcplog", "TCP address and flags print buffers");
	@@ -2643,11 +2643,11 @@
	#define ISN_STATIC_INCREMENT 4096
	#define ISN_RANDOM_INCREMENT (4096 - 1)

	-static VNET_DEFINE(u_char, isn_secret[32]);
	-static VNET_DEFINE(int, isn_last);
	-static VNET_DEFINE(int, isn_last_reseed);
	-static VNET_DEFINE(u_int32_t, isn_offset);
	-static VNET_DEFINE(u_int32_t, isn_offset_old);
	+VNET_DEFINE_STATIC(u_char, isn_secret[32]);
	+VNET_DEFINE_STATIC(int, isn_last);
	+VNET_DEFINE_STATIC(int, isn_last_reseed);
	+VNET_DEFINE_STATIC(u_int32_t, isn_offset);
	+VNET_DEFINE_STATIC(u_int32_t, isn_offset_old);

	#define V_isn_secret VNET(isn_secret)
	#define V_isn_last VNET(isn_last)
	Index: sys/netinet/tcp_syncache.c
	===================================================================
	--- sys/netinet/tcp_syncache.c
	+++ sys/netinet/tcp_syncache.c
	@@ -102,19 +102,19 @@

	#include <security/mac/mac_framework.h>

	-static VNET_DEFINE(int, tcp_syncookies) = 1;
	+VNET_DEFINE_STATIC(int, tcp_syncookies) = 1;
	#define V_tcp_syncookies VNET(tcp_syncookies)
	SYSCTL_INT(_net_inet_tcp, OID_AUTO, syncookies, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(tcp_syncookies), 0,
	"Use TCP SYN cookies if the syncache overflows");

	-static VNET_DEFINE(int, tcp_syncookiesonly) = 0;
	+VNET_DEFINE_STATIC(int, tcp_syncookiesonly) = 0;
	#define V_tcp_syncookiesonly VNET(tcp_syncookiesonly)
	SYSCTL_INT(_net_inet_tcp, OID_AUTO, syncookies_only, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(tcp_syncookiesonly), 0,
	"Use only TCP SYN cookies");

	-static VNET_DEFINE(int, functions_inherit_listen_socket_stack) = 1;
	+VNET_DEFINE_STATIC(int, functions_inherit_listen_socket_stack) = 1;
	#define V_functions_inherit_listen_socket_stack \
	VNET(functions_inherit_listen_socket_stack)
	SYSCTL_INT(_net_inet_tcp, OID_AUTO, functions_inherit_listen_socket_stack,
	@@ -162,7 +162,7 @@
	#define TCP_SYNCACHE_HASHSIZE 512
	#define TCP_SYNCACHE_BUCKETLIMIT 30

	-static VNET_DEFINE(struct tcp_syncache, tcp_syncache);
	+VNET_DEFINE_STATIC(struct tcp_syncache, tcp_syncache);
	#define V_tcp_syncache VNET(tcp_syncache)

	static SYSCTL_NODE(_net_inet_tcp, OID_AUTO, syncache, CTLFLAG_RW, 0,
	Index: sys/netinet/tcp_timewait.c
	===================================================================
	--- sys/netinet/tcp_timewait.c
	+++ sys/netinet/tcp_timewait.c
	@@ -96,7 +96,7 @@

	#include <security/mac/mac_framework.h>

	-static VNET_DEFINE(uma_zone_t, tcptw_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, tcptw_zone);
	#define V_tcptw_zone VNET(tcptw_zone)
	static int maxtcptw;

	@@ -111,11 +111,11 @@
	* - a tcptw relies on its inpcb reference counting for memory stability
	* - a tcptw is dereferenceable only while its inpcb is locked
	*/
	-static VNET_DEFINE(TAILQ_HEAD(, tcptw), twq_2msl);
	+VNET_DEFINE_STATIC(TAILQ_HEAD(, tcptw), twq_2msl);
	#define V_twq_2msl VNET(twq_2msl)

	/* Global timewait lock */
	-static VNET_DEFINE(struct rwlock, tw_lock);
	+VNET_DEFINE_STATIC(struct rwlock, tw_lock);
	#define V_tw_lock VNET(tw_lock)

	#define TW_LOCK_INIT(tw, d) rw_init_flags(&(tw), (d), 0)
	@@ -172,7 +172,7 @@
	&maxtcptw, 0, sysctl_maxtcptw, "IU",
	"Maximum number of compressed TCP TIME_WAIT entries");

	-static VNET_DEFINE(int, nolocaltimewait) = 0;
	+VNET_DEFINE_STATIC(int, nolocaltimewait) = 0;
	#define V_nolocaltimewait VNET(nolocaltimewait)
	SYSCTL_INT(_net_inet_tcp, OID_AUTO, nolocaltimewait, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(nolocaltimewait), 0,
	Index: sys/netinet/udp_usrreq.c
	===================================================================
	--- sys/netinet/udp_usrreq.c
	+++ sys/netinet/udp_usrreq.c
	@@ -144,7 +144,7 @@
	VNET_DEFINE(struct inpcbinfo, udbinfo);
	VNET_DEFINE(struct inpcbhead, ulitecb);
	VNET_DEFINE(struct inpcbinfo, ulitecbinfo);
	-static VNET_DEFINE(uma_zone_t, udpcb_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, udpcb_zone);
	#define V_udpcb_zone VNET(udpcb_zone)

	#ifndef UDBHASHSIZE
	Index: sys/netinet6/frag6.c
	===================================================================
	--- sys/netinet6/frag6.c
	+++ sys/netinet6/frag6.c
	@@ -75,9 +75,9 @@
	/*
	* These fields all protected by ip6qlock.
	*/
	-static VNET_DEFINE(u_int, frag6_nfragpackets);
	-static VNET_DEFINE(u_int, frag6_nfrags);
	-static VNET_DEFINE(struct ip6q, ip6q); /* ip6 reassemble queue */
	+VNET_DEFINE_STATIC(u_int, frag6_nfragpackets);
	+VNET_DEFINE_STATIC(u_int, frag6_nfrags);
	+VNET_DEFINE_STATIC(struct ip6q, ip6q); /* ip6 reassemble queue */

	#define V_frag6_nfragpackets VNET(frag6_nfragpackets)
	#define V_frag6_nfrags VNET(frag6_nfrags)
	Index: sys/netinet6/icmp6.c
	===================================================================
	--- sys/netinet6/icmp6.c
	+++ sys/netinet6/icmp6.c
	@@ -124,8 +124,8 @@
	VNET_DECLARE(struct inpcbinfo, ripcbinfo);
	VNET_DECLARE(struct inpcbhead, ripcb);
	VNET_DECLARE(int, icmp6errppslim);
	-static VNET_DEFINE(int, icmp6errpps_count) = 0;
	-static VNET_DEFINE(struct timeval, icmp6errppslim_last);
	+VNET_DEFINE_STATIC(int, icmp6errpps_count) = 0;
	+VNET_DEFINE_STATIC(struct timeval, icmp6errppslim_last);
	VNET_DECLARE(int, icmp6_nodeinfo);

	#define V_ripcbinfo VNET(ripcbinfo)
	Index: sys/netinet6/in6_gif.c
	===================================================================
	--- sys/netinet6/in6_gif.c
	+++ sys/netinet6/in6_gif.c
	@@ -74,7 +74,7 @@
	#include <net/if_gif.h>

	#define GIF_HLIM 30
	-static VNET_DEFINE(int, ip6_gif_hlim) = GIF_HLIM;
	+VNET_DEFINE_STATIC(int, ip6_gif_hlim) = GIF_HLIM;
	#define V_ip6_gif_hlim VNET(ip6_gif_hlim)

	SYSCTL_DECL(_net_inet6_ip6);
	@@ -86,8 +86,8 @@
	* We keep interfaces in a hash table using src+dst as key.
	* Interfaces with GIF_IGNORE_SOURCE flag are linked into plain list.
	*/
	-static VNET_DEFINE(struct gif_list *, ipv6_hashtbl) = NULL;
	-static VNET_DEFINE(struct gif_list, ipv6_list) = CK_LIST_HEAD_INITIALIZER();
	+VNET_DEFINE_STATIC(struct gif_list *, ipv6_hashtbl) = NULL;
	+VNET_DEFINE_STATIC(struct gif_list, ipv6_list) = CK_LIST_HEAD_INITIALIZER();
	#define V_ipv6_hashtbl VNET(ipv6_hashtbl)
	#define V_ipv6_list VNET(ipv6_list)

	Index: sys/netinet6/in6_rmx.c
	===================================================================
	--- sys/netinet6/in6_rmx.c
	+++ sys/netinet6/in6_rmx.c
	@@ -159,7 +159,7 @@
	struct rib_head *rnh;
	time_t nextstop;
	};
	-static VNET_DEFINE(struct callout, rtq_mtutimer);
	+VNET_DEFINE_STATIC(struct callout, rtq_mtutimer);
	#define V_rtq_mtutimer VNET(rtq_mtutimer)

	static int
	@@ -209,7 +209,7 @@
	/*
	* Initialize our routing tree.
	*/
	-static VNET_DEFINE(int, _in6_rt_was_here);
	+VNET_DEFINE_STATIC(int, _in6_rt_was_here);
	#define V__in6_rt_was_here VNET(_in6_rt_was_here)

	int
	Index: sys/netinet6/in6_src.c
	===================================================================
	--- sys/netinet6/in6_src.c
	+++ sys/netinet6/in6_src.c
	@@ -127,7 +127,7 @@
	#define ADDRSEL_XUNLOCK() sx_xunlock(&addrsel_sxlock)

	#define ADDR_LABEL_NOTAPP (-1)
	-static VNET_DEFINE(struct in6_addrpolicy, defaultaddrpolicy);
	+VNET_DEFINE_STATIC(struct in6_addrpolicy, defaultaddrpolicy);
	#define V_defaultaddrpolicy VNET(defaultaddrpolicy)

	VNET_DEFINE(int, ip6_prefer_tempaddr) = 0;
	@@ -1094,7 +1094,7 @@

	TAILQ_HEAD(addrsel_policyhead, addrsel_policyent);

	-static VNET_DEFINE(struct addrsel_policyhead, addrsel_policytab);
	+VNET_DEFINE_STATIC(struct addrsel_policyhead, addrsel_policytab);
	#define V_addrsel_policytab VNET(addrsel_policytab)

	static void
	Index: sys/netinet6/ip6_gre.c
	===================================================================
	--- sys/netinet6/ip6_gre.c
	+++ sys/netinet6/ip6_gre.c
	@@ -65,7 +65,7 @@
	SYSCTL_INT(_net_inet6_ip6, OID_AUTO, grehlim, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(ip6_gre_hlim), 0, "Default hop limit for encapsulated packets");

	-static VNET_DEFINE(struct gre_list *, ipv6_hashtbl) = NULL;
	+VNET_DEFINE_STATIC(struct gre_list *, ipv6_hashtbl) = NULL;
	#define V_ipv6_hashtbl VNET(ipv6_hashtbl)
	#define GRE_HASH(src, dst) (V_ipv6_hashtbl[\
	in6_gre_hashval((src), (dst)) & (GRE_HASH_SIZE - 1)])
	Index: sys/netinet6/ip6_mroute.c
	===================================================================
	--- sys/netinet6/ip6_mroute.c
	+++ sys/netinet6/ip6_mroute.c
	@@ -150,7 +150,7 @@
	};


	-static VNET_DEFINE(int, ip6_mrouter_ver) = 0;
	+VNET_DEFINE_STATIC(int, ip6_mrouter_ver) = 0;
	#define V_ip6_mrouter_ver VNET(ip6_mrouter_ver)

	SYSCTL_DECL(_net_inet6);
	@@ -235,7 +235,7 @@
	#define MIF6_LOCK_DESTROY() mtx_destroy(&mif6_mtx)

	#ifdef MRT6DEBUG
	-static VNET_DEFINE(u_int, mrt6debug) = 0; /* debug level */
	+VNET_DEFINE_STATIC(u_int, mrt6debug) = 0; /* debug level */
	#define V_mrt6debug VNET(mrt6debug)
	#define DEBUG_MFC 0x02
	#define DEBUG_FORWARD 0x04
	@@ -288,7 +288,7 @@
	"PIM Statistics (struct pim6stat, netinet6/pim6_var.h)");

	#define PIM6STAT_INC(name) pim6stat.name += 1
	-static VNET_DEFINE(int, pim6);
	+VNET_DEFINE_STATIC(int, pim6);
	#define V_pim6 VNET(pim6)

	/*
	Index: sys/netinet6/mld6.c
	===================================================================
	--- sys/netinet6/mld6.c
	+++ sys/netinet6/mld6.c
	@@ -207,11 +207,11 @@
	/*
	* VIMAGE-wide globals.
	*/
	-static VNET_DEFINE(struct timeval, mld_gsrdelay) = {10, 0};
	-static VNET_DEFINE(LIST_HEAD(, mld_ifsoftc), mli_head);
	-static VNET_DEFINE(int, interface_timers_running6);
	-static VNET_DEFINE(int, state_change_timers_running6);
	-static VNET_DEFINE(int, current_state_timers_running6);
	+VNET_DEFINE_STATIC(struct timeval, mld_gsrdelay) = {10, 0};
	+VNET_DEFINE_STATIC(LIST_HEAD(, mld_ifsoftc), mli_head);
	+VNET_DEFINE_STATIC(int, interface_timers_running6);
	+VNET_DEFINE_STATIC(int, state_change_timers_running6);
	+VNET_DEFINE_STATIC(int, current_state_timers_running6);

	#define V_mld_gsrdelay VNET(mld_gsrdelay)
	#define V_mli_head VNET(mli_head)
	Index: sys/netinet6/nd6.c
	===================================================================
	--- sys/netinet6/nd6.c
	+++ sys/netinet6/nd6.c
	@@ -98,11 +98,11 @@
	* collection timer */

	/* preventing too many loops in ND option parsing */
	-static VNET_DEFINE(int, nd6_maxndopt) = 10; /* max # of ND options allowed */
	+VNET_DEFINE_STATIC(int, nd6_maxndopt) = 10; /* max # of ND options allowed */

	VNET_DEFINE(int, nd6_maxnudhint) = 0; /* max # of subsequent upper
	* layer hints */
	-static VNET_DEFINE(int, nd6_maxqueuelen) = 1; /* max pkts cached in unresolved
	+VNET_DEFINE_STATIC(int, nd6_maxqueuelen) = 1; /* max pkts cached in unresolved
	* ND entries */
	#define V_nd6_maxndopt VNET(nd6_maxndopt)
	#define V_nd6_maxqueuelen VNET(nd6_maxqueuelen)
	@@ -142,7 +142,7 @@
	static int nd6_need_cache(struct ifnet *);


	-static VNET_DEFINE(struct callout, nd6_slowtimo_ch);
	+VNET_DEFINE_STATIC(struct callout, nd6_slowtimo_ch);
	#define V_nd6_slowtimo_ch VNET(nd6_slowtimo_ch)

	VNET_DEFINE(struct callout, nd6_timer_ch);
	Index: sys/netinet6/nd6_nbr.c
	===================================================================
	--- sys/netinet6/nd6_nbr.c
	+++ sys/netinet6/nd6_nbr.c
	@@ -99,7 +99,7 @@
	static void nd6_ns_output_fib(struct ifnet , const struct in6_addr ,
	const struct in6_addr , const struct in6_addr , uint8_t *, u_int);

	-static VNET_DEFINE(int, dad_enhanced) = 1;
	+VNET_DEFINE_STATIC(int, dad_enhanced) = 1;
	#define V_dad_enhanced VNET(dad_enhanced)

	SYSCTL_DECL(_net_inet6_ip6);
	@@ -107,7 +107,7 @@
	&VNET_NAME(dad_enhanced), 0,
	"Enable Enhanced DAD, which adds a random nonce to NS messages for DAD.");

	-static VNET_DEFINE(int, dad_maxtry) = 15; /* max # of tries to
	+VNET_DEFINE_STATIC(int, dad_maxtry) = 15; /* max # of tries to
	transmit DAD packet */
	#define V_dad_maxtry VNET(dad_maxtry)

	@@ -1120,8 +1120,8 @@
	bool dad_ondadq; /* on dadq? Protected by DADQ_WLOCK. */
	};

	-static VNET_DEFINE(TAILQ_HEAD(, dadq), dadq);
	-static VNET_DEFINE(struct rwlock, dad_rwlock);
	+VNET_DEFINE_STATIC(TAILQ_HEAD(, dadq), dadq);
	+VNET_DEFINE_STATIC(struct rwlock, dad_rwlock);
	#define V_dadq VNET(dadq)
	#define V_dad_rwlock VNET(dad_rwlock)

	Index: sys/netinet6/nd6_rtr.c
	===================================================================
	--- sys/netinet6/nd6_rtr.c
	+++ sys/netinet6/nd6_rtr.c
	@@ -94,7 +94,7 @@
	VNET_DECLARE(int, nd6_recalc_reachtm_interval);
	#define V_nd6_recalc_reachtm_interval VNET(nd6_recalc_reachtm_interval)

	-static VNET_DEFINE(struct ifnet *, nd6_defifp);
	+VNET_DEFINE_STATIC(struct ifnet *, nd6_defifp);
	VNET_DEFINE(int, nd6_defifindex);
	#define V_nd6_defifp VNET(nd6_defifp)

	Index: sys/netinet6/scope6.c
	===================================================================
	--- sys/netinet6/scope6.c
	+++ sys/netinet6/scope6.c
	@@ -76,7 +76,7 @@
	#define SCOPE6_UNLOCK() mtx_unlock(&scope6_lock)
	#define SCOPE6_LOCK_ASSERT() mtx_assert(&scope6_lock, MA_OWNED)

	-static VNET_DEFINE(struct scope6_id, sid_default);
	+VNET_DEFINE_STATIC(struct scope6_id, sid_default);
	#define V_sid_default VNET(sid_default)

	#define SID(ifp) \
	Index: sys/netinet6/send.c
	===================================================================
	--- sys/netinet6/send.c
	+++ sys/netinet6/send.c
	@@ -64,7 +64,7 @@
	/*
	* The socket used to communicate with the SeND daemon.
	*/
	-static VNET_DEFINE(struct socket *, send_so);
	+VNET_DEFINE_STATIC(struct socket *, send_so);
	#define V_send_so VNET(send_so)

	u_long send_sendspace = 8 * (1024 + sizeof(struct sockaddr_send));
	Index: sys/netipsec/ipsec.c
	===================================================================
	--- sys/netipsec/ipsec.c
	+++ sys/netipsec/ipsec.c
	@@ -119,11 +119,11 @@
	/* ECN ignore(-1)/forbidden(0)/allowed(1) */
	VNET_DEFINE(int, ip4_ipsec_ecn) = 0;

	-static VNET_DEFINE(int, ip4_filtertunnel) = 0;
	+VNET_DEFINE_STATIC(int, ip4_filtertunnel) = 0;
	#define V_ip4_filtertunnel VNET(ip4_filtertunnel)
	-static VNET_DEFINE(int, check_policy_history) = 0;
	+VNET_DEFINE_STATIC(int, check_policy_history) = 0;
	#define V_check_policy_history VNET(check_policy_history)
	-static VNET_DEFINE(struct secpolicy *, def_policy) = NULL;
	+VNET_DEFINE_STATIC(struct secpolicy *, def_policy) = NULL;
	#define V_def_policy VNET(def_policy)
	static int
	sysctl_def_policy(SYSCTL_HANDLER_ARGS)
	@@ -249,7 +249,7 @@
	VNET_DEFINE(int, ip6_ah_net_deflev) = IPSEC_LEVEL_USE;
	VNET_DEFINE(int, ip6_ipsec_ecn) = 0; /* ECN ignore(-1)/forbidden(0)/allowed(1) */

	-static VNET_DEFINE(int, ip6_filtertunnel) = 0;
	+VNET_DEFINE_STATIC(int, ip6_filtertunnel) = 0;
	#define V_ip6_filtertunnel VNET(ip6_filtertunnel)

	SYSCTL_DECL(_net_inet6_ipsec6);
	Index: sys/netipsec/key.c
	===================================================================
	--- sys/netipsec/key.c
	+++ sys/netipsec/key.c
	@@ -113,20 +113,20 @@
	*/

	VNET_DEFINE(u_int32_t, key_debug_level) = 0;
	-static VNET_DEFINE(u_int, key_spi_trycnt) = 1000;
	-static VNET_DEFINE(u_int32_t, key_spi_minval) = 0x100;
	-static VNET_DEFINE(u_int32_t, key_spi_maxval) = 0x0fffffff; /* XXX */
	-static VNET_DEFINE(u_int32_t, policy_id) = 0;
	+VNET_DEFINE_STATIC(u_int, key_spi_trycnt) = 1000;
	+VNET_DEFINE_STATIC(u_int32_t, key_spi_minval) = 0x100;
	+VNET_DEFINE_STATIC(u_int32_t, key_spi_maxval) = 0x0fffffff; /* XXX */
	+VNET_DEFINE_STATIC(u_int32_t, policy_id) = 0;
	/interval to initialize randseed,1(m)/
	-static VNET_DEFINE(u_int, key_int_random) = 60;
	+VNET_DEFINE_STATIC(u_int, key_int_random) = 60;
	/* interval to expire acquiring, 30(s)*/
	-static VNET_DEFINE(u_int, key_larval_lifetime) = 30;
	+VNET_DEFINE_STATIC(u_int, key_larval_lifetime) = 30;
	/* counter for blocking SADB_ACQUIRE.*/
	-static VNET_DEFINE(int, key_blockacq_count) = 10;
	+VNET_DEFINE_STATIC(int, key_blockacq_count) = 10;
	/* lifetime for blocking SADB_ACQUIRE.*/
	-static VNET_DEFINE(int, key_blockacq_lifetime) = 20;
	+VNET_DEFINE_STATIC(int, key_blockacq_lifetime) = 20;
	/* preferred old sa rather than new sa.*/
	-static VNET_DEFINE(int, key_preferred_oldsa) = 1;
	+VNET_DEFINE_STATIC(int, key_preferred_oldsa) = 1;
	#define V_key_spi_trycnt VNET(key_spi_trycnt)
	#define V_key_spi_minval VNET(key_spi_minval)
	#define V_key_spi_maxval VNET(key_spi_maxval)
	@@ -137,17 +137,17 @@
	#define V_key_blockacq_lifetime VNET(key_blockacq_lifetime)
	#define V_key_preferred_oldsa VNET(key_preferred_oldsa)

	-static VNET_DEFINE(u_int32_t, acq_seq) = 0;
	+VNET_DEFINE_STATIC(u_int32_t, acq_seq) = 0;
	#define V_acq_seq VNET(acq_seq)

	-static VNET_DEFINE(uint32_t, sp_genid) = 0;
	+VNET_DEFINE_STATIC(uint32_t, sp_genid) = 0;
	#define V_sp_genid VNET(sp_genid)

	/* SPD */
	TAILQ_HEAD(secpolicy_queue, secpolicy);
	LIST_HEAD(secpolicy_list, secpolicy);
	-static VNET_DEFINE(struct secpolicy_queue, sptree[IPSEC_DIR_MAX]);
	-static VNET_DEFINE(struct secpolicy_queue, sptree_ifnet[IPSEC_DIR_MAX]);
	+VNET_DEFINE_STATIC(struct secpolicy_queue, sptree[IPSEC_DIR_MAX]);
	+VNET_DEFINE_STATIC(struct secpolicy_queue, sptree_ifnet[IPSEC_DIR_MAX]);
	static struct rmlock sptree_lock;
	#define V_sptree VNET(sptree)
	#define V_sptree_ifnet VNET(sptree_ifnet)
	@@ -163,8 +163,8 @@
	#define SPTREE_UNLOCK_ASSERT() rm_assert(&sptree_lock, RA_UNLOCKED)

	/* Hash table for lookup SP using unique id */
	-static VNET_DEFINE(struct secpolicy_list *, sphashtbl);
	-static VNET_DEFINE(u_long, sphash_mask);
	+VNET_DEFINE_STATIC(struct secpolicy_list *, sphashtbl);
	+VNET_DEFINE_STATIC(u_long, sphash_mask);
	#define V_sphashtbl VNET(sphashtbl)
	#define V_sphash_mask VNET(sphash_mask)

	@@ -184,19 +184,19 @@

	#define SPDCACHE_MAX_ENTRIES_PER_HASH 8

	-static VNET_DEFINE(u_int, key_spdcache_maxentries) = 0;
	+VNET_DEFINE_STATIC(u_int, key_spdcache_maxentries) = 0;
	#define V_key_spdcache_maxentries VNET(key_spdcache_maxentries)
	-static VNET_DEFINE(u_int, key_spdcache_threshold) = 32;
	+VNET_DEFINE_STATIC(u_int, key_spdcache_threshold) = 32;
	#define V_key_spdcache_threshold VNET(key_spdcache_threshold)
	-static VNET_DEFINE(unsigned long, spd_size) = 0;
	+VNET_DEFINE_STATIC(unsigned long, spd_size) = 0;
	#define V_spd_size VNET(spd_size)

	#define SPDCACHE_ENABLED() (V_key_spdcache_maxentries != 0)
	#define SPDCACHE_ACTIVE() \
	(SPDCACHE_ENABLED() && V_spd_size >= V_key_spdcache_threshold)

	-static VNET_DEFINE(struct spdcache_entry_list *, spdcachehashtbl);
	-static VNET_DEFINE(u_long, spdcachehash_mask);
	+VNET_DEFINE_STATIC(struct spdcache_entry_list *, spdcachehashtbl);
	+VNET_DEFINE_STATIC(u_long, spdcachehash_mask);
	#define V_spdcachehashtbl VNET(spdcachehashtbl)
	#define V_spdcachehash_mask VNET(spdcachehash_mask)

	@@ -205,7 +205,7 @@
	V_spdcachehash_mask)

	/* Each cache line is protected by a mutex */
	-static VNET_DEFINE(struct mtx *, spdcache_lock);
	+VNET_DEFINE_STATIC(struct mtx *, spdcache_lock);
	#define V_spdcache_lock VNET(spdcache_lock)

	#define SPDCACHE_LOCK_INIT(a) \
	@@ -218,7 +218,7 @@
	/* SAD */
	TAILQ_HEAD(secashead_queue, secashead);
	LIST_HEAD(secashead_list, secashead);
	-static VNET_DEFINE(struct secashead_queue, sahtree);
	+VNET_DEFINE_STATIC(struct secashead_queue, sahtree);
	static struct rmlock sahtree_lock;
	#define V_sahtree VNET(sahtree)
	#define SAHTREE_LOCK_INIT() rm_init(&sahtree_lock, "sahtree")
	@@ -233,8 +233,8 @@
	#define SAHTREE_UNLOCK_ASSERT() rm_assert(&sahtree_lock, RA_UNLOCKED)

	/* Hash table for lookup in SAD using SA addresses */
	-static VNET_DEFINE(struct secashead_list *, sahaddrhashtbl);
	-static VNET_DEFINE(u_long, sahaddrhash_mask);
	+VNET_DEFINE_STATIC(struct secashead_list *, sahaddrhashtbl);
	+VNET_DEFINE_STATIC(u_long, sahaddrhash_mask);
	#define V_sahaddrhashtbl VNET(sahaddrhashtbl)
	#define V_sahaddrhash_mask VNET(sahaddrhash_mask)

	@@ -248,8 +248,8 @@

	/* Hash table for lookup in SAD using SPI */
	LIST_HEAD(secasvar_list, secasvar);
	-static VNET_DEFINE(struct secasvar_list *, savhashtbl);
	-static VNET_DEFINE(u_long, savhash_mask);
	+VNET_DEFINE_STATIC(struct secasvar_list *, savhashtbl);
	+VNET_DEFINE_STATIC(u_long, savhash_mask);
	#define V_savhashtbl VNET(savhashtbl)
	#define V_savhash_mask VNET(savhash_mask)
	#define SAVHASH_NHASH_LOG2 7
	@@ -298,7 +298,7 @@
	}

	/* registed list */
	-static VNET_DEFINE(LIST_HEAD(_regtree, secreg), regtree[SADB_SATYPE_MAX + 1]);
	+VNET_DEFINE_STATIC(LIST_HEAD(_regtree, secreg), regtree[SADB_SATYPE_MAX + 1]);
	#define V_regtree VNET(regtree)
	static struct mtx regtree_lock;
	#define REGTREE_LOCK_INIT() \
	@@ -310,7 +310,7 @@

	/* Acquiring list */
	LIST_HEAD(secacq_list, secacq);
	-static VNET_DEFINE(struct secacq_list, acqtree);
	+VNET_DEFINE_STATIC(struct secacq_list, acqtree);
	#define V_acqtree VNET(acqtree)
	static struct mtx acq_lock;
	#define ACQ_LOCK_INIT() \
	@@ -321,14 +321,14 @@
	#define ACQ_LOCK_ASSERT() mtx_assert(&acq_lock, MA_OWNED)

	/* Hash table for lookup in ACQ list using SA addresses */
	-static VNET_DEFINE(struct secacq_list *, acqaddrhashtbl);
	-static VNET_DEFINE(u_long, acqaddrhash_mask);
	+VNET_DEFINE_STATIC(struct secacq_list *, acqaddrhashtbl);
	+VNET_DEFINE_STATIC(u_long, acqaddrhash_mask);
	#define V_acqaddrhashtbl VNET(acqaddrhashtbl)
	#define V_acqaddrhash_mask VNET(acqaddrhash_mask)

	/* Hash table for lookup in ACQ list using SEQ number */
	-static VNET_DEFINE(struct secacq_list *, acqseqhashtbl);
	-static VNET_DEFINE(u_long, acqseqhash_mask);
	+VNET_DEFINE_STATIC(struct secacq_list *, acqseqhashtbl);
	+VNET_DEFINE_STATIC(u_long, acqseqhash_mask);
	#define V_acqseqhashtbl VNET(acqseqhashtbl)
	#define V_acqseqhash_mask VNET(acqseqhash_mask)

	@@ -344,7 +344,7 @@
	#define ACQSEQHASH_HASH(seq) \
	&V_acqseqhashtbl[ACQSEQHASH_HASHVAL(seq)]
	/* SP acquiring list */
	-static VNET_DEFINE(LIST_HEAD(_spacqtree, secspacq), spacqtree);
	+VNET_DEFINE_STATIC(LIST_HEAD(_spacqtree, secspacq), spacqtree);
	#define V_spacqtree VNET(spacqtree)
	static struct mtx spacq_lock;
	#define SPACQ_LOCK_INIT() \
	@@ -433,9 +433,9 @@
	((_mhp)->extlen[(_ext)] > maxsize[(_ext)])))
	#define SADB_CHECKHDR(_mhp, _ext) ((_mhp)->ext[(_ext)] == NULL)

	-static VNET_DEFINE(int, ipsec_esp_keymin) = 256;
	-static VNET_DEFINE(int, ipsec_esp_auth) = 0;
	-static VNET_DEFINE(int, ipsec_ah_keymin) = 128;
	+VNET_DEFINE_STATIC(int, ipsec_esp_keymin) = 256;
	+VNET_DEFINE_STATIC(int, ipsec_esp_auth) = 0;
	+VNET_DEFINE_STATIC(int, ipsec_ah_keymin) = 128;

	#define V_ipsec_esp_keymin VNET(ipsec_esp_keymin)
	#define V_ipsec_esp_auth VNET(ipsec_esp_auth)
	@@ -531,7 +531,7 @@
	MALLOC_DEFINE(M_IPSEC_SAR, "ipsec-reg", "ipsec sa acquire");
	MALLOC_DEFINE(M_IPSEC_SPDCACHE, "ipsec-spdcache", "ipsec SPD cache");

	-static VNET_DEFINE(uma_zone_t, key_lft_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, key_lft_zone);
	#define V_key_lft_zone VNET(key_lft_zone)

	static LIST_HEAD(xforms_list, xformsw) xforms = LIST_HEAD_INITIALIZER();
	Index: sys/netipsec/keysock.c
	===================================================================
	--- sys/netipsec/keysock.c
	+++ sys/netipsec/keysock.c
	@@ -71,7 +71,7 @@
	int key_count;
	int any_count;
	};
	-static VNET_DEFINE(struct key_cb, key_cb);
	+VNET_DEFINE_STATIC(struct key_cb, key_cb);
	#define V_key_cb VNET(key_cb)

	static struct sockaddr key_src = { 2, PF_KEY, };
	Index: sys/netpfil/ipfw/ip_fw2.c
	===================================================================
	--- sys/netpfil/ipfw/ip_fw2.c
	+++ sys/netpfil/ipfw/ip_fw2.c
	@@ -110,10 +110,10 @@
	* All ipfw global variables are here.
	*/

	-static VNET_DEFINE(int, fw_deny_unknown_exthdrs);
	+VNET_DEFINE_STATIC(int, fw_deny_unknown_exthdrs);
	#define V_fw_deny_unknown_exthdrs VNET(fw_deny_unknown_exthdrs)

	-static VNET_DEFINE(int, fw_permit_single_frag6) = 1;
	+VNET_DEFINE_STATIC(int, fw_permit_single_frag6) = 1;
	#define V_fw_permit_single_frag6 VNET(fw_permit_single_frag6)

	#ifdef IPFIREWALL_DEFAULT_TO_ACCEPT
	Index: sys/netpfil/ipfw/ip_fw_bpf.c
	===================================================================
	--- sys/netpfil/ipfw/ip_fw_bpf.c
	+++ sys/netpfil/ipfw/ip_fw_bpf.c
	@@ -48,10 +48,10 @@
	#include <netinet/ip_var.h>
	#include <netpfil/ipfw/ip_fw_private.h>

	-static VNET_DEFINE(struct ifnet *, log_if);
	-static VNET_DEFINE(struct ifnet *, pflog_if);
	-static VNET_DEFINE(struct if_clone *, ipfw_cloner);
	-static VNET_DEFINE(struct if_clone *, ipfwlog_cloner);
	+VNET_DEFINE_STATIC(struct ifnet *, log_if);
	+VNET_DEFINE_STATIC(struct ifnet *, pflog_if);
	+VNET_DEFINE_STATIC(struct if_clone *, ipfw_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, ipfwlog_cloner);
	#define V_ipfw_cloner VNET(ipfw_cloner)
	#define V_ipfwlog_cloner VNET(ipfwlog_cloner)
	#define V_log_if VNET(log_if)
	Index: sys/netpfil/ipfw/ip_fw_dynamic.c
	===================================================================
	--- sys/netpfil/ipfw/ip_fw_dynamic.c
	+++ sys/netpfil/ipfw/ip_fw_dynamic.c
	@@ -179,11 +179,11 @@
	SLIST_ENTRY(dyn_ipv4_state) expired;
	};
	CK_SLIST_HEAD(dyn_ipv4ck_slist, dyn_ipv4_state);
	-static VNET_DEFINE(struct dyn_ipv4ck_slist *, dyn_ipv4);
	-static VNET_DEFINE(struct dyn_ipv4ck_slist *, dyn_ipv4_parent);
	+VNET_DEFINE_STATIC(struct dyn_ipv4ck_slist *, dyn_ipv4);
	+VNET_DEFINE_STATIC(struct dyn_ipv4ck_slist *, dyn_ipv4_parent);

	SLIST_HEAD(dyn_ipv4_slist, dyn_ipv4_state);
	-static VNET_DEFINE(struct dyn_ipv4_slist, dyn_expired_ipv4);
	+VNET_DEFINE_STATIC(struct dyn_ipv4_slist, dyn_expired_ipv4);
	#define V_dyn_ipv4 VNET(dyn_ipv4)
	#define V_dyn_ipv4_parent VNET(dyn_ipv4_parent)
	#define V_dyn_expired_ipv4 VNET(dyn_expired_ipv4)
	@@ -204,11 +204,11 @@
	SLIST_ENTRY(dyn_ipv6_state) expired;
	};
	CK_SLIST_HEAD(dyn_ipv6ck_slist, dyn_ipv6_state);
	-static VNET_DEFINE(struct dyn_ipv6ck_slist *, dyn_ipv6);
	-static VNET_DEFINE(struct dyn_ipv6ck_slist *, dyn_ipv6_parent);
	+VNET_DEFINE_STATIC(struct dyn_ipv6ck_slist *, dyn_ipv6);
	+VNET_DEFINE_STATIC(struct dyn_ipv6ck_slist *, dyn_ipv6_parent);

	SLIST_HEAD(dyn_ipv6_slist, dyn_ipv6_state);
	-static VNET_DEFINE(struct dyn_ipv6_slist, dyn_expired_ipv6);
	+VNET_DEFINE_STATIC(struct dyn_ipv6_slist, dyn_expired_ipv6);
	#define V_dyn_ipv6 VNET(dyn_ipv6)
	#define V_dyn_ipv6_parent VNET(dyn_ipv6_parent)
	#define V_dyn_expired_ipv6 VNET(dyn_expired_ipv6)
	@@ -255,28 +255,28 @@
	* Currently one dyn_bucket_lock is used for all ipv4, ipv4_parent, ipv6,
	* and ipv6_parent lists.
	*/
	-static VNET_DEFINE(struct mtx, dyn_expire_lock);
	-static VNET_DEFINE(struct mtx *, dyn_bucket_lock);
	+VNET_DEFINE_STATIC(struct mtx, dyn_expire_lock);
	+VNET_DEFINE_STATIC(struct mtx *, dyn_bucket_lock);
	#define V_dyn_expire_lock VNET(dyn_expire_lock)
	#define V_dyn_bucket_lock VNET(dyn_bucket_lock)

	/*
	* Bucket's add/delete generation versions.
	*/
	-static VNET_DEFINE(uint32_t *, dyn_ipv4_add);
	-static VNET_DEFINE(uint32_t *, dyn_ipv4_del);
	-static VNET_DEFINE(uint32_t *, dyn_ipv4_parent_add);
	-static VNET_DEFINE(uint32_t *, dyn_ipv4_parent_del);
	+VNET_DEFINE_STATIC(uint32_t *, dyn_ipv4_add);
	+VNET_DEFINE_STATIC(uint32_t *, dyn_ipv4_del);
	+VNET_DEFINE_STATIC(uint32_t *, dyn_ipv4_parent_add);
	+VNET_DEFINE_STATIC(uint32_t *, dyn_ipv4_parent_del);
	#define V_dyn_ipv4_add VNET(dyn_ipv4_add)
	#define V_dyn_ipv4_del VNET(dyn_ipv4_del)
	#define V_dyn_ipv4_parent_add VNET(dyn_ipv4_parent_add)
	#define V_dyn_ipv4_parent_del VNET(dyn_ipv4_parent_del)

	#ifdef INET6
	-static VNET_DEFINE(uint32_t *, dyn_ipv6_add);
	-static VNET_DEFINE(uint32_t *, dyn_ipv6_del);
	-static VNET_DEFINE(uint32_t *, dyn_ipv6_parent_add);
	-static VNET_DEFINE(uint32_t *, dyn_ipv6_parent_del);
	+VNET_DEFINE_STATIC(uint32_t *, dyn_ipv6_add);
	+VNET_DEFINE_STATIC(uint32_t *, dyn_ipv6_del);
	+VNET_DEFINE_STATIC(uint32_t *, dyn_ipv6_parent_add);
	+VNET_DEFINE_STATIC(uint32_t *, dyn_ipv6_parent_del);
	#define V_dyn_ipv6_add VNET(dyn_ipv6_add)
	#define V_dyn_ipv6_del VNET(dyn_ipv6_del)
	#define V_dyn_ipv6_parent_add VNET(dyn_ipv6_parent_add)
	@@ -300,25 +300,25 @@
	#define DYN_EXPIRED_LOCK() mtx_lock(&V_dyn_expire_lock)
	#define DYN_EXPIRED_UNLOCK() mtx_unlock(&V_dyn_expire_lock)

	-static VNET_DEFINE(uint32_t, dyn_buckets_max);
	-static VNET_DEFINE(uint32_t, curr_dyn_buckets);
	-static VNET_DEFINE(struct callout, dyn_timeout);
	+VNET_DEFINE_STATIC(uint32_t, dyn_buckets_max);
	+VNET_DEFINE_STATIC(uint32_t, curr_dyn_buckets);
	+VNET_DEFINE_STATIC(struct callout, dyn_timeout);
	#define V_dyn_buckets_max VNET(dyn_buckets_max)
	#define V_curr_dyn_buckets VNET(curr_dyn_buckets)
	#define V_dyn_timeout VNET(dyn_timeout)

	/* Maximum length of states chain in a bucket */
	-static VNET_DEFINE(uint32_t, curr_max_length);
	+VNET_DEFINE_STATIC(uint32_t, curr_max_length);
	#define V_curr_max_length VNET(curr_max_length)

	-static VNET_DEFINE(uint32_t, dyn_keep_states);
	+VNET_DEFINE_STATIC(uint32_t, dyn_keep_states);
	#define V_dyn_keep_states VNET(dyn_keep_states)

	-static VNET_DEFINE(uma_zone_t, dyn_data_zone);
	-static VNET_DEFINE(uma_zone_t, dyn_parent_zone);
	-static VNET_DEFINE(uma_zone_t, dyn_ipv4_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, dyn_data_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, dyn_parent_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, dyn_ipv4_zone);
	#ifdef INET6
	-static VNET_DEFINE(uma_zone_t, dyn_ipv6_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, dyn_ipv6_zone);
	#define V_dyn_ipv6_zone VNET(dyn_ipv6_zone)
	#endif /* INET6 */
	#define V_dyn_data_zone VNET(dyn_data_zone)
	@@ -328,12 +328,12 @@
	/*
	* Timeouts for various events in handing dynamic rules.
	*/
	-static VNET_DEFINE(uint32_t, dyn_ack_lifetime);
	-static VNET_DEFINE(uint32_t, dyn_syn_lifetime);
	-static VNET_DEFINE(uint32_t, dyn_fin_lifetime);
	-static VNET_DEFINE(uint32_t, dyn_rst_lifetime);
	-static VNET_DEFINE(uint32_t, dyn_udp_lifetime);
	-static VNET_DEFINE(uint32_t, dyn_short_lifetime);
	+VNET_DEFINE_STATIC(uint32_t, dyn_ack_lifetime);
	+VNET_DEFINE_STATIC(uint32_t, dyn_syn_lifetime);
	+VNET_DEFINE_STATIC(uint32_t, dyn_fin_lifetime);
	+VNET_DEFINE_STATIC(uint32_t, dyn_rst_lifetime);
	+VNET_DEFINE_STATIC(uint32_t, dyn_udp_lifetime);
	+VNET_DEFINE_STATIC(uint32_t, dyn_short_lifetime);

	#define V_dyn_ack_lifetime VNET(dyn_ack_lifetime)
	#define V_dyn_syn_lifetime VNET(dyn_syn_lifetime)
	@@ -350,20 +350,20 @@
	* than dyn_keepalive_period.
	*/
	#define DYN_KEEPALIVE_MAXQ 512
	-static VNET_DEFINE(uint32_t, dyn_keepalive_interval);
	-static VNET_DEFINE(uint32_t, dyn_keepalive_period);
	-static VNET_DEFINE(uint32_t, dyn_keepalive);
	-static VNET_DEFINE(time_t, dyn_keepalive_last);
	+VNET_DEFINE_STATIC(uint32_t, dyn_keepalive_interval);
	+VNET_DEFINE_STATIC(uint32_t, dyn_keepalive_period);
	+VNET_DEFINE_STATIC(uint32_t, dyn_keepalive);
	+VNET_DEFINE_STATIC(time_t, dyn_keepalive_last);

	#define V_dyn_keepalive_interval VNET(dyn_keepalive_interval)
	#define V_dyn_keepalive_period VNET(dyn_keepalive_period)
	#define V_dyn_keepalive VNET(dyn_keepalive)
	#define V_dyn_keepalive_last VNET(dyn_keepalive_last)

	-static VNET_DEFINE(uint32_t, dyn_max); /* max # of dynamic states */
	-static VNET_DEFINE(uint32_t, dyn_count); /* number of states */
	-static VNET_DEFINE(uint32_t, dyn_parent_max); /* max # of parent states */
	-static VNET_DEFINE(uint32_t, dyn_parent_count); /* number of parent states */
	+VNET_DEFINE_STATIC(uint32_t, dyn_max); /* max # of dynamic states */
	+VNET_DEFINE_STATIC(uint32_t, dyn_count); /* number of states */
	+VNET_DEFINE_STATIC(uint32_t, dyn_parent_max); /* max # of parent states */
	+VNET_DEFINE_STATIC(uint32_t, dyn_parent_count); /* number of parent states */

	#define V_dyn_max VNET(dyn_max)
	#define V_dyn_count VNET(dyn_count)
	@@ -781,7 +781,7 @@

	#else /* IPFIREWALL_JENKINSHASH */

	-static VNET_DEFINE(uint32_t, dyn_hashseed);
	+VNET_DEFINE_STATIC(uint32_t, dyn_hashseed);
	#define V_dyn_hashseed VNET(dyn_hashseed)

	static __inline int
	Index: sys/netpfil/ipfw/ip_fw_pfil.c
	===================================================================
	--- sys/netpfil/ipfw/ip_fw_pfil.c
	+++ sys/netpfil/ipfw/ip_fw_pfil.c
	@@ -70,15 +70,15 @@

	#include <machine/in_cksum.h>

	-static VNET_DEFINE(int, fw_enable) = 1;
	+VNET_DEFINE_STATIC(int, fw_enable) = 1;
	#define V_fw_enable VNET(fw_enable)

	#ifdef INET6
	-static VNET_DEFINE(int, fw6_enable) = 1;
	+VNET_DEFINE_STATIC(int, fw6_enable) = 1;
	#define V_fw6_enable VNET(fw6_enable)
	#endif

	-static VNET_DEFINE(int, fwlink_enable) = 0;
	+VNET_DEFINE_STATIC(int, fwlink_enable) = 0;
	#define V_fwlink_enable VNET(fwlink_enable)

	int ipfw_chg_hook(SYSCTL_HANDLER_ARGS);
	Index: sys/netpfil/ipfw/ip_fw_sockopt.c
	===================================================================
	--- sys/netpfil/ipfw/ip_fw_sockopt.c
	+++ sys/netpfil/ipfw/ip_fw_sockopt.c
	@@ -183,7 +183,7 @@
	* static variables followed by global ones
	*/

	-static VNET_DEFINE(uma_zone_t, ipfw_cntr_zone);
	+VNET_DEFINE_STATIC(uma_zone_t, ipfw_cntr_zone);
	#define V_ipfw_cntr_zone VNET(ipfw_cntr_zone)

	void
	Index: sys/netpfil/ipfw/nptv6/nptv6.c
	===================================================================
	--- sys/netpfil/ipfw/nptv6/nptv6.c
	+++ sys/netpfil/ipfw/nptv6/nptv6.c
	@@ -61,7 +61,7 @@
	#include <netpfil/ipfw/ip_fw_private.h>
	#include <netpfil/ipfw/nptv6/nptv6.h>

	-static VNET_DEFINE(uint16_t, nptv6_eid) = 0;
	+VNET_DEFINE_STATIC(uint16_t, nptv6_eid) = 0;
	#define V_nptv6_eid VNET(nptv6_eid)
	#define IPFW_TLV_NPTV6_NAME IPFW_TLV_EACTION_NAME(V_nptv6_eid)

	Index: sys/netpfil/ipfw/pmod/tcpmod.c
	===================================================================
	--- sys/netpfil/ipfw/pmod/tcpmod.c
	+++ sys/netpfil/ipfw/pmod/tcpmod.c
	@@ -56,7 +56,7 @@

	#include <machine/in_cksum.h>

	-static VNET_DEFINE(uint16_t, tcpmod_setmss_eid) = 0;
	+VNET_DEFINE_STATIC(uint16_t, tcpmod_setmss_eid) = 0;
	#define V_tcpmod_setmss_eid VNET(tcpmod_setmss_eid)

	static int
	Index: sys/netpfil/pf/if_pflog.c
	===================================================================
	--- sys/netpfil/pf/if_pflog.c
	+++ sys/netpfil/pf/if_pflog.c
	@@ -96,7 +96,7 @@

	static const char pflogname[] = "pflog";

	-static VNET_DEFINE(struct if_clone *, pflog_cloner);
	+VNET_DEFINE_STATIC(struct if_clone *, pflog_cloner);
	#define V_pflog_cloner VNET(pflog_cloner)

	VNET_DEFINE(struct ifnet , pflogifs[PFLOGIFS_MAX]); / for fast access */
	Index: sys/netpfil/pf/if_pfsync.c
	===================================================================
	--- sys/netpfil/pf/if_pfsync.c
	+++ sys/netpfil/pf/if_pfsync.c
	@@ -229,13 +229,13 @@

	static const char pfsyncname[] = "pfsync";
	static MALLOC_DEFINE(M_PFSYNC, pfsyncname, "pfsync(4) data");
	-static VNET_DEFINE(struct pfsync_softc *, pfsyncif) = NULL;
	+VNET_DEFINE_STATIC(struct pfsync_softc *, pfsyncif) = NULL;
	#define V_pfsyncif VNET(pfsyncif)
	-static VNET_DEFINE(void *, pfsync_swi_cookie) = NULL;
	+VNET_DEFINE_STATIC(void *, pfsync_swi_cookie) = NULL;
	#define V_pfsync_swi_cookie VNET(pfsync_swi_cookie)
	-static VNET_DEFINE(struct pfsyncstats, pfsyncstats);
	+VNET_DEFINE_STATIC(struct pfsyncstats, pfsyncstats);
	#define V_pfsyncstats VNET(pfsyncstats)
	-static VNET_DEFINE(int, pfsync_carp_adj) = CARP_MAXSKEW;
	+VNET_DEFINE_STATIC(int, pfsync_carp_adj) = CARP_MAXSKEW;
	#define V_pfsync_carp_adj VNET(pfsync_carp_adj)

	static void pfsync_timeout(void *);
	Index: sys/netpfil/pf/pf.c
	===================================================================
	--- sys/netpfil/pf/pf.c
	+++ sys/netpfil/pf/pf.c
	@@ -135,7 +135,7 @@
	VNET_DECLARE(int, pf_vnet_active);
	#define V_pf_vnet_active VNET(pf_vnet_active)

	-static VNET_DEFINE(uint32_t, pf_purge_idx);
	+VNET_DEFINE_STATIC(uint32_t, pf_purge_idx);
	#define V_pf_purge_idx VNET(pf_purge_idx)

	/*
	@@ -159,7 +159,7 @@
	};

	STAILQ_HEAD(pf_send_head, pf_send_entry);
	-static VNET_DEFINE(struct pf_send_head, pf_sendqueue);
	+VNET_DEFINE_STATIC(struct pf_send_head, pf_sendqueue);
	#define V_pf_sendqueue VNET(pf_sendqueue)

	static struct mtx pf_sendqueue_mtx;
	@@ -179,9 +179,9 @@
	};

	SLIST_HEAD(pf_overload_head, pf_overload_entry);
	-static VNET_DEFINE(struct pf_overload_head, pf_overloadqueue);
	+VNET_DEFINE_STATIC(struct pf_overload_head, pf_overloadqueue);
	#define V_pf_overloadqueue VNET(pf_overloadqueue)
	-static VNET_DEFINE(struct task, pf_overloadtask);
	+VNET_DEFINE_STATIC(struct task, pf_overloadtask);
	#define V_pf_overloadtask VNET(pf_overloadtask)

	static struct mtx pf_overloadqueue_mtx;
	@@ -195,7 +195,7 @@
	MTX_SYSINIT(pf_unlnkdrules_mtx, &pf_unlnkdrules_mtx, "pf unlinked rules",
	MTX_DEF);

	-static VNET_DEFINE(uma_zone_t, pf_sources_z);
	+VNET_DEFINE_STATIC(uma_zone_t, pf_sources_z);
	#define V_pf_sources_z VNET(pf_sources_z)
	uma_zone_t pf_mtag_z;
	VNET_DEFINE(uma_zone_t, pf_state_z);
	Index: sys/netpfil/pf/pf_if.c
	===================================================================
	--- sys/netpfil/pf/pf_if.c
	+++ sys/netpfil/pf/pf_if.c
	@@ -55,16 +55,16 @@
	#include <net/route.h>

	VNET_DEFINE(struct pfi_kif *, pfi_all);
	-static VNET_DEFINE(long, pfi_update);
	+VNET_DEFINE_STATIC(long, pfi_update);
	#define V_pfi_update VNET(pfi_update)
	#define PFI_BUFFER_MAX 0x10000

	VNET_DECLARE(int, pf_vnet_active);
	#define V_pf_vnet_active VNET(pf_vnet_active)

	-static VNET_DEFINE(struct pfr_addr *, pfi_buffer);
	-static VNET_DEFINE(int, pfi_buffer_cnt);
	-static VNET_DEFINE(int, pfi_buffer_max);
	+VNET_DEFINE_STATIC(struct pfr_addr *, pfi_buffer);
	+VNET_DEFINE_STATIC(int, pfi_buffer_cnt);
	+VNET_DEFINE_STATIC(int, pfi_buffer_max);
	#define V_pfi_buffer VNET(pfi_buffer)
	#define V_pfi_buffer_cnt VNET(pfi_buffer_cnt)
	#define V_pfi_buffer_max VNET(pfi_buffer_max)
	@@ -98,14 +98,14 @@
	RB_HEAD(pfi_ifhead, pfi_kif);
	static RB_PROTOTYPE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare);
	static RB_GENERATE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare);
	-static VNET_DEFINE(struct pfi_ifhead, pfi_ifs);
	+VNET_DEFINE_STATIC(struct pfi_ifhead, pfi_ifs);
	#define V_pfi_ifs VNET(pfi_ifs)

	#define PFI_BUFFER_MAX 0x10000
	MALLOC_DEFINE(PFI_MTYPE, "pf_ifnet", "pf(4) interface database");

	LIST_HEAD(pfi_list, pfi_kif);
	-static VNET_DEFINE(struct pfi_list, pfi_unlinked_kifs);
	+VNET_DEFINE_STATIC(struct pfi_list, pfi_unlinked_kifs);
	#define V_pfi_unlinked_kifs VNET(pfi_unlinked_kifs)
	static struct mtx pfi_unlnkdkifs_mtx;
	MTX_SYSINIT(pfi_unlnkdkifs_mtx, &pfi_unlnkdkifs_mtx, "pf unlinked interfaces",
	Index: sys/netpfil/pf/pf_ioctl.c
	===================================================================
	--- sys/netpfil/pf/pf_ioctl.c
	+++ sys/netpfil/pf/pf_ioctl.c
	@@ -117,7 +117,7 @@
	VNET_DEFINE(struct pf_rule, pf_default_rule);

	#ifdef ALTQ
	-static VNET_DEFINE(int, pf_altq_running);
	+VNET_DEFINE_STATIC(int, pf_altq_running);
	#define V_pf_altq_running VNET(pf_altq_running)
	#endif

	@@ -187,7 +187,7 @@
	.d_version = D_VERSION,
	};

	-static volatile VNET_DEFINE(int, pf_pfil_hooked);
	+volatile VNET_DEFINE_STATIC(int, pf_pfil_hooked);
	#define V_pf_pfil_hooked VNET(pf_pfil_hooked)

	/*
	Index: sys/netpfil/pf/pf_norm.c
	===================================================================
	--- sys/netpfil/pf/pf_norm.c
	+++ sys/netpfil/pf/pf_norm.c
	@@ -109,17 +109,17 @@

	VNET_DEFINE(uma_zone_t, pf_state_scrub_z); /* XXX: shared with pfsync */

	-static VNET_DEFINE(uma_zone_t, pf_frent_z);
	+VNET_DEFINE_STATIC(uma_zone_t, pf_frent_z);
	#define V_pf_frent_z VNET(pf_frent_z)
	-static VNET_DEFINE(uma_zone_t, pf_frag_z);
	+VNET_DEFINE_STATIC(uma_zone_t, pf_frag_z);
	#define V_pf_frag_z VNET(pf_frag_z)

	TAILQ_HEAD(pf_fragqueue, pf_fragment);
	TAILQ_HEAD(pf_cachequeue, pf_fragment);
	-static VNET_DEFINE(struct pf_fragqueue, pf_fragqueue);
	+VNET_DEFINE_STATIC(struct pf_fragqueue, pf_fragqueue);
	#define V_pf_fragqueue VNET(pf_fragqueue)
	RB_HEAD(pf_frag_tree, pf_fragment);
	-static VNET_DEFINE(struct pf_frag_tree, pf_frag_tree);
	+VNET_DEFINE_STATIC(struct pf_frag_tree, pf_frag_tree);
	#define V_pf_frag_tree VNET(pf_frag_tree)
	static int pf_frag_compare(struct pf_fragment *,
	struct pf_fragment *);
	Index: sys/netpfil/pf/pf_osfp.c
	===================================================================
	--- sys/netpfil/pf/pf_osfp.c
	+++ sys/netpfil/pf/pf_osfp.c
	@@ -47,7 +47,7 @@
	printf(format , ##x)

	SLIST_HEAD(pf_osfp_list, pf_os_fingerprint);
	-static VNET_DEFINE(struct pf_osfp_list, pf_osfp_list) =
	+VNET_DEFINE_STATIC(struct pf_osfp_list, pf_osfp_list) =
	SLIST_HEAD_INITIALIZER();
	#define V_pf_osfp_list VNET(pf_osfp_list)

	Index: sys/netpfil/pf/pf_table.c
	===================================================================
	--- sys/netpfil/pf/pf_table.c
	+++ sys/netpfil/pf/pf_table.c
	@@ -122,9 +122,9 @@
	#define senderr(e) do { rv = (e); goto _bad; } while (0)

	static MALLOC_DEFINE(M_PFTABLE, "pf_table", "pf(4) tables structures");
	-static VNET_DEFINE(uma_zone_t, pfr_kentry_z);
	+VNET_DEFINE_STATIC(uma_zone_t, pfr_kentry_z);
	#define V_pfr_kentry_z VNET(pfr_kentry_z)
	-static VNET_DEFINE(uma_zone_t, pfr_kcounters_z);
	+VNET_DEFINE_STATIC(uma_zone_t, pfr_kcounters_z);
	#define V_pfr_kcounters_z VNET(pfr_kcounters_z)

	static struct pf_addr pfr_ffaddr = {
	@@ -184,13 +184,13 @@
	static RB_PROTOTYPE(pfr_ktablehead, pfr_ktable, pfrkt_tree, pfr_ktable_compare);
	static RB_GENERATE(pfr_ktablehead, pfr_ktable, pfrkt_tree, pfr_ktable_compare);

	-static VNET_DEFINE(struct pfr_ktablehead, pfr_ktables);
	+VNET_DEFINE_STATIC(struct pfr_ktablehead, pfr_ktables);
	#define V_pfr_ktables VNET(pfr_ktables)

	-static VNET_DEFINE(struct pfr_table, pfr_nulltable);
	+VNET_DEFINE_STATIC(struct pfr_table, pfr_nulltable);
	#define V_pfr_nulltable VNET(pfr_nulltable)

	-static VNET_DEFINE(int, pfr_ktable_cnt);
	+VNET_DEFINE_STATIC(int, pfr_ktable_cnt);
	#define V_pfr_ktable_cnt VNET(pfr_ktable_cnt)

	void

File Metadata

Mime Type: text/plain
Expires: Tue, Apr 7, 12:19 AM (12 h, 30 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 31003476
Default Alt Text: D16147.id45599.diff (94 KB)

D16147.id45599.diffNo OneTemporaryActions

D16147.id45599.diffView Options

File Metadata

Event Timeline

D16147.id45599.diff
No OneTemporary
Actions

D16147.id45599.diff
View Options