diff --git a/sys/netinet/ip_reass.c b/sys/netinet/ip_reass.c
--- a/sys/netinet/ip_reass.c
+++ b/sys/netinet/ip_reass.c
@@ -87,7 +87,7 @@
 #define	V_ipq		VNET(ipq)
 VNET_DEFINE_STATIC(uint32_t, ipq_hashseed);
 #define	V_ipq_hashseed	VNET(ipq_hashseed)
-VNET_DEFINE_STATIC(uint32_t, ipq_hashsize);
+VNET_DEFINE_STATIC(uint32_t, ipq_hashsize) = IPREASS_NHASH;
 #define	V_ipq_hashsize	VNET(ipq_hashsize)
 
 #define	IPQ_LOCK(i)	mtx_lock(&V_ipq[i].lock)
@@ -682,8 +682,6 @@
 {
 	int max;
 
-	V_ipq_hashsize = IPREASS_NHASH;
-	TUNABLE_INT_FETCH("net.inet.ip.reass_hashsize", &V_ipq_hashsize);
 	V_ipq = malloc(sizeof(struct ipqbucket) * V_ipq_hashsize,
 	    M_IPREASS_HASH, M_WAITOK);
 
diff --git a/sys/netinet/tcp_hostcache.c b/sys/netinet/tcp_hostcache.c
--- a/sys/netinet/tcp_hostcache.c
+++ b/sys/netinet/tcp_hostcache.c
@@ -143,7 +143,12 @@
 #define TCP_HOSTCACHE_EXPIRE		60*60	/* one hour */
 #define TCP_HOSTCACHE_PRUNE		5*60	/* every 5 minutes */
 
-VNET_DEFINE_STATIC(struct tcp_hostcache, tcp_hostcache);
+VNET_DEFINE_STATIC(struct tcp_hostcache, tcp_hostcache) = {
+	.hashsize = TCP_HOSTCACHE_HASHSIZE,
+	.bucket_limit = TCP_HOSTCACHE_BUCKETLIMIT,
+	.expire = TCP_HOSTCACHE_EXPIRE,
+	.prune = TCP_HOSTCACHE_PRUNE,
+};
 #define	V_tcp_hostcache		VNET(tcp_hostcache)
 
 VNET_DEFINE_STATIC(struct callout, tcp_hc_callout);
@@ -232,29 +237,18 @@
 	/*
 	 * Initialize hostcache structures.
 	 */
-	atomic_store_int(&V_tcp_hostcache.cache_count, 0);
-	V_tcp_hostcache.hashsize = TCP_HOSTCACHE_HASHSIZE;
-	V_tcp_hostcache.bucket_limit = TCP_HOSTCACHE_BUCKETLIMIT;
-	V_tcp_hostcache.expire = TCP_HOSTCACHE_EXPIRE;
-	V_tcp_hostcache.prune = TCP_HOSTCACHE_PRUNE;
 	V_tcp_hostcache.hashsalt = arc4random();
 
-	TUNABLE_INT_FETCH("net.inet.tcp.hostcache.hashsize",
-	    &V_tcp_hostcache.hashsize);
 	if (!powerof2(V_tcp_hostcache.hashsize)) {
 		printf("WARNING: hostcache hash size is not a power of 2.\n");
 		V_tcp_hostcache.hashsize = TCP_HOSTCACHE_HASHSIZE; /* default */
 	}
 	V_tcp_hostcache.hashmask = V_tcp_hostcache.hashsize - 1;
 
-	TUNABLE_INT_FETCH("net.inet.tcp.hostcache.bucketlimit",
-	    &V_tcp_hostcache.bucket_limit);
-
 	cache_limit = V_tcp_hostcache.hashsize * V_tcp_hostcache.bucket_limit;
-	V_tcp_hostcache.cache_limit = cache_limit;
-	TUNABLE_INT_FETCH("net.inet.tcp.hostcache.cachelimit",
-	    &V_tcp_hostcache.cache_limit);
-	if (V_tcp_hostcache.cache_limit > cache_limit)
+	if (V_tcp_hostcache.cache_limit == 0)
+		V_tcp_hostcache.cache_limit = cache_limit;
+	else if (V_tcp_hostcache.cache_limit > cache_limit)
 		V_tcp_hostcache.cache_limit = cache_limit;
 
 	/*
diff --git a/sys/netinet/tcp_syncache.c b/sys/netinet/tcp_syncache.c
--- a/sys/netinet/tcp_syncache.c
+++ b/sys/netinet/tcp_syncache.c
@@ -170,7 +170,11 @@
 #define TCP_SYNCACHE_HASHSIZE		512
 #define TCP_SYNCACHE_BUCKETLIMIT	30
 
-VNET_DEFINE_STATIC(struct tcp_syncache, tcp_syncache);
+VNET_DEFINE_STATIC(struct tcp_syncache, tcp_syncache) = {
+	.hashsize = TCP_SYNCACHE_HASHSIZE,
+	.bucket_limit = TCP_SYNCACHE_BUCKETLIMIT,
+	.rexmt_limit = SYNCACHE_MAXREXMTS,
+};
 #define	V_tcp_syncache			VNET(tcp_syncache)
 
 static SYSCTL_NODE(_net_inet_tcp, OID_AUTO, syncache,
@@ -192,8 +196,8 @@
     &VNET_NAME(tcp_syncache.hashsize), 0,
     "Size of TCP syncache hashtable");
 
-SYSCTL_BOOL(_net_inet_tcp_syncache, OID_AUTO, see_other, CTLFLAG_VNET |
-    CTLFLAG_RW, &VNET_NAME(tcp_syncache.see_other), 0,
+SYSCTL_BOOL(_net_inet_tcp_syncache, OID_AUTO, see_other, CTLFLAG_VNET | CTLFLAG_RW,
+    &VNET_NAME(tcp_syncache.see_other), 0,
     "All syncache(4) entries are visible, ignoring UID/GID, jail(2) "
     "and mac(4) checks");
 
@@ -254,15 +258,8 @@
 {
 	int i;
 
-	V_tcp_syncache.hashsize = TCP_SYNCACHE_HASHSIZE;
-	V_tcp_syncache.bucket_limit = TCP_SYNCACHE_BUCKETLIMIT;
-	V_tcp_syncache.rexmt_limit = SYNCACHE_MAXREXMTS;
 	V_tcp_syncache.hash_secret = arc4random();
 
-	TUNABLE_INT_FETCH("net.inet.tcp.syncache.hashsize",
-	    &V_tcp_syncache.hashsize);
-	TUNABLE_INT_FETCH("net.inet.tcp.syncache.bucketlimit",
-	    &V_tcp_syncache.bucket_limit);
 	if (!powerof2(V_tcp_syncache.hashsize) ||
 	    V_tcp_syncache.hashsize == 0) {
 		printf("WARNING: syncache hash size is not a power of 2.\n");
@@ -271,10 +268,10 @@
 	V_tcp_syncache.hashmask = V_tcp_syncache.hashsize - 1;
 
 	/* Set limits. */
-	V_tcp_syncache.cache_limit =
-	    V_tcp_syncache.hashsize * V_tcp_syncache.bucket_limit;
-	TUNABLE_INT_FETCH("net.inet.tcp.syncache.cachelimit",
-	    &V_tcp_syncache.cache_limit);
+	if (V_tcp_syncache.cache_limit == 0) {
+		V_tcp_syncache.cache_limit =
+		    V_tcp_syncache.hashsize * V_tcp_syncache.bucket_limit;
+	}
 
 	/* Allocate the hash table. */
 	V_tcp_syncache.hashbase = malloc(V_tcp_syncache.hashsize *