15 files changed, 80 insertions, 80 deletions

diff --git a/sys/netpfil/ipfw/ip_fw2.c b/sys/netpfil/ipfw/ip_fw2.c
index eb2b120e51ca..de0018ec2eb6 100644
--- a/sys/netpfil/ipfw/ip_fw2.c
+++ b/sys/netpfil/ipfw/ip_fw2.c
@@ -110,10 +110,10 @@ __FBSDID("$FreeBSD$");
  * 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
diff --git a/sys/netpfil/ipfw/ip_fw_bpf.c b/sys/netpfil/ipfw/ip_fw_bpf.c
index 6f8aa39701c5..d7e10596573f 100644
--- a/sys/netpfil/ipfw/ip_fw_bpf.c
+++ b/sys/netpfil/ipfw/ip_fw_bpf.c
@@ -48,10 +48,10 @@ __FBSDID("$FreeBSD$");
 #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)
diff --git a/sys/netpfil/ipfw/ip_fw_dynamic.c b/sys/netpfil/ipfw/ip_fw_dynamic.c
index 6f877edf7944..761b768cd20e 100644
--- a/sys/netpfil/ipfw/ip_fw_dynamic.c
+++ b/sys/netpfil/ipfw/ip_fw_dynamic.c
@@ -179,11 +179,11 @@ struct dyn_ipv4_state {
 	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 @@ struct dyn_ipv6_state {
 	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 @@ DPCPU_DEFINE_STATIC(void *, dyn_hp);
  * 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 @@ static VNET_DEFINE(uint32_t *, dyn_ipv6_parent_del);
 #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 @@ static VNET_DEFINE(uma_zone_t, dyn_ipv6_zone);
 /*
  * 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 @@ static VNET_DEFINE(uint32_t, dyn_short_lifetime);
  * 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 @@ hash_parent(const struct ipfw_flow_id *id, const void *rule)
 
 #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
diff --git a/sys/netpfil/ipfw/ip_fw_pfil.c b/sys/netpfil/ipfw/ip_fw_pfil.c
index 2e2c99734756..56d5e9f9e780 100644
--- a/sys/netpfil/ipfw/ip_fw_pfil.c
+++ b/sys/netpfil/ipfw/ip_fw_pfil.c
@@ -70,15 +70,15 @@ __FBSDID("$FreeBSD$");
 
 #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);
diff --git a/sys/netpfil/ipfw/ip_fw_sockopt.c b/sys/netpfil/ipfw/ip_fw_sockopt.c
index b98e71abbec8..f872032c5094 100644
--- a/sys/netpfil/ipfw/ip_fw_sockopt.c
+++ b/sys/netpfil/ipfw/ip_fw_sockopt.c
@@ -183,7 +183,7 @@ static size_t ctl3_rsize;
  * 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
diff --git a/sys/netpfil/ipfw/nptv6/nptv6.c b/sys/netpfil/ipfw/nptv6/nptv6.c
index 302560ddaf77..f4724fc683e8 100644
--- a/sys/netpfil/ipfw/nptv6/nptv6.c
+++ b/sys/netpfil/ipfw/nptv6/nptv6.c
@@ -61,7 +61,7 @@ __FBSDID("$FreeBSD$");
 #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)
 
diff --git a/sys/netpfil/ipfw/pmod/tcpmod.c b/sys/netpfil/ipfw/pmod/tcpmod.c
index 10b6d2d6a3a3..e9fabff6a046 100644
--- a/sys/netpfil/ipfw/pmod/tcpmod.c
+++ b/sys/netpfil/ipfw/pmod/tcpmod.c
@@ -56,7 +56,7 @@ __FBSDID("$FreeBSD$");
 
 #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
diff --git a/sys/netpfil/pf/if_pflog.c b/sys/netpfil/pf/if_pflog.c
index 6c072701457d..87e674f46942 100644
--- a/sys/netpfil/pf/if_pflog.c
+++ b/sys/netpfil/pf/if_pflog.c
@@ -96,7 +96,7 @@ static void	pflog_clone_destroy(struct ifnet *);
 
 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 */
diff --git a/sys/netpfil/pf/if_pfsync.c b/sys/netpfil/pf/if_pfsync.c
index a2008adbfda3..71d6696d4eff 100644
--- a/sys/netpfil/pf/if_pfsync.c
+++ b/sys/netpfil/pf/if_pfsync.c
@@ -229,13 +229,13 @@ struct pfsync_softc {
 
 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 *);
diff --git a/sys/netpfil/pf/pf.c b/sys/netpfil/pf/pf.c
index b5039c819537..08eea294b4e2 100644
--- a/sys/netpfil/pf/pf.c
+++ b/sys/netpfil/pf/pf.c
@@ -135,7 +135,7 @@ VNET_DEFINE(int,			 pf_tcp_iss_off);
 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 @@ struct pf_send_entry {
 };
 
 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 @@ struct pf_overload_entry {
 };
 
 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 @@ struct mtx pf_unlnkdrules_mtx;
 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);
diff --git a/sys/netpfil/pf/pf_if.c b/sys/netpfil/pf/pf_if.c
index 1c9130fdbbe7..15c19e747c86 100644
--- a/sys/netpfil/pf/pf_if.c
+++ b/sys/netpfil/pf/pf_if.c
@@ -55,16 +55,16 @@ __FBSDID("$FreeBSD$");
 #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 @@ static void	 pfi_ifaddr_event(void * __unused, struct ifnet *);
 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",
diff --git a/sys/netpfil/pf/pf_ioctl.c b/sys/netpfil/pf/pf_ioctl.c
index 381e349e96c3..fa2c2d131d13 100644
--- a/sys/netpfil/pf/pf_ioctl.c
+++ b/sys/netpfil/pf/pf_ioctl.c
@@ -117,7 +117,7 @@ static void		 pf_addr_copyout(struct pf_addr_wrap *);
 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 @@ static struct cdevsw pf_cdevsw = {
 	.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)
 
 /*
diff --git a/sys/netpfil/pf/pf_norm.c b/sys/netpfil/pf/pf_norm.c
index 719f64f4f22c..5e8598e9758f 100644
--- a/sys/netpfil/pf/pf_norm.c
+++ b/sys/netpfil/pf/pf_norm.c
@@ -109,17 +109,17 @@ MTX_SYSINIT(pf_frag_mtx, &pf_frag_mtx, "pf fragments", MTX_DEF);
 
 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 *);
diff --git a/sys/netpfil/pf/pf_osfp.c b/sys/netpfil/pf/pf_osfp.c
index 55ee7785267b..e00cce5c4d36 100644
--- a/sys/netpfil/pf/pf_osfp.c
+++ b/sys/netpfil/pf/pf_osfp.c
@@ -47,7 +47,7 @@ static MALLOC_DEFINE(M_PFOSFP, "pf_osfp", "pf(4) operating system fingerprints")
 		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)
 
diff --git a/sys/netpfil/pf/pf_table.c b/sys/netpfil/pf/pf_table.c
index 0a8925962456..0e43c0b846c8 100644
--- a/sys/netpfil/pf/pf_table.c
+++ b/sys/netpfil/pf/pf_table.c
@@ -122,9 +122,9 @@ struct pfr_walktree {
 #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 struct pfr_kentry
 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