Mark more nodes as CTLFLAG_MPSAFE or CTLFLAG_NEEDGIANT (17 of many)

r357614 added CTLFLAG_NEEDGIANT to make it easier to find nodes that are
still not MPSAFE (or already are but aren’t properly marked).
Use it in preparation for a general review of all nodes.

This is non-functional change that adds annotations to SYSCTL_NODE and
SYSCTL_PROC nodes using one of the soon-to-be-required flags.

Mark all obvious cases as MPSAFE.  All entries that haven't been marked
as MPSAFE before are by default marked as NEEDGIANT

Approved by:	kib (mentor, blanket)
Commented by:	kib, gallatin, melifaro
Differential Revision:	https://reviews.freebsd.org/D23718

200 files changed, 1775 insertions, 1555 deletions

diff --git a/sys/dev/aac/aac.c b/sys/dev/aac/aac.c
index 74e9fc7f34a8..e4a4ec102d20 100644
--- a/sys/dev/aac/aac.c
+++ b/sys/dev/aac/aac.c
@@ -225,7 +225,8 @@ static struct cdevsw aac_cdevsw = {
 static MALLOC_DEFINE(M_AACBUF, "aacbuf", "Buffers for the AAC driver");
 
 /* sysctl node */
-SYSCTL_NODE(_hw, OID_AUTO, aac, CTLFLAG_RD, 0, "AAC driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, aac, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "AAC driver parameters");
 
 /*
  * Device Interface
diff --git a/sys/dev/aacraid/aacraid.c b/sys/dev/aacraid/aacraid.c
index a1a6f37b374b..688286c6c993 100644
--- a/sys/dev/aacraid/aacraid.c
+++ b/sys/dev/aacraid/aacraid.c
@@ -224,7 +224,8 @@ static struct cdevsw aacraid_cdevsw = {
 MALLOC_DEFINE(M_AACRAIDBUF, "aacraid_buf", "Buffers for the AACRAID driver");
 
 /* sysctl node */
-SYSCTL_NODE(_hw, OID_AUTO, aacraid, CTLFLAG_RD, 0, "AACRAID driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, aacraid, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "AACRAID driver parameters");
 
 /*
  * Device Interface
diff --git a/sys/dev/acpi_support/acpi_asus.c b/sys/dev/acpi_support/acpi_asus.c
index 5111146b0a3e..85bfeb46ff38 100644
--- a/sys/dev/acpi_support/acpi_asus.c
+++ b/sys/dev/acpi_support/acpi_asus.c
@@ -731,7 +731,7 @@ acpi_asus_attach(device_t dev)
 	sysctl_ctx_init(&sc->sysctl_ctx);
 	sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 	    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
-	    OID_AUTO, "asus", CTLFLAG_RD, 0, "");
+	    OID_AUTO, "asus", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
 
 	/* Hook up nodes */
 	for (int i = 0; acpi_asus_sysctls[i].name != NULL; i++) {
@@ -742,14 +742,14 @@ acpi_asus_attach(device_t dev)
 			SYSCTL_ADD_PROC(&sc->sysctl_ctx,
 			    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 			    acpi_asus_sysctls[i].name,
-			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
-			    sc, i, acpi_asus_sysctl, "I",
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY |
+			    CTLFLAG_NEEDGIANT, sc, i, acpi_asus_sysctl, "I",
 			    acpi_asus_sysctls[i].description);
 		} else {
 			SYSCTL_ADD_PROC(&sc->sysctl_ctx,
 			    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 			    acpi_asus_sysctls[i].name,
-			    CTLTYPE_INT | CTLFLAG_RW,
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 			    sc, i, acpi_asus_sysctl, "I",
 			    acpi_asus_sysctls[i].description);
 		}
diff --git a/sys/dev/acpi_support/acpi_asus_wmi.c b/sys/dev/acpi_support/acpi_asus_wmi.c
index 7538d3d2bed5..b4506e218938 100644
--- a/sys/dev/acpi_support/acpi_asus_wmi.c
+++ b/sys/dev/acpi_support/acpi_asus_wmi.c
@@ -429,14 +429,14 @@ next:
 			SYSCTL_ADD_PROC(sc->sysctl_ctx,
 			    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 			    acpi_asus_wmi_sysctls[i].name,
-			    CTLTYPE_INT | CTLFLAG_RD,
+			    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 			    sc, i, acpi_asus_wmi_sysctl, "I",
 			    acpi_asus_wmi_sysctls[i].description);
 		} else {
 			SYSCTL_ADD_PROC(sc->sysctl_ctx,
 			    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 			    acpi_asus_wmi_sysctls[i].name,
-			    CTLTYPE_INT | CTLFLAG_RW,
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 			    sc, i, acpi_asus_wmi_sysctl, "I",
 			    acpi_asus_wmi_sysctls[i].description);
 		}
diff --git a/sys/dev/acpi_support/acpi_fujitsu.c b/sys/dev/acpi_support/acpi_fujitsu.c
index 98fd1fe0e36a..3a4c2be637ad 100644
--- a/sys/dev/acpi_support/acpi_fujitsu.c
+++ b/sys/dev/acpi_support/acpi_fujitsu.c
@@ -385,7 +385,7 @@ acpi_fujitsu_init(struct acpi_fujitsu_softc *sc)
 	sysctl_ctx_init(&sc->sysctl_ctx);
 	sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 	    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
-	    OID_AUTO, "fujitsu", CTLFLAG_RD, 0, "");
+	    OID_AUTO, "fujitsu", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
 
 	for (i = 0; sysctl_table[i].name != NULL; i++) {
 		switch(sysctl_table[i].method) {
@@ -418,8 +418,8 @@ acpi_fujitsu_init(struct acpi_fujitsu_softc *sc)
 		SYSCTL_ADD_PROC(&sc->sysctl_ctx,
 		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 		    sysctl_table[i].name,
-		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
-		    sc, i, acpi_fujitsu_sysctl, "I",
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY |
+		    CTLFLAG_NEEDGIANT, sc, i, acpi_fujitsu_sysctl, "I",
 		    sysctl_table[i].description);
 	}
 
diff --git a/sys/dev/acpi_support/acpi_hp.c b/sys/dev/acpi_support/acpi_hp.c
index e9de245e264a..aaf27b2c76c3 100644
--- a/sys/dev/acpi_support/acpi_hp.c
+++ b/sys/dev/acpi_support/acpi_hp.c
@@ -593,13 +593,15 @@ acpi_hp_attach(device_t dev)
 		if (acpi_hp_sysctls[i].flag_rdonly != 0) {
 			SYSCTL_ADD_PROC(sc->sysctl_ctx,
 			    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
-			    acpi_hp_sysctls[i].name, CTLTYPE_INT | CTLFLAG_RD,
+			    acpi_hp_sysctls[i].name,
+			    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 			    sc, i, acpi_hp_sysctl, "I",
 			    acpi_hp_sysctls[i].description);
 		} else {
 			SYSCTL_ADD_PROC(sc->sysctl_ctx,
 			    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
-			    acpi_hp_sysctls[i].name, CTLTYPE_INT | CTLFLAG_RW,
+			    acpi_hp_sysctls[i].name,
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 			    sc, i, acpi_hp_sysctl, "I",
 			    acpi_hp_sysctls[i].description);
 		}
diff --git a/sys/dev/acpi_support/acpi_ibm.c b/sys/dev/acpi_support/acpi_ibm.c
index 376b61095d6e..9ec9f7e84c94 100644
--- a/sys/dev/acpi_support/acpi_ibm.c
+++ b/sys/dev/acpi_support/acpi_ibm.c
@@ -543,13 +543,15 @@ acpi_ibm_attach(device_t dev)
 		if (acpi_ibm_sysctls[i].flag_rdonly != 0) {
 			SYSCTL_ADD_PROC(sc->sysctl_ctx,
 			    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
-			    acpi_ibm_sysctls[i].name, CTLTYPE_INT | CTLFLAG_RD,
+			    acpi_ibm_sysctls[i].name,
+			    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 			    sc, i, acpi_ibm_sysctl, "I",
 			    acpi_ibm_sysctls[i].description);
 		} else {
 			SYSCTL_ADD_PROC(sc->sysctl_ctx,
 			    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
-			    acpi_ibm_sysctls[i].name, CTLTYPE_INT | CTLFLAG_RW,
+			    acpi_ibm_sysctls[i].name,
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 			    sc, i, acpi_ibm_sysctl, "I",
 			    acpi_ibm_sysctls[i].description);
 		}
@@ -559,15 +561,15 @@ acpi_ibm_attach(device_t dev)
 	if (acpi_ibm_sysctl_init(sc, ACPI_IBM_METHOD_THERMAL)) {
 		SYSCTL_ADD_PROC(sc->sysctl_ctx,
 		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, "thermal",
-		    CTLTYPE_INT | CTLFLAG_RD, sc, 0, acpi_ibm_thermal_sysctl,
-		    "I", "Thermal zones");
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+		    acpi_ibm_thermal_sysctl, "I", "Thermal zones");
 	}
 
 	/* Hook up handlerevents node */
 	if (acpi_ibm_sysctl_init(sc, ACPI_IBM_METHOD_HANDLEREVENTS)) {
 		SYSCTL_ADD_PROC(sc->sysctl_ctx,
 		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, "handlerevents",
-		    CTLTYPE_STRING | CTLFLAG_RW, sc, 0,
+		    CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
 		    acpi_ibm_handlerevents_sysctl, "I",
 		    "devd(8) events handled by acpi_ibm");
 	}
diff --git a/sys/dev/acpi_support/acpi_panasonic.c b/sys/dev/acpi_support/acpi_panasonic.c
index b54b06cb61b4..c8f8d58c9ae8 100644
--- a/sys/dev/acpi_support/acpi_panasonic.c
+++ b/sys/dev/acpi_support/acpi_panasonic.c
@@ -168,13 +168,13 @@ acpi_panasonic_attach(device_t dev)
 	sysctl_ctx_init(&sc->sysctl_ctx);
 	sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 	    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO,
-	    "panasonic", CTLFLAG_RD, 0, "");
+	    "panasonic", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
 	for (i = 0; sysctl_table[i].name != NULL; i++) {
 		SYSCTL_ADD_PROC(&sc->sysctl_ctx,
 		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 		    sysctl_table[i].name,
-		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
-		    sc, i, acpi_panasonic_sysctl, "I", "");
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY |
+		    CTLFLAG_NEEDGIANT, sc, i, acpi_panasonic_sysctl, "I", "");
 	}
 
 #if 0
diff --git a/sys/dev/acpi_support/acpi_rapidstart.c b/sys/dev/acpi_support/acpi_rapidstart.c
index 4b896338db80..b5fb5173754a 100644
--- a/sys/dev/acpi_support/acpi_rapidstart.c
+++ b/sys/dev/acpi_support/acpi_rapidstart.c
@@ -90,14 +90,14 @@ acpi_rapidstart_attach(device_t dev)
 			SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 			    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 			    i, acpi_rapidstart_oids[i].nodename,
-			    CTLTYPE_INT | CTLFLAG_RW,
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 			    dev, i, sysctl_acpi_rapidstart_gen_handler, "I",
 			    acpi_rapidstart_oids[i].comment);
 		} else {
 			SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 			    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 			    i, acpi_rapidstart_oids[i].nodename,
-			    CTLTYPE_INT | CTLFLAG_RD,
+			    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 			    dev, i, sysctl_acpi_rapidstart_gen_handler, "I",
 			    acpi_rapidstart_oids[i].comment);
 		}
diff --git a/sys/dev/acpi_support/acpi_sony.c b/sys/dev/acpi_support/acpi_sony.c
index 97c35d58f412..0cfb312b552f 100644
--- a/sys/dev/acpi_support/acpi_sony.c
+++ b/sys/dev/acpi_support/acpi_sony.c
@@ -137,14 +137,14 @@ acpi_sony_attach(device_t dev)
 			SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 			    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 			    i, acpi_sony_oids[i].nodename ,
-			    CTLTYPE_INT | CTLFLAG_RW,
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 			    dev, i, sysctl_acpi_sony_gen_handler, "I",
 			    acpi_sony_oids[i].comment);
 		} else {
 			SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 			    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 			    i, acpi_sony_oids[i].nodename ,
-			    CTLTYPE_INT | CTLFLAG_RD,
+			    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 			    dev, i, sysctl_acpi_sony_gen_handler, "I",
 			    acpi_sony_oids[i].comment);
 		}
diff --git a/sys/dev/acpi_support/acpi_toshiba.c b/sys/dev/acpi_support/acpi_toshiba.c
index 612a12ea621d..a9b537edf993 100644
--- a/sys/dev/acpi_support/acpi_toshiba.c
+++ b/sys/dev/acpi_support/acpi_toshiba.c
@@ -247,14 +247,14 @@ acpi_toshiba_attach(device_t dev)
 	sysctl_ctx_init(&sc->sysctl_ctx);
 	sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 	    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO,
-	    "toshiba", CTLFLAG_RD, 0, "");
+	    "toshiba", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
 
 	for (i = 0; sysctl_table[i].name != NULL; i++) {
 		SYSCTL_ADD_PROC(&sc->sysctl_ctx,
 		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 		    sysctl_table[i].name,
-		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
-		    sc, i, acpi_toshiba_sysctl, "I", "");
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY |
+		    CTLFLAG_NEEDGIANT, sc, i, acpi_toshiba_sysctl, "I", "");
 	}
 
 	if (enable_fn_keys != 0) {
diff --git a/sys/dev/acpi_support/atk0110.c b/sys/dev/acpi_support/atk0110.c
index 1f589ae4bd91..202421120e60 100644
--- a/sys/dev/acpi_support/atk0110.c
+++ b/sys/dev/acpi_support/atk0110.c
@@ -234,7 +234,7 @@ aibs_sensor_added(struct aibs_softc *sc, struct sysctl_oid *so,
 #endif
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->sc_dev),
 	    SYSCTL_CHILDREN(so), idx, sysctl_name,
-	    CTLTYPE_INT | CTLFLAG_RD, sc, (uintptr_t)sensor,
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, (uintptr_t)sensor,
 	    sc->sc_ggrp_method ? aibs_sysctl_ggrp : aibs_sysctl,
 	    sensor->t == AIBS_SENS_TYPE_TEMP ? "IK" : "I", descr);
 }
@@ -319,7 +319,8 @@ aibs_attach_ggrp(struct aibs_softc *sc)
 			/* sysctl subtree for sensors of this type */
 			*so = SYSCTL_ADD_NODE(device_get_sysctl_ctx(sc->sc_dev),
 			    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->sc_dev)),
-			    sensor->t, name, CTLFLAG_RD, NULL, NULL);
+			    sensor->t, name, CTLFLAG_RD | CTLFLAG_MPSAFE,
+			    NULL, NULL);
 		}
 		aibs_sensor_added(sc, *so, name, *s_idx, sensor, descr);
 		*s_idx += 1;
@@ -415,7 +416,7 @@ aibs_attach_sif(struct aibs_softc *sc, int st)
 	/* sysctl subtree for sensors of this type */
 	*so = SYSCTL_ADD_NODE(device_get_sysctl_ctx(sc->sc_dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->sc_dev)), st,
-	    node, CTLFLAG_RD, NULL, NULL);
+	    node, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, NULL);
 
 	for (i = 0, o++; i < n; i++, o++) {
 		const char	*descr;
diff --git a/sys/dev/acpica/acpi.c b/sys/dev/acpica/acpi.c
index 1e3d9b7c13ad..686b41b9b3f7 100644
--- a/sys/dev/acpica/acpi.c
+++ b/sys/dev/acpica/acpi.c
@@ -251,7 +251,8 @@ static struct rman acpi_rman_io, acpi_rman_mem;
 /* Holds the description of the acpi0 device. */
 static char acpi_desc[ACPI_OEM_ID_SIZE + ACPI_OEM_TABLE_ID_SIZE + 2];
 
-SYSCTL_NODE(_debug, OID_AUTO, acpi, CTLFLAG_RD, NULL, "ACPI debugging");
+SYSCTL_NODE(_debug, OID_AUTO, acpi, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+    "ACPI debugging");
 static char acpi_ca_version[12];
 SYSCTL_STRING(_debug_acpi, OID_AUTO, acpi_ca_version, CTLFLAG_RD,
 	      acpi_ca_version, 0, "Version of Intel ACPI-CA");
@@ -270,7 +271,8 @@ TUNABLE_STR("hw.acpi.remove_interface", acpi_remove_interface,
 static int acpi_debug_objects;
 TUNABLE_INT("debug.acpi.enable_debug_objects", &acpi_debug_objects);
 SYSCTL_PROC(_debug_acpi, OID_AUTO, enable_debug_objects,
-    CTLFLAG_RW | CTLTYPE_INT, NULL, 0, acpi_debug_objects_sysctl, "I",
+    CTLFLAG_RW | CTLTYPE_INT | CTLFLAG_NEEDGIANT, NULL, 0,
+    acpi_debug_objects_sysctl, "I",
     "Enable Debug objects");
 
 /* Allow the interpreter to ignore common mistakes in BIOS. */
@@ -551,29 +553,35 @@ acpi_attach(device_t dev)
      */
     sysctl_ctx_init(&sc->acpi_sysctl_ctx);
     sc->acpi_sysctl_tree = SYSCTL_ADD_NODE(&sc->acpi_sysctl_ctx,
-			       SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
-			       device_get_name(dev), CTLFLAG_RD, 0, "");
+        SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO, device_get_name(dev),
+	CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
     SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
-	OID_AUTO, "supported_sleep_state", CTLTYPE_STRING | CTLFLAG_RD,
+	OID_AUTO, "supported_sleep_state",
+	CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	0, 0, acpi_supported_sleep_state_sysctl, "A",
 	"List supported ACPI sleep states.");
     SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
-	OID_AUTO, "power_button_state", CTLTYPE_STRING | CTLFLAG_RW,
+	OID_AUTO, "power_button_state",
+	CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	&sc->acpi_power_button_sx, 0, acpi_sleep_state_sysctl, "A",
 	"Power button ACPI sleep state.");
     SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
-	OID_AUTO, "sleep_button_state", CTLTYPE_STRING | CTLFLAG_RW,
+	OID_AUTO, "sleep_button_state",
+	CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	&sc->acpi_sleep_button_sx, 0, acpi_sleep_state_sysctl, "A",
 	"Sleep button ACPI sleep state.");
     SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
-	OID_AUTO, "lid_switch_state", CTLTYPE_STRING | CTLFLAG_RW,
+	OID_AUTO, "lid_switch_state",
+	CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	&sc->acpi_lid_switch_sx, 0, acpi_sleep_state_sysctl, "A",
 	"Lid ACPI sleep state. Set to S3 if you want to suspend your laptop when close the Lid.");
     SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
-	OID_AUTO, "standby_state", CTLTYPE_STRING | CTLFLAG_RW,
+	OID_AUTO, "standby_state",
+	CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	&sc->acpi_standby_sx, 0, acpi_sleep_state_sysctl, "A", "");
     SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
-	OID_AUTO, "suspend_state", CTLTYPE_STRING | CTLFLAG_RW,
+	OID_AUTO, "suspend_state",
+	CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	&sc->acpi_suspend_sx, 0, acpi_sleep_state_sysctl, "A", "");
     SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
 	OID_AUTO, "sleep_delay", CTLFLAG_RW, &sc->acpi_sleep_delay, 0,
@@ -3353,7 +3361,7 @@ acpi_wake_sysctl_walk(device_t dev)
 	if (ACPI_SUCCESS(status)) {
 	    SYSCTL_ADD_PROC(device_get_sysctl_ctx(child),
 		SYSCTL_CHILDREN(device_get_sysctl_tree(child)), OID_AUTO,
-		"wake", CTLTYPE_INT | CTLFLAG_RW, child, 0,
+		"wake", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, child, 0,
 		acpi_wake_set_sysctl, "I", "Device set to wake the system");
 	}
     }
@@ -4126,10 +4134,14 @@ acpi_debug_sysctl(SYSCTL_HANDLER_ARGS)
     return (error);
 }
 
-SYSCTL_PROC(_debug_acpi, OID_AUTO, layer, CTLFLAG_RW | CTLTYPE_STRING,
-	    "debug.acpi.layer", 0, acpi_debug_sysctl, "A", "");
-SYSCTL_PROC(_debug_acpi, OID_AUTO, level, CTLFLAG_RW | CTLTYPE_STRING,
-	    "debug.acpi.level", 0, acpi_debug_sysctl, "A", "");
+SYSCTL_PROC(_debug_acpi, OID_AUTO, layer,
+    CTLFLAG_RW | CTLTYPE_STRING | CTLFLAG_NEEDGIANT, "debug.acpi.layer", 0,
+    acpi_debug_sysctl, "A",
+    "");
+SYSCTL_PROC(_debug_acpi, OID_AUTO, level,
+    CTLFLAG_RW | CTLTYPE_STRING | CTLFLAG_NEEDGIANT, "debug.acpi.level", 0,
+    acpi_debug_sysctl, "A",
+    "");
 #endif /* ACPI_DEBUG */
 
 static int
diff --git a/sys/dev/acpica/acpi_acad.c b/sys/dev/acpica/acpi_acad.c
index 18a36013809f..52cfcc50d9aa 100644
--- a/sys/dev/acpica/acpi_acad.c
+++ b/sys/dev/acpica/acpi_acad.c
@@ -170,9 +170,9 @@ acpi_acad_attach(device_t dev)
     if (device_get_unit(dev) == 0) {
 	acpi_sc = acpi_device_get_parent_softc(dev);
 	SYSCTL_ADD_PROC(&acpi_sc->acpi_sysctl_ctx,
-			SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
-			OID_AUTO, "acline", CTLTYPE_INT | CTLFLAG_RD,
-			&sc->status, 0, acpi_acad_sysctl, "I", "");
+	    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO, "acline",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &sc->status, 0,
+	    acpi_acad_sysctl, "I", "");
     }
 
     /* Get initial status after whole system is up. */
diff --git a/sys/dev/acpica/acpi_battery.c b/sys/dev/acpica/acpi_battery.c
index eaf7dd0bf3e4..ea4a5e3baeee 100644
--- a/sys/dev/acpica/acpi_battery.c
+++ b/sys/dev/acpica/acpi_battery.c
@@ -490,31 +490,31 @@ acpi_battery_init(void)
 
     sysctl_ctx_init(&acpi_battery_sysctl_ctx);
     acpi_battery_sysctl_tree = SYSCTL_ADD_NODE(&acpi_battery_sysctl_ctx,
-	SYSCTL_CHILDREN(sc->acpi_sysctl_tree), OID_AUTO, "battery", CTLFLAG_RD,
-	0, "battery status and info");
+	SYSCTL_CHILDREN(sc->acpi_sysctl_tree), OID_AUTO, "battery",
+	CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "battery status and info");
     SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx,
 	SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
-	OID_AUTO, "life", CTLTYPE_INT | CTLFLAG_RD,
+	OID_AUTO, "life", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	&acpi_battery_battinfo.cap, 0, acpi_battery_sysctl, "I",
 	"percent capacity remaining");
     SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx,
 	SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
-	OID_AUTO, "time", CTLTYPE_INT | CTLFLAG_RD,
+	OID_AUTO, "time", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	&acpi_battery_battinfo.min, 0, acpi_battery_sysctl, "I",
 	"remaining time in minutes");
     SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx,
 	SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
-	OID_AUTO, "rate", CTLTYPE_INT | CTLFLAG_RD,
+	OID_AUTO, "rate", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	&acpi_battery_battinfo.rate, 0, acpi_battery_sysctl, "I",
 	"present rate in mW");
     SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx,
 	SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
-	OID_AUTO, "state", CTLTYPE_INT | CTLFLAG_RD,
+	OID_AUTO, "state", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	&acpi_battery_battinfo.state, 0, acpi_battery_sysctl, "I",
 	"current status flags");
     SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx,
 	SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
-	OID_AUTO, "units", CTLTYPE_INT | CTLFLAG_RD,
+	OID_AUTO, "units", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	NULL, 0, acpi_battery_units_sysctl, "I", "number of batteries");
     SYSCTL_ADD_INT(&acpi_battery_sysctl_ctx,
 	SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
diff --git a/sys/dev/acpica/acpi_cpu.c b/sys/dev/acpica/acpi_cpu.c
index 46972630d585..e5d02cca974a 100644
--- a/sys/dev/acpica/acpi_cpu.c
+++ b/sys/dev/acpica/acpi_cpu.c
@@ -391,7 +391,7 @@ acpi_cpu_attach(device_t dev)
 	sysctl_ctx_init(&cpu_sysctl_ctx);
 	cpu_sysctl_tree = SYSCTL_ADD_NODE(&cpu_sysctl_ctx,
 	    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO, "cpu",
-	    CTLFLAG_RD, 0, "node for CPU children");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "node for CPU children");
     }
 
     /*
@@ -1023,7 +1023,7 @@ acpi_cpu_startup(void *arg)
 
     /* Add a sysctl handler to handle global Cx lowest setting */
     SYSCTL_ADD_PROC(&cpu_sysctl_ctx, SYSCTL_CHILDREN(cpu_sysctl_tree),
-	OID_AUTO, "cx_lowest", CTLTYPE_STRING | CTLFLAG_RW,
+	OID_AUTO, "cx_lowest", CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	NULL, 0, acpi_cpu_global_cx_lowest_sysctl, "A",
 	"Global lowest Cx sleep state to use");
 
@@ -1067,26 +1067,25 @@ acpi_cpu_startup_cx(struct acpi_cpu_softc *sc)
 		      sc->cpu_cx_supported, 0,
 		      "Cx/microsecond values for supported Cx states");
     SYSCTL_ADD_PROC(&sc->cpu_sysctl_ctx,
-		    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)),
-		    OID_AUTO, "cx_lowest", CTLTYPE_STRING | CTLFLAG_RW,
-		    (void *)sc, 0, acpi_cpu_cx_lowest_sysctl, "A",
-		    "lowest Cx sleep state to use");
+        SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)), OID_AUTO,
+	"cx_lowest", CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	(void *)sc, 0, acpi_cpu_cx_lowest_sysctl, "A",
+	"lowest Cx sleep state to use");
     SYSCTL_ADD_PROC(&sc->cpu_sysctl_ctx,
-		    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)),
-		    OID_AUTO, "cx_usage", CTLTYPE_STRING | CTLFLAG_RD,
-		    (void *)sc, 0, acpi_cpu_usage_sysctl, "A",
-		    "percent usage for each Cx state");
+        SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)), OID_AUTO,
+	"cx_usage", CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	(void *)sc, 0, acpi_cpu_usage_sysctl, "A",
+	"percent usage for each Cx state");
     SYSCTL_ADD_PROC(&sc->cpu_sysctl_ctx,
-		    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)),
-		    OID_AUTO, "cx_usage_counters", CTLTYPE_STRING | CTLFLAG_RD,
-		    (void *)sc, 0, acpi_cpu_usage_counters_sysctl, "A",
-		    "Cx sleep state counters");
+        SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)), OID_AUTO,
+	"cx_usage_counters", CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	(void *)sc, 0, acpi_cpu_usage_counters_sysctl, "A",
+	"Cx sleep state counters");
 #if defined(__i386__) || defined(__amd64__)
     SYSCTL_ADD_PROC(&sc->cpu_sysctl_ctx,
-		    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)),
-		    OID_AUTO, "cx_method", CTLTYPE_STRING | CTLFLAG_RD,
-		    (void *)sc, 0, acpi_cpu_method_sysctl, "A",
-		    "Cx entrance methods");
+        SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)), OID_AUTO,
+	"cx_method", CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	(void *)sc, 0, acpi_cpu_method_sysctl, "A", "Cx entrance methods");
 #endif
 
     /* Signal platform that we can handle _CST notification. */
diff --git a/sys/dev/acpica/acpi_dock.c b/sys/dev/acpica/acpi_dock.c
index 00b2e9fc375f..e566a86307b0 100644
--- a/sys/dev/acpica/acpi_dock.c
+++ b/sys/dev/acpica/acpi_dock.c
@@ -515,7 +515,7 @@ acpi_dock_attach(device_t dev)
 	SYSCTL_ADD_PROC(sc->sysctl_ctx,
 		SYSCTL_CHILDREN(sc->sysctl_tree),
 		OID_AUTO, "status",
-		CTLTYPE_INT|CTLFLAG_RW, dev, 0,
+		CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, dev, 0,
 		acpi_dock_status_sysctl, "I",
 		"Dock/Undock operation");
 
diff --git a/sys/dev/acpica/acpi_ec.c b/sys/dev/acpica/acpi_ec.c
index 2457a5ab68c9..d6211d5881f2 100644
--- a/sys/dev/acpica/acpi_ec.c
+++ b/sys/dev/acpica/acpi_ec.c
@@ -179,7 +179,9 @@ struct acpi_ec_softc {
 
 ACPI_SERIAL_DECL(ec, "ACPI embedded controller");
 
-static SYSCTL_NODE(_debug_acpi, OID_AUTO, ec, CTLFLAG_RD, NULL, "EC debugging");
+static SYSCTL_NODE(_debug_acpi, OID_AUTO, ec,
+    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+    "EC debugging");
 
 static int	ec_burst_mode;
 SYSCTL_INT(_debug_acpi_ec, OID_AUTO, burst, CTLFLAG_RWTUN, &ec_burst_mode, 0,
diff --git a/sys/dev/acpica/acpi_smbat.c b/sys/dev/acpica/acpi_smbat.c
index 28efb9015da5..65995ac77eec 100644
--- a/sys/dev/acpica/acpi_smbat.c
+++ b/sys/dev/acpica/acpi_smbat.c
@@ -62,7 +62,8 @@ static int	acpi_smbat_get_bst(device_t dev, struct acpi_bst *bst);
 
 ACPI_SERIAL_DECL(smbat, "ACPI Smart Battery");
 
-static SYSCTL_NODE(_debug_acpi, OID_AUTO, batt, CTLFLAG_RD, NULL,
+static SYSCTL_NODE(_debug_acpi, OID_AUTO, batt,
+    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
     "Battery debugging");
 
 /* On some laptops with smart batteries, enabling battery monitoring
diff --git a/sys/dev/acpica/acpi_thermal.c b/sys/dev/acpica/acpi_thermal.c
index fa731deef42d..73b2de51b382 100644
--- a/sys/dev/acpica/acpi_thermal.c
+++ b/sys/dev/acpica/acpi_thermal.c
@@ -241,8 +241,8 @@ acpi_tz_attach(device_t dev)
 	acpi_sc = acpi_device_get_parent_softc(dev);
 	sysctl_ctx_init(&acpi_tz_sysctl_ctx);
 	acpi_tz_sysctl_tree = SYSCTL_ADD_NODE(&acpi_tz_sysctl_ctx,
-			      SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
-			      OID_AUTO, "thermal", CTLFLAG_RD, 0, "");
+	    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO, "thermal",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
 	SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx,
 		       SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
 		       OID_AUTO, "min_runtime", CTLFLAG_RW,
@@ -260,56 +260,52 @@ acpi_tz_attach(device_t dev)
     sysctl_ctx_init(&sc->tz_sysctl_ctx);
     sprintf(oidname, "tz%d", device_get_unit(dev));
     sc->tz_sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&sc->tz_sysctl_ctx,
-			 SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
-			 OID_AUTO, oidname, CTLFLAG_RD, 0, "", "thermal_zone");
+        SYSCTL_CHILDREN(acpi_tz_sysctl_tree), OID_AUTO, oidname,
+	CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "", "thermal_zone");
     SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
-		    OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD,
-		    &sc->tz_temperature, 0, sysctl_handle_int,
-		    "IK", "current thermal zone temperature");
+        OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	&sc->tz_temperature, 0, sysctl_handle_int, "IK",
+	"current thermal zone temperature");
     SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
-		    OID_AUTO, "active", CTLTYPE_INT | CTLFLAG_RW,
-		    sc, 0, acpi_tz_active_sysctl, "I", "cooling is active");
+        OID_AUTO, "active", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc,
+	0, acpi_tz_active_sysctl, "I", "cooling is active");
     SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
-		    OID_AUTO, "passive_cooling", CTLTYPE_INT | CTLFLAG_RW,
-		    sc, 0, acpi_tz_cooling_sysctl, "I",
-		    "enable passive (speed reduction) cooling");
+        OID_AUTO, "passive_cooling",
+	CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	acpi_tz_cooling_sysctl, "I",
+	"enable passive (speed reduction) cooling");
 
     SYSCTL_ADD_INT(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
 		   OID_AUTO, "thermal_flags", CTLFLAG_RD,
 		   &sc->tz_thflags, 0, "thermal zone flags");
     SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
-		    OID_AUTO, "_PSV", CTLTYPE_INT | CTLFLAG_RW,
-		    sc, offsetof(struct acpi_tz_softc, tz_zone.psv),
-		    acpi_tz_temp_sysctl, "IK", "passive cooling temp setpoint");
+        OID_AUTO, "_PSV", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc,
+	offsetof(struct acpi_tz_softc, tz_zone.psv), acpi_tz_temp_sysctl, "IK",
+	"passive cooling temp setpoint");
     SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
-		    OID_AUTO, "_HOT", CTLTYPE_INT | CTLFLAG_RW,
-		    sc, offsetof(struct acpi_tz_softc, tz_zone.hot),
-		    acpi_tz_temp_sysctl, "IK",
-		    "too hot temp setpoint (suspend now)");
+        OID_AUTO, "_HOT", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc,
+	offsetof(struct acpi_tz_softc, tz_zone.hot), acpi_tz_temp_sysctl, "IK",
+	"too hot temp setpoint (suspend now)");
     SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
-		    OID_AUTO, "_CRT", CTLTYPE_INT | CTLFLAG_RW,
-		    sc, offsetof(struct acpi_tz_softc, tz_zone.crt),
-		    acpi_tz_temp_sysctl, "IK",
-		    "critical temp setpoint (shutdown now)");
+        OID_AUTO, "_CRT", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc,
+	offsetof(struct acpi_tz_softc, tz_zone.crt), acpi_tz_temp_sysctl, "IK",
+	"critical temp setpoint (shutdown now)");
     SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
-		    OID_AUTO, "_ACx", CTLTYPE_INT | CTLFLAG_RD,
-		    &sc->tz_zone.ac, sizeof(sc->tz_zone.ac),
-		    sysctl_handle_opaque, "IK", "");
+        OID_AUTO, "_ACx", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	&sc->tz_zone.ac, sizeof(sc->tz_zone.ac), sysctl_handle_opaque, "IK",
+	"");
     SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
-		    OID_AUTO, "_TC1", CTLTYPE_INT | CTLFLAG_RW,
-		    sc, offsetof(struct acpi_tz_softc, tz_zone.tc1),
-		    acpi_tz_passive_sysctl, "I",
-		    "thermal constant 1 for passive cooling");
+        OID_AUTO, "_TC1", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc,
+	offsetof(struct acpi_tz_softc, tz_zone.tc1), acpi_tz_passive_sysctl,
+	"I", "thermal constant 1 for passive cooling");
     SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
-		    OID_AUTO, "_TC2", CTLTYPE_INT | CTLFLAG_RW,
-		    sc, offsetof(struct acpi_tz_softc, tz_zone.tc2),
-		    acpi_tz_passive_sysctl, "I",
-		    "thermal constant 2 for passive cooling");
+        OID_AUTO, "_TC2", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc,
+	offsetof(struct acpi_tz_softc, tz_zone.tc2), acpi_tz_passive_sysctl,
+	"I", "thermal constant 2 for passive cooling");
     SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
-		    OID_AUTO, "_TSP", CTLTYPE_INT | CTLFLAG_RW,
-		    sc, offsetof(struct acpi_tz_softc, tz_zone.tsp),
-		    acpi_tz_passive_sysctl, "I",
-		    "thermal sampling period for passive cooling");
+        OID_AUTO, "_TSP", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc,
+	offsetof(struct acpi_tz_softc, tz_zone.tsp), acpi_tz_passive_sysctl,
+	"I", "thermal sampling period for passive cooling");
 
     /*
      * Register our power profile event handler.
diff --git a/sys/dev/acpica/acpi_timer.c b/sys/dev/acpica/acpi_timer.c
index 34a832089a23..20ad87840c7a 100644
--- a/sys/dev/acpica/acpi_timer.c
+++ b/sys/dev/acpica/acpi_timer.c
@@ -368,8 +368,10 @@ acpi_timer_sysctl_freq(SYSCTL_HANDLER_ARGS)
     return (error);
 }
  
-SYSCTL_PROC(_machdep, OID_AUTO, acpi_timer_freq, CTLTYPE_INT | CTLFLAG_RW,
-    0, sizeof(u_int), acpi_timer_sysctl_freq, "I", "ACPI timer frequency");
+SYSCTL_PROC(_machdep, OID_AUTO, acpi_timer_freq,
+    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 0, sizeof(u_int),
+    acpi_timer_sysctl_freq, "I",
+    "ACPI timer frequency");
 
 /*
  * Some ACPI timers are known or believed to suffer from implementation
diff --git a/sys/dev/acpica/acpi_video.c b/sys/dev/acpica/acpi_video.c
index ad3ac4eba751..f3b28e9c48a6 100644
--- a/sys/dev/acpica/acpi_video.c
+++ b/sys/dev/acpica/acpi_video.c
@@ -254,9 +254,9 @@ acpi_video_attach(device_t dev)
 	ACPI_SERIAL_BEGIN(video);
 	if (acpi_video_sysctl_tree == NULL) {
 		acpi_video_sysctl_tree = SYSCTL_ADD_NODE(&acpi_video_sysctl_ctx,
-				    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
-				    OID_AUTO, "video", CTLFLAG_RD, 0,
-				    "video extension control");
+		    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO,
+		    "video", CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+		    "video extension control");
 	}
 	ACPI_SERIAL_END(video);
 
@@ -539,39 +539,40 @@ acpi_video_vo_init(UINT32 adr)
 			vo->vo_sysctl_tree =
 			    SYSCTL_ADD_NODE(&vo->vo_sysctl_ctx,
 				SYSCTL_CHILDREN(acpi_video_sysctl_tree),
-				OID_AUTO, name, CTLFLAG_RD, 0, desc);
+				OID_AUTO, name, CTLFLAG_RD | CTLFLAG_MPSAFE,
+				0, desc);
 		if (vo->vo_sysctl_tree != NULL) {
 			SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
 			    SYSCTL_CHILDREN(vo->vo_sysctl_tree),
 			    OID_AUTO, "active",
-			    CTLTYPE_INT|CTLFLAG_RW, vo, 0,
-			    acpi_video_vo_active_sysctl, "I",
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vo,
+			    0, acpi_video_vo_active_sysctl, "I",
 			    "current activity of this device");
 			SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
 			    SYSCTL_CHILDREN(vo->vo_sysctl_tree),
 			    OID_AUTO, "brightness",
-			    CTLTYPE_INT|CTLFLAG_RW, vo, 0,
-			    acpi_video_vo_bright_sysctl, "I",
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vo,
+			    0, acpi_video_vo_bright_sysctl, "I",
 			    "current brightness level");
 			SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
 			    SYSCTL_CHILDREN(vo->vo_sysctl_tree),
 			    OID_AUTO, "fullpower",
-			    CTLTYPE_INT|CTLFLAG_RW, vo,
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vo,
 			    POWER_PROFILE_PERFORMANCE,
 			    acpi_video_vo_presets_sysctl, "I",
 			    "preset level for full power mode");
 			SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
 			    SYSCTL_CHILDREN(vo->vo_sysctl_tree),
 			    OID_AUTO, "economy",
-			    CTLTYPE_INT|CTLFLAG_RW, vo,
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vo,
 			    POWER_PROFILE_ECONOMY,
 			    acpi_video_vo_presets_sysctl, "I",
 			    "preset level for economy mode");
 			SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
 			    SYSCTL_CHILDREN(vo->vo_sysctl_tree),
 			    OID_AUTO, "levels",
-			    CTLTYPE_INT | CTLFLAG_RD, vo, 0,
-			    acpi_video_vo_levels_sysctl, "I",
+			    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, vo,
+			    0, acpi_video_vo_levels_sysctl, "I",
 			    "supported brightness levels");
 		} else
 			printf("%s: sysctl node creation failed\n", type);
diff --git a/sys/dev/adb/adb_kbd.c b/sys/dev/adb/adb_kbd.c
index 82003692804d..e2dba622ecd8 100644
--- a/sys/dev/adb/adb_kbd.c
+++ b/sys/dev/adb/adb_kbd.c
@@ -370,7 +370,8 @@ adb_kbd_attach(device_t dev)
 		tree = device_get_sysctl_tree(dev);
 
 		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-		    "fn_keys_function_as_primary", CTLTYPE_INT | CTLFLAG_RW, sc,
+		    "fn_keys_function_as_primary",
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc,
 		    0, adb_fn_keys, "I",
 		    "Set the Fn keys to be their F-key type as default");
 	}
diff --git a/sys/dev/adb/adb_mouse.c b/sys/dev/adb/adb_mouse.c
index 8f0ccca3b3bd..2dfdd6e381d1 100644
--- a/sys/dev/adb/adb_mouse.c
+++ b/sys/dev/adb/adb_mouse.c
@@ -330,8 +330,8 @@ adb_init_trackpad(device_t dev)
 	ctx = device_get_sysctl_ctx(dev);
 	tree = device_get_sysctl_tree(dev);
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "tapping",
-			CTLTYPE_INT | CTLFLAG_RW, sc, 0, adb_tapping_sysctl,
-			"I", "Tapping the pad causes button events");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    adb_tapping_sysctl, "I", "Tapping the pad causes button events");
 	return;
 }
 
diff --git a/sys/dev/ae/if_ae.c b/sys/dev/ae/if_ae.c
index 557b3a67752b..7d486abbea44 100644
--- a/sys/dev/ae/if_ae.c
+++ b/sys/dev/ae/if_ae.c
@@ -419,13 +419,13 @@ ae_init_tunables(ae_softc_t *sc)
 	ctx = device_get_sysctl_ctx(sc->dev);
 	root = device_get_sysctl_tree(sc->dev);
 	stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(root), OID_AUTO, "stats",
-	    CTLFLAG_RD, NULL, "ae statistics");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "ae statistics");
 
 	/*
 	 * Receiver statistcics.
 	 */
 	stats_rx = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, "rx",
-	    CTLFLAG_RD, NULL, "Rx MAC statistics");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Rx MAC statistics");
 	AE_SYSCTL(ctx, SYSCTL_CHILDREN(stats_rx), "bcast",
 	    "broadcast frames", &ae_stats->rx_bcast);
 	AE_SYSCTL(ctx, SYSCTL_CHILDREN(stats_rx), "mcast",
@@ -451,7 +451,7 @@ ae_init_tunables(ae_softc_t *sc)
 	 * Receiver statistcics.
 	 */
 	stats_tx = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, "tx",
-	    CTLFLAG_RD, NULL, "Tx MAC statistics");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Tx MAC statistics");
 	AE_SYSCTL(ctx, SYSCTL_CHILDREN(stats_tx), "bcast",
 	    "broadcast frames", &ae_stats->tx_bcast);
 	AE_SYSCTL(ctx, SYSCTL_CHILDREN(stats_tx), "mcast",
diff --git a/sys/dev/age/if_age.c b/sys/dev/age/if_age.c
index b6fac97b50a8..5280bd36746c 100644
--- a/sys/dev/age/if_age.c
+++ b/sys/dev/age/if_age.c
@@ -749,13 +749,14 @@ age_sysctl_node(struct age_softc *sc)
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->age_dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->age_dev)), OID_AUTO,
-	    "stats", CTLTYPE_INT | CTLFLAG_RW, sc, 0, sysctl_age_stats,
-	    "I", "Statistics");
+	    "stats", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    sc, 0, sysctl_age_stats, "I", "Statistics");
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->age_dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->age_dev)), OID_AUTO,
-	    "int_mod", CTLTYPE_INT | CTLFLAG_RW, &sc->age_int_mod, 0,
-	    sysctl_hw_age_int_mod, "I", "age interrupt moderation");
+	    "int_mod", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    &sc->age_int_mod, 0, sysctl_hw_age_int_mod, "I",
+	    "age interrupt moderation");
 
 	/* Pull in device tunables. */
 	sc->age_int_mod = AGE_IM_TIMER_DEFAULT;
@@ -773,8 +774,8 @@ age_sysctl_node(struct age_softc *sc)
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->age_dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->age_dev)), OID_AUTO,
-	    "process_limit", CTLTYPE_INT | CTLFLAG_RW, &sc->age_process_limit,
-	    0, sysctl_hw_age_proc_limit, "I",
+	    "process_limit", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    &sc->age_process_limit, 0, sysctl_hw_age_proc_limit, "I",
 	    "max number of Rx events to process");
 
 	/* Pull in device tunables. */
diff --git a/sys/dev/ahci/ahci.c b/sys/dev/ahci/ahci.c
index 47ee81c6f81c..8ad76d5ea963 100644
--- a/sys/dev/ahci/ahci.c
+++ b/sys/dev/ahci/ahci.c
@@ -904,8 +904,8 @@ ahci_ch_attach(device_t dev)
 	ctx = device_get_sysctl_ctx(dev);
 	tree = device_get_sysctl_tree(dev);
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "disable_phy",
-	    CTLFLAG_RW | CTLTYPE_UINT, ch, 0, ahci_ch_disablephy_proc, "IU",
-	    "Disable PHY");
+	    CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT, ch,
+	    0, ahci_ch_disablephy_proc, "IU", "Disable PHY");
 	return (0);
 
 err3:
diff --git a/sys/dev/aic7xxx/aic79xx_osm.c b/sys/dev/aic7xxx/aic79xx_osm.c
index 47ddeb691821..015de114a98d 100644
--- a/sys/dev/aic7xxx/aic79xx_osm.c
+++ b/sys/dev/aic7xxx/aic79xx_osm.c
@@ -159,22 +159,22 @@ ahd_sysctl(struct ahd_softc *ahd)
 
 	ahd->sysctl_tree[AHD_SYSCTL_ROOT] =
 	    SYSCTL_ADD_NODE(&ahd->sysctl_ctx[AHD_SYSCTL_ROOT],
-			    SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
-			    device_get_nameunit(ahd->dev_softc), CTLFLAG_RD, 0,
-			    ahd_sysctl_node_descriptions[AHD_SYSCTL_ROOT]);
+	        SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
+		device_get_nameunit(ahd->dev_softc),
+		CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+		ahd_sysctl_node_descriptions[AHD_SYSCTL_ROOT]);
 	    SYSCTL_ADD_PROC(&ahd->sysctl_ctx[AHD_SYSCTL_ROOT],
-			    SYSCTL_CHILDREN(ahd->sysctl_tree[AHD_SYSCTL_ROOT]),
-			    OID_AUTO, "clear", CTLTYPE_UINT | CTLFLAG_RW, ahd,
-			    0, ahd_clear_allcounters, "IU",
-			    "Clear all counters");
+	        SYSCTL_CHILDREN(ahd->sysctl_tree[AHD_SYSCTL_ROOT]), OID_AUTO,
+		"clear", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, ahd,
+		0, ahd_clear_allcounters, "IU", "Clear all counters");
 
 	for (i = AHD_SYSCTL_SUMMARY; i < AHD_SYSCTL_NUMBER; i++)
 		ahd->sysctl_tree[i] =
 		    SYSCTL_ADD_NODE(&ahd->sysctl_ctx[i],
-				    SYSCTL_CHILDREN(ahd->sysctl_tree[AHD_SYSCTL_ROOT]),
-				    OID_AUTO, ahd_sysctl_node_elements[i],
-				    CTLFLAG_RD, 0,
-				    ahd_sysctl_node_descriptions[i]);
+		        SYSCTL_CHILDREN(ahd->sysctl_tree[AHD_SYSCTL_ROOT]),
+			OID_AUTO, ahd_sysctl_node_elements[i],
+			CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+			ahd_sysctl_node_descriptions[i]);
 
 	for (i = AHD_ERRORS_CORRECTABLE; i < AHD_ERRORS_NUMBER; i++) {
 		SYSCTL_ADD_UINT(&ahd->sysctl_ctx[AHD_SYSCTL_SUMMARY],
@@ -183,11 +183,11 @@ ahd_sysctl(struct ahd_softc *ahd)
 				CTLFLAG_RD, &ahd->summerr[i], i,
 				ahd_sysctl_errors_descriptions[i]);
 		SYSCTL_ADD_PROC(&ahd->sysctl_ctx[AHD_SYSCTL_DEBUG],
-				SYSCTL_CHILDREN(ahd->sysctl_tree[AHD_SYSCTL_DEBUG]),
-				OID_AUTO, ahd_sysctl_errors_elements[i],
-				CTLFLAG_RW | CTLTYPE_UINT, ahd, i,
-				ahd_set_debugcounters, "IU",
-				ahd_sysctl_errors_descriptions[i]);
+		    SYSCTL_CHILDREN(ahd->sysctl_tree[AHD_SYSCTL_DEBUG]),
+		    OID_AUTO, ahd_sysctl_errors_elements[i],
+		    CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT, ahd, i,
+		    ahd_set_debugcounters, "IU",
+		    ahd_sysctl_errors_descriptions[i]);
 	}
 }
 
diff --git a/sys/dev/alc/if_alc.c b/sys/dev/alc/if_alc.c
index 531c9f18fc8f..255fea53acfa 100644
--- a/sys/dev/alc/if_alc.c
+++ b/sys/dev/alc/if_alc.c
@@ -1747,11 +1747,11 @@ alc_sysctl_node(struct alc_softc *sc)
 	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->alc_dev));
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_rx_mod",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->alc_int_rx_mod, 0,
-	    sysctl_hw_alc_int_mod, "I", "alc Rx interrupt moderation");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->alc_int_rx_mod,
+	    0, sysctl_hw_alc_int_mod, "I", "alc Rx interrupt moderation");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_tx_mod",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->alc_int_tx_mod, 0,
-	    sysctl_hw_alc_int_mod, "I", "alc Tx interrupt moderation");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->alc_int_tx_mod,
+	    0, sysctl_hw_alc_int_mod, "I", "alc Tx interrupt moderation");
 	/* Pull in device tunables. */
 	sc->alc_int_rx_mod = ALC_IM_RX_TIMER_DEFAULT;
 	error = resource_int_value(device_get_name(sc->alc_dev),
@@ -1778,8 +1778,8 @@ alc_sysctl_node(struct alc_softc *sc)
 		}
 	}
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "process_limit",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->alc_process_limit, 0,
-	    sysctl_hw_alc_proc_limit, "I",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    &sc->alc_process_limit, 0, sysctl_hw_alc_proc_limit, "I",
 	    "max number of Rx events to process");
 	/* Pull in device tunables. */
 	sc->alc_process_limit = ALC_PROC_DEFAULT;
@@ -1796,13 +1796,13 @@ alc_sysctl_node(struct alc_softc *sc)
 		}
 	}
 
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "ALC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "ALC statistics");
 	parent = SYSCTL_CHILDREN(tree);
 
 	/* Rx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "Rx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Rx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	ALC_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
 	    &stats->rx_frames, "Good frames");
@@ -1855,8 +1855,8 @@ alc_sysctl_node(struct alc_softc *sc)
 	    "Frames dropped due to address filtering");
 
 	/* Tx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "Tx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Tx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	ALC_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
 	    &stats->tx_frames, "Good frames");
diff --git a/sys/dev/ale/if_ale.c b/sys/dev/ale/if_ale.c
index 4a8afd887de6..03580b478fe7 100644
--- a/sys/dev/ale/if_ale.c
+++ b/sys/dev/ale/if_ale.c
@@ -792,11 +792,11 @@ ale_sysctl_node(struct ale_softc *sc)
 	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->ale_dev));
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_rx_mod",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->ale_int_rx_mod, 0,
-	    sysctl_hw_ale_int_mod, "I", "ale Rx interrupt moderation");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->ale_int_rx_mod,
+	    0, sysctl_hw_ale_int_mod, "I", "ale Rx interrupt moderation");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_tx_mod",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->ale_int_tx_mod, 0,
-	    sysctl_hw_ale_int_mod, "I", "ale Tx interrupt moderation");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->ale_int_tx_mod,
+	    0, sysctl_hw_ale_int_mod, "I", "ale Tx interrupt moderation");
 	/* Pull in device tunables. */
 	sc->ale_int_rx_mod = ALE_IM_RX_TIMER_DEFAULT;
 	error = resource_int_value(device_get_name(sc->ale_dev),
@@ -823,8 +823,8 @@ ale_sysctl_node(struct ale_softc *sc)
 		}
 	}
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "process_limit",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->ale_process_limit, 0,
-	    sysctl_hw_ale_proc_limit, "I",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    &sc->ale_process_limit, 0, sysctl_hw_ale_proc_limit, "I",
 	    "max number of Rx events to process");
 	/* Pull in device tunables. */
 	sc->ale_process_limit = ALE_PROC_DEFAULT;
@@ -846,13 +846,13 @@ ale_sysctl_node(struct ale_softc *sc)
 	    &stats->reset_brk_seq,
 	    "Controller resets due to broken Rx sequnce number");
 
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "ATE statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "ATE statistics");
 	parent = SYSCTL_CHILDREN(tree);
 
 	/* Rx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "Rx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Rx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	ALE_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
 	    &stats->rx_frames, "Good frames");
@@ -905,8 +905,8 @@ ale_sysctl_node(struct ale_softc *sc)
 	    "Frames dropped due to address filtering");
 
 	/* Tx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "Tx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Tx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	ALE_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
 	    &stats->tx_frames, "Good frames");
diff --git a/sys/dev/altera/atse/if_atse.c b/sys/dev/altera/atse/if_atse.c
index 2dfd55b94866..9444c749463e 100644
--- a/sys/dev/altera/atse/if_atse.c
+++ b/sys/dev/altera/atse/if_atse.c
@@ -1237,7 +1237,8 @@ atse_sysctl_stats_attach(device_t dev)
 		}
 
 		SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
-		    atse_mac_stats_regs[i].name, CTLTYPE_UINT|CTLFLAG_RD,
+		    atse_mac_stats_regs[i].name,
+		    CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		    sc, i, sysctl_atse_mac_stats_proc, "IU",
 		    atse_mac_stats_regs[i].descr);
 	}
@@ -1250,7 +1251,8 @@ atse_sysctl_stats_attach(device_t dev)
 		}
 
 		SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
-		    atse_rx_err_stats_regs[i].name, CTLTYPE_UINT|CTLFLAG_RD,
+		    atse_rx_err_stats_regs[i].name,
+		    CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		    sc, i, sysctl_atse_rx_err_stats_proc, "IU",
 		    atse_rx_err_stats_regs[i].descr);
 	}
diff --git a/sys/dev/altera/jtag_uart/altera_jtag_uart_cons.c b/sys/dev/altera/jtag_uart/altera_jtag_uart_cons.c
index c0cd3aa5a59f..51e0b2b28699 100644
--- a/sys/dev/altera/jtag_uart/altera_jtag_uart_cons.c
+++ b/sys/dev/altera/jtag_uart/altera_jtag_uart_cons.c
@@ -52,7 +52,8 @@ __FBSDID("$FreeBSD$");
 
 devclass_t	altera_jtag_uart_devclass;
 
-static SYSCTL_NODE(_hw, OID_AUTO, altera_jtag_uart, CTLFLAG_RW, 0,
+static SYSCTL_NODE(_hw, OID_AUTO, altera_jtag_uart,
+    CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
     "Altera JTAG UART configuration knobs");
 
 /*
diff --git a/sys/dev/amd_ecc_inject/ecc_inject.c b/sys/dev/amd_ecc_inject/ecc_inject.c
index 5021b01a8311..79a23bf81bb8 100644
--- a/sys/dev/amd_ecc_inject/ecc_inject.c
+++ b/sys/dev/amd_ecc_inject/ecc_inject.c
@@ -125,24 +125,26 @@ sysctl_proc_inject(SYSCTL_HANDLER_ARGS)
 	return (0);
 }
 
-static SYSCTL_NODE(_hw, OID_AUTO, error_injection, CTLFLAG_RD, NULL,
+static SYSCTL_NODE(_hw, OID_AUTO, error_injection,
+    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
     "Hardware error injection");
-static SYSCTL_NODE(_hw_error_injection, OID_AUTO, dram_ecc, CTLFLAG_RD, NULL,
+static SYSCTL_NODE(_hw_error_injection, OID_AUTO, dram_ecc,
+    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
     "DRAM ECC error injection");
 SYSCTL_UINT(_hw_error_injection_dram_ecc, OID_AUTO, delay,
     CTLTYPE_UINT | CTLFLAG_RW, &delay_ms, 0,
     "Delay in milliseconds between error injections");
 SYSCTL_PROC(_hw_error_injection_dram_ecc, OID_AUTO, quadrant,
-    CTLTYPE_UINT | CTLFLAG_RW, &quadrant, QUADRANT_MASK,
+    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &quadrant, QUADRANT_MASK,
     sysctl_int_with_max, "IU",
     "Index of 16-byte quadrant within 64-byte line where errors "
     "should be injected");
 SYSCTL_PROC(_hw_error_injection_dram_ecc, OID_AUTO, word_mask,
-    CTLTYPE_UINT | CTLFLAG_RW, &word_mask, INJ_WORD_MASK,
+    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &word_mask, INJ_WORD_MASK,
     sysctl_nonzero_int_with_max, "IU",
     "9-bit mask of words where errors should be injected (8 data + 1 ECC)");
 SYSCTL_PROC(_hw_error_injection_dram_ecc, OID_AUTO, bit_mask,
-    CTLTYPE_UINT | CTLFLAG_RW, &bit_mask, INJ_VECTOR_MASK,
+    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &bit_mask, INJ_VECTOR_MASK,
     sysctl_nonzero_int_with_max, "IU",
     "16-bit mask of bits within each selected word where errors "
     "should be injected");
diff --git a/sys/dev/amdtemp/amdtemp.c b/sys/dev/amdtemp/amdtemp.c
index 38be7d9bd1b5..597737c98c8c 100644
--- a/sys/dev/amdtemp/amdtemp.c
+++ b/sys/dev/amdtemp/amdtemp.c
@@ -496,11 +496,12 @@ amdtemp_attach(device_t dev)
 	    "Temperature sensor offset");
 	sysctlnode = SYSCTL_ADD_NODE(sysctlctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "core0", CTLFLAG_RD, 0, "Core 0");
+	    "core0", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "Core 0");
 
 	SYSCTL_ADD_PROC(sysctlctx,
 	    SYSCTL_CHILDREN(sysctlnode),
-	    OID_AUTO, "sensor0", CTLTYPE_INT | CTLFLAG_RD,
+	    OID_AUTO, "sensor0",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    dev, CORE0_SENSOR0, amdtemp_sysctl, "IK",
 	    "Core 0 / Sensor 0 temperature");
 
@@ -509,24 +510,28 @@ amdtemp_attach(device_t dev)
 	else if (sc->sc_ntemps > 1) {
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sysctlnode),
-		    OID_AUTO, "sensor1", CTLTYPE_INT | CTLFLAG_RD,
+		    OID_AUTO, "sensor1",
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		    dev, CORE0_SENSOR1, amdtemp_sysctl, "IK",
 		    "Core 0 / Sensor 1 temperature");
 
 		if (sc->sc_ncores > 1) {
 			sysctlnode = SYSCTL_ADD_NODE(sysctlctx,
 			    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-			    OID_AUTO, "core1", CTLFLAG_RD, 0, "Core 1");
+			    OID_AUTO, "core1", CTLFLAG_RD | CTLFLAG_MPSAFE,
+			    0, "Core 1");
 
 			SYSCTL_ADD_PROC(sysctlctx,
 			    SYSCTL_CHILDREN(sysctlnode),
-			    OID_AUTO, "sensor0", CTLTYPE_INT | CTLFLAG_RD,
+			    OID_AUTO, "sensor0",
+			    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 			    dev, CORE1_SENSOR0, amdtemp_sysctl, "IK",
 			    "Core 1 / Sensor 0 temperature");
 
 			SYSCTL_ADD_PROC(sysctlctx,
 			    SYSCTL_CHILDREN(sysctlnode),
-			    OID_AUTO, "sensor1", CTLTYPE_INT | CTLFLAG_RD,
+			    OID_AUTO, "sensor1",
+			    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 			    dev, CORE1_SENSOR1, amdtemp_sysctl, "IK",
 			    "Core 1 / Sensor 1 temperature");
 		}
@@ -578,7 +583,8 @@ amdtemp_intrhook(void *arg)
 			    (i == 0 ? CORE0 : CORE1) : CORE0_SENSOR0;
 			sc->sc_sysctl_cpu[i] = SYSCTL_ADD_PROC(sysctlctx,
 			    SYSCTL_CHILDREN(device_get_sysctl_tree(cpu)),
-			    OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD,
+			    OID_AUTO, "temperature",
+			    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 			    dev, sensor, amdtemp_sysctl, "IK",
 			    "Current temparature");
 		}
diff --git a/sys/dev/amr/amr.c b/sys/dev/amr/amr.c
index 2e77c3e4befc..11279ba315e4 100644
--- a/sys/dev/amr/amr.c
+++ b/sys/dev/amr/amr.c
@@ -90,7 +90,8 @@ __FBSDID("$FreeBSD$");
 #define AMR_DEFINE_TABLES
 #include <dev/amr/amr_tables.h>
 
-SYSCTL_NODE(_hw, OID_AUTO, amr, CTLFLAG_RD, 0, "AMR driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, amr, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "AMR driver parameters");
 
 static d_open_t         amr_open;
 static d_close_t        amr_close;
diff --git a/sys/dev/an/if_an.c b/sys/dev/an/if_an.c
index 70866f1d002b..9eb9843f444f 100644
--- a/sys/dev/an/if_an.c
+++ b/sys/dev/an/if_an.c
@@ -206,7 +206,7 @@ static char an_conf_cache[256];
 
 /* sysctl vars */
 
-static SYSCTL_NODE(_hw, OID_AUTO, an, CTLFLAG_RD, 0,
+static SYSCTL_NODE(_hw, OID_AUTO, an, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "Wireless driver parameters");
 
 /* XXX violate ethernet/netgraph callback hooks */
@@ -266,8 +266,10 @@ sysctl_an_dump(SYSCTL_HANDLER_ARGS)
 	return error;
 }
 
-SYSCTL_PROC(_hw_an, OID_AUTO, an_dump, CTLTYPE_STRING | CTLFLAG_RW,
-	    0, sizeof(an_conf), sysctl_an_dump, "A", "");
+SYSCTL_PROC(_hw_an, OID_AUTO, an_dump,
+    CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 0, sizeof(an_conf),
+    sysctl_an_dump, "A",
+    "");
 
 static int
 sysctl_an_cache_mode(SYSCTL_HANDLER_ARGS)
@@ -302,8 +304,10 @@ sysctl_an_cache_mode(SYSCTL_HANDLER_ARGS)
 	return error;
 }
 
-SYSCTL_PROC(_hw_an, OID_AUTO, an_cache_mode, CTLTYPE_STRING | CTLFLAG_RW,
-	    0, sizeof(an_conf_cache), sysctl_an_cache_mode, "A", "");
+SYSCTL_PROC(_hw_an, OID_AUTO, an_cache_mode,
+    CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 0, sizeof(an_conf_cache),
+    sysctl_an_cache_mode, "A",
+    "");
 
 /*
  * We probe for an Aironet 4500/4800 card by attempting to
diff --git a/sys/dev/asmc/asmc.c b/sys/dev/asmc/asmc.c
index 0771d7f0732a..bb5154a1ee92 100644
--- a/sys/dev/asmc/asmc.c
+++ b/sys/dev/asmc/asmc.c
@@ -490,7 +490,7 @@ asmc_attach(device_t dev)
 	 */
 	sc->sc_fan_tree[0] = SYSCTL_ADD_NODE(sysctlctx,
 	    SYSCTL_CHILDREN(sysctlnode), OID_AUTO, "fan",
-	    CTLFLAG_RD, 0, "Fan Root Tree");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "Fan Root Tree");
 
 	for (i = 1; i <= sc->sc_nfan; i++) {
 		j = i - 1;
@@ -498,46 +498,48 @@ asmc_attach(device_t dev)
 		name[1] = 0;
 		sc->sc_fan_tree[i] = SYSCTL_ADD_NODE(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_fan_tree[0]),
-		    OID_AUTO, name, CTLFLAG_RD, 0,
+		    OID_AUTO, name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
 		    "Fan Subtree");
 
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_fan_tree[i]),
-		    OID_AUTO, "id", CTLTYPE_STRING | CTLFLAG_RD,
+		    OID_AUTO, "id",
+		    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		    dev, j, model->smc_fan_id, "I",
 		    "Fan ID");
 
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_fan_tree[i]),
-		    OID_AUTO, "speed", CTLTYPE_INT | CTLFLAG_RD,
+		    OID_AUTO, "speed",
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		    dev, j, model->smc_fan_speed, "I",
 		    "Fan speed in RPM");
 
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_fan_tree[i]),
 		    OID_AUTO, "safespeed",
-		    CTLTYPE_INT | CTLFLAG_RD,
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		    dev, j, model->smc_fan_safespeed, "I",
 		    "Fan safe speed in RPM");
 
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_fan_tree[i]),
 		    OID_AUTO, "minspeed",
-		    CTLTYPE_INT | CTLFLAG_RW,
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 		    dev, j, model->smc_fan_minspeed, "I",
 		    "Fan minimum speed in RPM");
 
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_fan_tree[i]),
 		    OID_AUTO, "maxspeed",
-		    CTLTYPE_INT | CTLFLAG_RW,
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 		    dev, j, model->smc_fan_maxspeed, "I",
 		    "Fan maximum speed in RPM");
 
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_fan_tree[i]),
 		    OID_AUTO, "targetspeed",
-		    CTLTYPE_INT | CTLFLAG_RW,
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 		    dev, j, model->smc_fan_targetspeed, "I",
 		    "Fan target speed in RPM");
 	}
@@ -547,13 +549,13 @@ asmc_attach(device_t dev)
 	 */
 	sc->sc_temp_tree = SYSCTL_ADD_NODE(sysctlctx,
 	    SYSCTL_CHILDREN(sysctlnode), OID_AUTO, "temp",
-	    CTLFLAG_RD, 0, "Temperature sensors");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "Temperature sensors");
 
 	for (i = 0; model->smc_temps[i]; i++) {
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_temp_tree),
 		    OID_AUTO, model->smc_tempnames[i],
-		    CTLTYPE_INT | CTLFLAG_RD,
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		    dev, i, asmc_temp_sysctl, "I",
 		    model->smc_tempdescs[i]);
 	}
@@ -564,25 +566,29 @@ asmc_attach(device_t dev)
 	if (model->smc_light_left) {
 		sc->sc_light_tree = SYSCTL_ADD_NODE(sysctlctx,
 		    SYSCTL_CHILDREN(sysctlnode), OID_AUTO, "light",
-		    CTLFLAG_RD, 0, "Keyboard backlight sensors");
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+		    "Keyboard backlight sensors");
 
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_light_tree),
-		    OID_AUTO, "left", CTLTYPE_INT | CTLFLAG_RD,
+		    OID_AUTO, "left",
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		    dev, 0, model->smc_light_left, "I",
 		    "Keyboard backlight left sensor");
 
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_light_tree),
-		    OID_AUTO, "right", CTLTYPE_INT | CTLFLAG_RD,
+		    OID_AUTO, "right",
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		    dev, 0, model->smc_light_right, "I",
 		    "Keyboard backlight right sensor");
 
 		SYSCTL_ADD_PROC(sysctlctx,
 		    SYSCTL_CHILDREN(sc->sc_light_tree),
 		    OID_AUTO, "control",
-		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
-		    dev, 0, model->smc_light_control, "I",
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY |
+		    CTLFLAG_NEEDGIANT, dev, 0,
+		    model->smc_light_control, "I",
 		    "Keyboard backlight brightness control");
 	}
 
@@ -594,23 +600,26 @@ asmc_attach(device_t dev)
 	 */
 	sc->sc_sms_tree = SYSCTL_ADD_NODE(sysctlctx,
 	    SYSCTL_CHILDREN(sysctlnode), OID_AUTO, "sms",
-	    CTLFLAG_RD, 0, "Sudden Motion Sensor");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "Sudden Motion Sensor");
 
 	SYSCTL_ADD_PROC(sysctlctx,
 	    SYSCTL_CHILDREN(sc->sc_sms_tree),
-	    OID_AUTO, "x", CTLTYPE_INT | CTLFLAG_RD,
+	    OID_AUTO, "x",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    dev, 0, model->smc_sms_x, "I",
 	    "Sudden Motion Sensor X value");
 
 	SYSCTL_ADD_PROC(sysctlctx,
 	    SYSCTL_CHILDREN(sc->sc_sms_tree),
-	    OID_AUTO, "y", CTLTYPE_INT | CTLFLAG_RD,
+	    OID_AUTO, "y",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    dev, 0, model->smc_sms_y, "I",
 	    "Sudden Motion Sensor Y value");
 
 	SYSCTL_ADD_PROC(sysctlctx,
 	    SYSCTL_CHILDREN(sc->sc_sms_tree),
-	    OID_AUTO, "z", CTLTYPE_INT | CTLFLAG_RD,
+	    OID_AUTO, "z",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    dev, 0, model->smc_sms_z, "I",
 	    "Sudden Motion Sensor Z value");
 
diff --git a/sys/dev/ata/ata-all.c b/sys/dev/ata/ata-all.c
index f9a82f730f5c..e456017fd4d5 100644
--- a/sys/dev/ata/ata-all.c
+++ b/sys/dev/ata/ata-all.c
@@ -78,7 +78,8 @@ devclass_t ata_devclass;
 int ata_dma_check_80pin = 1;
 
 /* sysctl vars */
-static SYSCTL_NODE(_hw, OID_AUTO, ata, CTLFLAG_RD, 0, "ATA driver parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, ata, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "ATA driver parameters");
 SYSCTL_INT(_hw_ata, OID_AUTO, ata_dma_check_80pin,
 	   CTLFLAG_RWTUN, &ata_dma_check_80pin, 0,
 	   "Check for 80pin cable before setting ATA DMA mode");
diff --git a/sys/dev/atkbdc/psm.c b/sys/dev/atkbdc/psm.c
index 67890f45bb1e..cbdcc13a8b09 100644
--- a/sys/dev/atkbdc/psm.c
+++ b/sys/dev/atkbdc/psm.c
@@ -2943,8 +2943,10 @@ psmtimeout(void *arg)
 }
 
 /* Add all sysctls under the debug.psm and hw.psm nodes */
-static SYSCTL_NODE(_debug, OID_AUTO, psm, CTLFLAG_RD, 0, "ps/2 mouse");
-static SYSCTL_NODE(_hw, OID_AUTO, psm, CTLFLAG_RD, 0, "ps/2 mouse");
+static SYSCTL_NODE(_debug, OID_AUTO, psm, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "ps/2 mouse");
+static SYSCTL_NODE(_hw, OID_AUTO, psm, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "ps/2 mouse");
 
 SYSCTL_INT(_debug_psm, OID_AUTO, loglevel, CTLFLAG_RWTUN, &verbose, 0,
     "Verbosity level");
@@ -5800,7 +5802,8 @@ synaptics_sysctl_create_softbuttons_tree(struct psm_softc *sc)
 	sc->syninfo.softbuttons_y = sc->synhw.topButtonPad ? -1700 : 1700;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "softbuttons_y", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "softbuttons_y",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_SOFTBUTTONS_Y,
 	    synaptics_sysctl, "I",
 	    "Vertical size of softbuttons area");
@@ -5809,7 +5812,8 @@ synaptics_sysctl_create_softbuttons_tree(struct psm_softc *sc)
 	sc->syninfo.softbutton2_x = 3100;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "softbutton2_x", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "softbutton2_x",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_SOFTBUTTON2_X,
 	    synaptics_sysctl, "I",
 	    "Horisontal position of 2-nd softbutton left edge (0-disable)");
@@ -5818,7 +5822,8 @@ synaptics_sysctl_create_softbuttons_tree(struct psm_softc *sc)
 	sc->syninfo.softbutton3_x = 3900;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "softbutton3_x", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "softbutton3_x",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_SOFTBUTTON3_X,
 	    synaptics_sysctl, "I",
 	    "Horisontal position of 3-rd softbutton left edge (0-disable)");
@@ -5835,8 +5840,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	/* Attach extra synaptics sysctl nodes under hw.psm.synaptics */
 	sysctl_ctx_init(&sc->syninfo.sysctl_ctx);
 	sc->syninfo.sysctl_tree = SYSCTL_ADD_NODE(&sc->syninfo.sysctl_ctx,
-	    SYSCTL_STATIC_CHILDREN(_hw_psm), OID_AUTO, name, CTLFLAG_RD,
-	    0, descr);
+	    SYSCTL_STATIC_CHILDREN(_hw_psm), OID_AUTO, name,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, descr);
 
 	/* hw.psm.synaptics.directional_scrolls. */
 	sc->syninfo.directional_scrolls = 0;
@@ -5884,7 +5889,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.min_pressure = 32;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "min_pressure", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "min_pressure",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_MIN_PRESSURE,
 	    synaptics_sysctl, "I",
 	    "Minimum pressure required to start an action");
@@ -5893,7 +5899,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.max_pressure = 220;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "max_pressure", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "max_pressure",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_MAX_PRESSURE,
 	    synaptics_sysctl, "I",
 	    "Maximum pressure to detect palm");
@@ -5902,7 +5909,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.max_width = 10;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "max_width", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "max_width",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_MAX_WIDTH,
 	    synaptics_sysctl, "I",
 	    "Maximum finger width to detect palm");
@@ -5911,7 +5919,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.margin_top = 200;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "margin_top", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "margin_top",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_MARGIN_TOP,
 	    synaptics_sysctl, "I",
 	    "Top margin");
@@ -5920,7 +5929,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.margin_right = 200;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "margin_right", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "margin_right",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_MARGIN_RIGHT,
 	    synaptics_sysctl, "I",
 	    "Right margin");
@@ -5929,7 +5939,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.margin_bottom = 200;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "margin_bottom", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "margin_bottom",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_MARGIN_BOTTOM,
 	    synaptics_sysctl, "I",
 	    "Bottom margin");
@@ -5938,7 +5949,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.margin_left = 200;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "margin_left", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "margin_left",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_MARGIN_LEFT,
 	    synaptics_sysctl, "I",
 	    "Left margin");
@@ -5947,7 +5959,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.na_top = 1783;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "na_top", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "na_top",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_NA_TOP,
 	    synaptics_sysctl, "I",
 	    "Top noisy area, where weight_previous_na is used instead "
@@ -5957,7 +5970,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.na_right = 563;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "na_right", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "na_right",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_NA_RIGHT,
 	    synaptics_sysctl, "I",
 	    "Right noisy area, where weight_previous_na is used instead "
@@ -5967,7 +5981,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.na_bottom = 1408;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "na_bottom", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "na_bottom",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_NA_BOTTOM,
 	    synaptics_sysctl, "I",
 	    "Bottom noisy area, where weight_previous_na is used instead "
@@ -5977,7 +5992,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.na_left = 1600;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "na_left", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "na_left",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_NA_LEFT,
 	    synaptics_sysctl, "I",
 	    "Left noisy area, where weight_previous_na is used instead "
@@ -5987,7 +6003,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.window_min = 4;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "window_min", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "window_min",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_WINDOW_MIN,
 	    synaptics_sysctl, "I",
 	    "Minimum window size to start an action");
@@ -5996,7 +6013,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.window_max = 10;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "window_max", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "window_max",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_WINDOW_MAX,
 	    synaptics_sysctl, "I",
 	    "Maximum window size");
@@ -6005,7 +6023,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.multiplicator = 10000;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "multiplicator", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "multiplicator",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_MULTIPLICATOR,
 	    synaptics_sysctl, "I",
 	    "Multiplicator to increase precision in averages and divisions");
@@ -6014,7 +6033,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.weight_current = 3;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "weight_current", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "weight_current",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_WEIGHT_CURRENT,
 	    synaptics_sysctl, "I",
 	    "Weight of the current movement in the new average");
@@ -6023,7 +6043,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.weight_previous = 6;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "weight_previous", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "weight_previous",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_WEIGHT_PREVIOUS,
 	    synaptics_sysctl, "I",
 	    "Weight of the previous average");
@@ -6032,7 +6053,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.weight_previous_na = 20;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "weight_previous_na", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "weight_previous_na",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_WEIGHT_PREVIOUS_NA,
 	    synaptics_sysctl, "I",
 	    "Weight of the previous average (inside the noisy area)");
@@ -6041,7 +6063,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.weight_len_squared = 2000;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "weight_len_squared", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "weight_len_squared",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_WEIGHT_LEN_SQUARED,
 	    synaptics_sysctl, "I",
 	    "Length (squared) of segments where weight_previous "
@@ -6051,7 +6074,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.div_min = 9;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "div_min", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "div_min",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_DIV_MIN,
 	    synaptics_sysctl, "I",
 	    "Divisor for fast movements");
@@ -6060,7 +6084,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.div_max = 17;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "div_max", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "div_max",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_DIV_MAX,
 	    synaptics_sysctl, "I",
 	    "Divisor for slow movements");
@@ -6069,7 +6094,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.div_max_na = 30;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "div_max_na", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "div_max_na",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_DIV_MAX_NA,
 	    synaptics_sysctl, "I",
 	    "Divisor with slow movements (inside the noisy area)");
@@ -6078,7 +6104,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.div_len = 100;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "div_len", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "div_len",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_DIV_LEN,
 	    synaptics_sysctl, "I",
 	    "Length of segments where div_max starts to decrease");
@@ -6087,7 +6114,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.tap_max_delta = 80;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "tap_max_delta", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "tap_max_delta",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_TAP_MAX_DELTA,
 	    synaptics_sysctl, "I",
 	    "Length of segments above which a tap is ignored");
@@ -6096,7 +6124,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.tap_min_queue = 2;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "tap_min_queue", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "tap_min_queue",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_TAP_MIN_QUEUE,
 	    synaptics_sysctl, "I",
 	    "Number of packets required to consider a tap");
@@ -6106,7 +6135,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.taphold_timeout = tap_timeout;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "taphold_timeout", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "taphold_timeout",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_TAPHOLD_TIMEOUT,
 	    synaptics_sysctl, "I",
 	    "Maximum elapsed time between two taps to consider a tap-hold "
@@ -6116,7 +6146,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.vscroll_hor_area = 0; /* 1300 */
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "vscroll_hor_area", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "vscroll_hor_area",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_VSCROLL_HOR_AREA,
 	    synaptics_sysctl, "I",
 	    "Area reserved for horizontal virtual scrolling");
@@ -6125,7 +6156,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.vscroll_ver_area = -400 - sc->syninfo.margin_right;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "vscroll_ver_area", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "vscroll_ver_area",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_VSCROLL_VER_AREA,
 	    synaptics_sysctl, "I",
 	    "Area reserved for vertical virtual scrolling");
@@ -6134,7 +6166,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.vscroll_min_delta = 50;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "vscroll_min_delta", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "vscroll_min_delta",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_VSCROLL_MIN_DELTA,
 	    synaptics_sysctl, "I",
 	    "Minimum movement to consider virtual scrolling");
@@ -6143,7 +6176,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.vscroll_div_min = 100;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "vscroll_div_min", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "vscroll_div_min",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_VSCROLL_DIV_MIN,
 	    synaptics_sysctl, "I",
 	    "Divisor for fast scrolling");
@@ -6152,7 +6186,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.vscroll_div_max = 150;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "vscroll_div_max", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "vscroll_div_max",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_VSCROLL_DIV_MAX,
 	    synaptics_sysctl, "I",
 	    "Divisor for slow scrolling");
@@ -6161,7 +6196,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.touchpad_off = 0;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "touchpad_off", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "touchpad_off",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_TOUCHPAD_OFF,
 	    synaptics_sysctl, "I",
 	    "Turn off touchpad");
@@ -6169,7 +6205,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.three_finger_drag = 0;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "three_finger_drag", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "three_finger_drag",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_THREE_FINGER_DRAG,
 	    synaptics_sysctl, "I",
 	    "Enable dragging with three fingers");
@@ -6178,7 +6215,8 @@ synaptics_sysctl_create_tree(struct psm_softc *sc, const char *name,
 	sc->syninfo.natural_scroll = 0;
 	SYSCTL_ADD_PROC(&sc->syninfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->syninfo.sysctl_tree), OID_AUTO,
-	    "natural_scroll", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "natural_scroll",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, SYNAPTICS_SYSCTL_NATURAL_SCROLL,
 	    synaptics_sysctl, "I",
 	    "Enable natural scrolling");
@@ -6763,14 +6801,15 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	/* Attach extra trackpoint sysctl nodes under hw.psm.trackpoint */
 	sysctl_ctx_init(&sc->tpinfo.sysctl_ctx);
 	sc->tpinfo.sysctl_tree = SYSCTL_ADD_NODE(&sc->tpinfo.sysctl_ctx,
-	    SYSCTL_STATIC_CHILDREN(_hw_psm), OID_AUTO, "trackpoint", CTLFLAG_RD,
-	    0, "IBM/Lenovo TrackPoint");
+	    SYSCTL_STATIC_CHILDREN(_hw_psm), OID_AUTO, "trackpoint",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "IBM/Lenovo TrackPoint");
 
 	/* hw.psm.trackpoint.sensitivity */
 	sc->tpinfo.sensitivity = 0x80;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "sensitivity", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "sensitivity",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_SENSITIVITY,
 	    trackpoint_sysctl, "I",
 	    "Sensitivity");
@@ -6779,7 +6818,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.inertia = 0x06;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "negative_inertia", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "negative_inertia",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_NEGATIVE_INERTIA,
 	    trackpoint_sysctl, "I",
 	    "Negative inertia factor");
@@ -6788,7 +6828,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.uplateau = 0x61;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "upper_plateau", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "upper_plateau",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_UPPER_PLATEAU,
 	    trackpoint_sysctl, "I",
 	    "Transfer function upper plateau speed");
@@ -6797,7 +6838,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.reach = 0x0a;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "backup_range", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "backup_range",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_BACKUP_RANGE,
 	    trackpoint_sysctl, "I",
 	    "Backup range");
@@ -6806,7 +6848,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.draghys = 0xff;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "drag_hysteresis", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "drag_hysteresis",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_DRAG_HYSTERESIS,
 	    trackpoint_sysctl, "I",
 	    "Drag hysteresis");
@@ -6815,7 +6858,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.mindrag = 0x14;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "minimum_drag", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "minimum_drag",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_MINIMUM_DRAG,
 	    trackpoint_sysctl, "I",
 	    "Minimum drag");
@@ -6824,7 +6868,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.upthresh = 0xff;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "up_threshold", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "up_threshold",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_UP_THRESHOLD,
 	    trackpoint_sysctl, "I",
 	    "Up threshold for release");
@@ -6833,7 +6878,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.threshold = 0x08;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "threshold", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "threshold",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_THRESHOLD,
 	    trackpoint_sysctl, "I",
 	    "Threshold");
@@ -6842,7 +6888,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.jenks = 0x87;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "jenks_curvature", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "jenks_curvature",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_JENKS_CURVATURE,
 	    trackpoint_sysctl, "I",
 	    "Jenks curvature");
@@ -6851,7 +6898,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.ztime = 0x26;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "z_time", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "z_time",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_Z_TIME,
 	    trackpoint_sysctl, "I",
 	    "Z time constant");
@@ -6860,7 +6908,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.pts = 0x00;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "press_to_select", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "press_to_select",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_PRESS_TO_SELECT,
 	    trackpoint_sysctl, "I",
 	    "Press to Select");
@@ -6869,7 +6918,8 @@ trackpoint_sysctl_create_tree(struct psm_softc *sc)
 	sc->tpinfo.skipback = 0x00;
 	SYSCTL_ADD_PROC(&sc->tpinfo.sysctl_ctx,
 	    SYSCTL_CHILDREN(sc->tpinfo.sysctl_tree), OID_AUTO,
-	    "skip_backups", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
+	    "skip_backups",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT,
 	    sc, TRACKPOINT_SYSCTL_SKIP_BACKUPS,
 	    trackpoint_sysctl, "I",
 	    "Skip backups from drags");
diff --git a/sys/dev/bce/if_bce.c b/sys/dev/bce/if_bce.c
index 205a0f3f343e..24255770a618 100644
--- a/sys/dev/bce/if_bce.c
+++ b/sys/dev/bce/if_bce.c
@@ -535,7 +535,8 @@ MODULE_PNP_INFO("U16:vendor;U16:device;U16:#;U16:#;D:#", pci, bce,
 /****************************************************************************/
 /* Tunable device values                                                    */
 /****************************************************************************/
-static SYSCTL_NODE(_hw, OID_AUTO, bce, CTLFLAG_RD, 0, "bce driver parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, bce, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "bce driver parameters");
 
 /* Allowable values are TRUE or FALSE */
 static int bce_verbose = TRUE;
@@ -9299,13 +9300,13 @@ bce_add_sysctls(struct bce_softc *sc)
 	}
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "nvram_dump", CTLTYPE_OPAQUE | CTLFLAG_RD,
+	    "nvram_dump", CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_nvram_dump, "S", "");
 
 #ifdef BCE_NVRAM_WRITE_SUPPORT
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "nvram_write", CTLTYPE_OPAQUE | CTLFLAG_WR,
+	    "nvram_write", CTLTYPE_OPAQUE | CTLFLAG_WR | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_nvram_write, "S", "");
 #endif
@@ -9590,84 +9591,85 @@ bce_add_sysctls(struct bce_softc *sc)
 
 #ifdef BCE_DEBUG
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "driver_state", CTLTYPE_INT | CTLFLAG_RW,
+	    "driver_state", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_driver_state, "I", "Drive state information");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "hw_state", CTLTYPE_INT | CTLFLAG_RW,
+	    "hw_state", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_hw_state, "I", "Hardware state information");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "status_block", CTLTYPE_INT | CTLFLAG_RW,
+	    "status_block", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_status_block, "I", "Dump status block");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "stats_block", CTLTYPE_INT | CTLFLAG_RW,
+	    "stats_block", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_stats_block, "I", "Dump statistics block");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "stats_clear", CTLTYPE_INT | CTLFLAG_RW,
+	    "stats_clear", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_stats_clear, "I", "Clear statistics block");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "shmem_state", CTLTYPE_INT | CTLFLAG_RW,
+	    "shmem_state", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_shmem_state, "I", "Shared memory state information");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "bc_state", CTLTYPE_INT | CTLFLAG_RW,
+	    "bc_state", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_bc_state, "I", "Bootcode state information");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "dump_rx_bd_chain", CTLTYPE_INT | CTLFLAG_RW,
+	    "dump_rx_bd_chain", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_dump_rx_bd_chain, "I", "Dump RX BD chain");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "dump_rx_mbuf_chain", CTLTYPE_INT | CTLFLAG_RW,
+	    "dump_rx_mbuf_chain", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_dump_rx_mbuf_chain, "I", "Dump RX MBUF chain");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "dump_tx_chain", CTLTYPE_INT | CTLFLAG_RW,
+	    "dump_tx_chain", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_dump_tx_chain, "I", "Dump tx_bd chain");
 
 	if (bce_hdr_split == TRUE) {
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		    "dump_pg_chain", CTLTYPE_INT | CTLFLAG_RW,
+		    "dump_pg_chain",
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 		    (void *)sc, 0,
 		    bce_sysctl_dump_pg_chain, "I", "Dump page chain");
 	}
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "dump_ctx", CTLTYPE_INT | CTLFLAG_RW,
+	    "dump_ctx", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_dump_ctx, "I", "Dump context memory");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "breakpoint", CTLTYPE_INT | CTLFLAG_RW,
+	    "breakpoint", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_breakpoint, "I", "Driver breakpoint");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "reg_read", CTLTYPE_INT | CTLFLAG_RW,
+	    "reg_read", CTLTYPE_INT | CTLFLAG_RW| CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_reg_read, "I", "Register read");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "nvram_read", CTLTYPE_INT | CTLFLAG_RW,
+	    "nvram_read", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_nvram_read, "I", "NVRAM read");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-	    "phy_read", CTLTYPE_INT | CTLFLAG_RW,
+	    "phy_read", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    (void *)sc, 0,
 	    bce_sysctl_phy_read, "I", "PHY register read");
 
diff --git a/sys/dev/bfe/if_bfe.c b/sys/dev/bfe/if_bfe.c
index 562ac165f54a..c7d7ebf8aafb 100644
--- a/sys/dev/bfe/if_bfe.c
+++ b/sys/dev/bfe/if_bfe.c
@@ -478,8 +478,8 @@ bfe_attach(device_t dev)
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "stats", CTLTYPE_INT | CTLFLAG_RW, sc, 0, sysctl_bfe_stats,
-	    "I", "Statistics");
+	    "stats", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    sysctl_bfe_stats, "I", "Statistics");
 
 	/* Set up ifnet structure */
 	ifp = sc->bfe_ifp = if_alloc(IFT_ETHER);
diff --git a/sys/dev/bge/if_bge.c b/sys/dev/bge/if_bge.c
index 551c18f8bf4b..0664f68e4aca 100644
--- a/sys/dev/bge/if_bge.c
+++ b/sys/dev/bge/if_bge.c
@@ -546,7 +546,8 @@ DRIVER_MODULE(miibus, bge, miibus_driver, miibus_devclass, 0, 0);
 
 static int bge_allow_asf = 1;
 
-static SYSCTL_NODE(_hw, OID_AUTO, bge, CTLFLAG_RD, 0, "BGE driver parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, bge, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "BGE driver parameters");
 SYSCTL_INT(_hw_bge, OID_AUTO, allow_asf, CTLFLAG_RDTUN, &bge_allow_asf, 0,
 	"Allow ASF mode if available");
 
@@ -6247,20 +6248,20 @@ bge_add_sysctls(struct bge_softc *sc)
 
 #ifdef BGE_REGISTER_DEBUG
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "debug_info",
-	    CTLTYPE_INT | CTLFLAG_RW, sc, 0, bge_sysctl_debug_info, "I",
-	    "Debug Information");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    bge_sysctl_debug_info, "I", "Debug Information");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "reg_read",
-	    CTLTYPE_INT | CTLFLAG_RW, sc, 0, bge_sysctl_reg_read, "I",
-	    "MAC Register Read");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    bge_sysctl_reg_read, "I", "MAC Register Read");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "ape_read",
-	    CTLTYPE_INT | CTLFLAG_RW, sc, 0, bge_sysctl_ape_read, "I",
-	    "APE Register Read");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    bge_sysctl_ape_read, "I", "APE Register Read");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "mem_read",
-	    CTLTYPE_INT | CTLFLAG_RW, sc, 0, bge_sysctl_mem_read, "I",
-	    "Memory Read");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    bge_sysctl_mem_read, "I", "Memory Read");
 
 #endif
 
@@ -6310,9 +6311,9 @@ bge_add_sysctls(struct bge_softc *sc)
 }
 
 #define BGE_SYSCTL_STAT(sc, ctx, desc, parent, node, oid) \
-	SYSCTL_ADD_PROC(ctx, parent, OID_AUTO, oid, CTLTYPE_UINT|CTLFLAG_RD, \
-	    sc, offsetof(struct bge_stats, node), bge_sysctl_stats, "IU", \
-	    desc)
+    SYSCTL_ADD_PROC(ctx, parent, OID_AUTO, oid, \
+        CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, \
+	offsetof(struct bge_stats, node), bge_sysctl_stats, "IU", desc)
 
 static void
 bge_add_sysctl_stats(struct bge_softc *sc, struct sysctl_ctx_list *ctx,
@@ -6321,8 +6322,8 @@ bge_add_sysctl_stats(struct bge_softc *sc, struct sysctl_ctx_list *ctx,
 	struct sysctl_oid *tree;
 	struct sysctl_oid_list *children, *schildren;
 
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "BGE Statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "BGE Statistics");
 	schildren = children = SYSCTL_CHILDREN(tree);
 	BGE_SYSCTL_STAT(sc, ctx, "Frames Dropped Due To Filters",
 	    children, COSFramesDroppedDueToFilters,
@@ -6356,8 +6357,8 @@ bge_add_sysctl_stats(struct bge_softc *sc, struct sysctl_ctx_list *ctx,
 	BGE_SYSCTL_STAT(sc, ctx, "NIC Send Threshold Hit",
 	    children, nicSendThresholdHit, "SendThresholdHit");
 
-	tree = SYSCTL_ADD_NODE(ctx, schildren, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "BGE RX Statistics");
+	tree = SYSCTL_ADD_NODE(ctx, schildren, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "BGE RX Statistics");
 	children = SYSCTL_CHILDREN(tree);
 	BGE_SYSCTL_STAT(sc, ctx, "Inbound Octets",
 	    children, rxstats.ifHCInOctets, "ifHCInOctets");
@@ -6392,8 +6393,8 @@ bge_add_sysctl_stats(struct bge_softc *sc, struct sysctl_ctx_list *ctx,
 	BGE_SYSCTL_STAT(sc, ctx, "Outbound Range Length Errors",
 	    children, rxstats.outRangeLengthError, "outRangeLengthError");
 
-	tree = SYSCTL_ADD_NODE(ctx, schildren, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "BGE TX Statistics");
+	tree = SYSCTL_ADD_NODE(ctx, schildren, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "BGE TX Statistics");
 	children = SYSCTL_CHILDREN(tree);
 	BGE_SYSCTL_STAT(sc, ctx, "Outbound Octets",
 	    children, txstats.ifHCOutOctets, "ifHCOutOctets");
@@ -6452,8 +6453,8 @@ bge_add_sysctl_stats_regs(struct bge_softc *sc, struct sysctl_ctx_list *ctx,
 	struct bge_mac_stats *stats;
 
 	stats = &sc->bge_mac_stats;
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "BGE Statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "BGE Statistics");
 	schild = child = SYSCTL_CHILDREN(tree);
 	BGE_SYSCTL_STAT_ADD64(ctx, child, "FramesDroppedDueToFilters",
 	    &stats->FramesDroppedDueToFilters, "Frames Dropped Due to Filters");
@@ -6471,8 +6472,8 @@ bge_add_sysctl_stats_regs(struct bge_softc *sc, struct sysctl_ctx_list *ctx,
 	BGE_SYSCTL_STAT_ADD64(ctx, child, "RecvThresholdHit",
 	    &stats->RecvThresholdHit, "NIC Recv Threshold Hit");
 
-	tree = SYSCTL_ADD_NODE(ctx, schild, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "BGE RX Statistics");
+	tree = SYSCTL_ADD_NODE(ctx, schild, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "BGE RX Statistics");
 	child = SYSCTL_CHILDREN(tree);
 	BGE_SYSCTL_STAT_ADD64(ctx, child, "ifHCInOctets",
 	    &stats->ifHCInOctets, "Inbound Octets");
@@ -6503,8 +6504,8 @@ bge_add_sysctl_stats_regs(struct bge_softc *sc, struct sysctl_ctx_list *ctx,
 	BGE_SYSCTL_STAT_ADD64(ctx, child, "UndersizePkts",
 	    &stats->etherStatsUndersizePkts, "Undersized Packets");
 
-	tree = SYSCTL_ADD_NODE(ctx, schild, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "BGE TX Statistics");
+	tree = SYSCTL_ADD_NODE(ctx, schild, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "BGE TX Statistics");
 	child = SYSCTL_CHILDREN(tree);
 	BGE_SYSCTL_STAT_ADD64(ctx, child, "ifHCOutOctets",
 	    &stats->ifHCOutOctets, "Outbound Octets");
diff --git a/sys/dev/bhnd/cores/pmu/bhnd_pmu.c b/sys/dev/bhnd/cores/pmu/bhnd_pmu.c
index 85d93d2b2c20..8b58212745e3 100644
--- a/sys/dev/bhnd/cores/pmu/bhnd_pmu.c
+++ b/sys/dev/bhnd/cores/pmu/bhnd_pmu.c
@@ -191,15 +191,15 @@ bhnd_pmu_attach(device_t dev, struct bhnd_resource *res)
 	tree = device_get_sysctl_tree(dev);
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-	    "bus_freq", CTLTYPE_UINT | CTLFLAG_RD, sc, 0,
+	    "bus_freq", CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    bhnd_pmu_sysctl_bus_freq, "IU", "Bus clock frequency");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-	    "cpu_freq", CTLTYPE_UINT | CTLFLAG_RD, sc, 0,
+	    "cpu_freq", CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    bhnd_pmu_sysctl_cpu_freq, "IU", "CPU clock frequency");
 	
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-	    "mem_freq", CTLTYPE_UINT | CTLFLAG_RD, sc, 0,
+	    "mem_freq", CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    bhnd_pmu_sysctl_mem_freq, "IU", "Memory clock frequency");
 
 	return (0);
diff --git a/sys/dev/bktr/bktr_os.c b/sys/dev/bktr/bktr_os.c
index c446ff32edd5..ce0414ba8465 100644
--- a/sys/dev/bktr/bktr_os.c
+++ b/sys/dev/bktr/bktr_os.c
@@ -110,7 +110,8 @@ int bt848_amsound = 0;		/* hard-wire AM sound at 6.5 Hz (france),
 int bt848_dolby = 0;
 #endif
 
-static SYSCTL_NODE(_hw, OID_AUTO, bt848, CTLFLAG_RW, 0, "Bt848 Driver mgmt");
+static SYSCTL_NODE(_hw, OID_AUTO, bt848, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "Bt848 Driver mgmt");
 SYSCTL_INT(_hw_bt848, OID_AUTO, card, CTLFLAG_RW, &bt848_card, -1, "");
 SYSCTL_INT(_hw_bt848, OID_AUTO, tuner, CTLFLAG_RW, &bt848_tuner, -1, "");
 SYSCTL_INT(_hw_bt848, OID_AUTO, reverse_mute, CTLFLAG_RW, &bt848_reverse_mute, -1, "");
diff --git a/sys/dev/bnxt/bnxt_sysctl.c b/sys/dev/bnxt/bnxt_sysctl.c
index e006260d7527..e566c54e5544 100644
--- a/sys/dev/bnxt/bnxt_sysctl.c
+++ b/sys/dev/bnxt/bnxt_sysctl.c
@@ -58,7 +58,7 @@ bnxt_init_sysctl_ctx(struct bnxt_softc *softc)
 	ctx = device_get_sysctl_ctx(softc->dev);
 	softc->hw_stats_oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(softc->dev)), OID_AUTO,
-	    "hwstats", CTLFLAG_RD, 0, "hardware statistics");
+	    "hwstats", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "hardware statistics");
 	if (!softc->hw_stats_oid) {
 		sysctl_ctx_free(&softc->hw_stats);
 		return ENOMEM;
@@ -68,7 +68,8 @@ bnxt_init_sysctl_ctx(struct bnxt_softc *softc)
 	ctx = device_get_sysctl_ctx(softc->dev);
 	softc->ver_info->ver_oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(softc->dev)), OID_AUTO,
-	    "ver", CTLFLAG_RD, 0, "hardware/firmware version information");
+	    "ver", CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+	    "hardware/firmware version information");
 	if (!softc->ver_info->ver_oid) {
 		sysctl_ctx_free(&softc->ver_info->ver_ctx);
 		return ENOMEM;
@@ -79,7 +80,8 @@ bnxt_init_sysctl_ctx(struct bnxt_softc *softc)
 		ctx = device_get_sysctl_ctx(softc->dev);
 		softc->nvm_info->nvm_oid = SYSCTL_ADD_NODE(ctx,
 		    SYSCTL_CHILDREN(device_get_sysctl_tree(softc->dev)), OID_AUTO,
-		    "nvram", CTLFLAG_RD, 0, "nvram information");
+		    "nvram", CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+		    "nvram information");
 		if (!softc->nvm_info->nvm_oid) {
 			sysctl_ctx_free(&softc->nvm_info->nvm_ctx);
 			return ENOMEM;
@@ -90,7 +92,7 @@ bnxt_init_sysctl_ctx(struct bnxt_softc *softc)
 	ctx = device_get_sysctl_ctx(softc->dev);
 	softc->hw_lro_oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(softc->dev)), OID_AUTO,
-	    "hw_lro", CTLFLAG_RD, 0, "hardware lro");
+	    "hw_lro", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "hardware lro");
 	if (!softc->hw_lro_oid) {
 		sysctl_ctx_free(&softc->hw_lro_ctx);
 		return ENOMEM;
@@ -100,7 +102,7 @@ bnxt_init_sysctl_ctx(struct bnxt_softc *softc)
 	ctx = device_get_sysctl_ctx(softc->dev);
 	softc->flow_ctrl_oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(softc->dev)), OID_AUTO,
-	    "fc", CTLFLAG_RD, 0, "flow ctrl");
+	    "fc", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "flow ctrl");
 	if (!softc->flow_ctrl_oid) {
 		sysctl_ctx_free(&softc->flow_ctrl_ctx);
 		return ENOMEM;
@@ -166,8 +168,8 @@ bnxt_create_tx_sysctls(struct bnxt_softc *softc, int txr)
 	sprintf(name, "txq%d", txr);
 	sprintf(desc, "transmit queue %d", txr);
 	oid = SYSCTL_ADD_NODE(&softc->hw_stats,
-	    SYSCTL_CHILDREN(softc->hw_stats_oid), OID_AUTO, name, CTLFLAG_RD, 0,
-	    desc);
+	    SYSCTL_CHILDREN(softc->hw_stats_oid), OID_AUTO, name,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, desc);
 	if (!oid)
 		return ENOMEM;
 
@@ -210,8 +212,8 @@ bnxt_create_port_stats_sysctls(struct bnxt_softc *softc)
 	sprintf(name, "port_stats");
 	sprintf(desc, "Port Stats");
 	oid = SYSCTL_ADD_NODE(&softc->hw_stats,
-			SYSCTL_CHILDREN(softc->hw_stats_oid), OID_AUTO, name, CTLFLAG_RD, 0,
-			desc);
+	    SYSCTL_CHILDREN(softc->hw_stats_oid), OID_AUTO, name,
+	        CTLFLAG_RD | CTLFLAG_MPSAFE, 0, desc);
 	if (!oid)
 		return ENOMEM;
 
@@ -661,8 +663,8 @@ bnxt_create_rx_sysctls(struct bnxt_softc *softc, int rxr)
 	sprintf(name, "rxq%d", rxr);
 	sprintf(desc, "receive queue %d", rxr);
 	oid = SYSCTL_ADD_NODE(&softc->hw_stats,
-	    SYSCTL_CHILDREN(softc->hw_stats_oid), OID_AUTO, name, CTLFLAG_RD, 0,
-	    desc);
+	    SYSCTL_CHILDREN(softc->hw_stats_oid), OID_AUTO, name,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, desc);
 	if (!oid)
 		return ENOMEM;
 
@@ -861,12 +863,12 @@ bnxt_create_ver_sysctls(struct bnxt_softc *softc)
 	    bnxt_chip_type[MAX_CHIP_TYPE] : bnxt_chip_type[vi->chip_type], 0,
 	    "RoCE firmware name");
 	SYSCTL_ADD_PROC(&vi->ver_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-	    "package_ver", CTLTYPE_STRING|CTLFLAG_RD, softc, 0,
-	    bnxt_package_ver_sysctl, "A",
+	    "package_ver", CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	    softc, 0, bnxt_package_ver_sysctl, "A",
 	    "currently installed package version");
 	SYSCTL_ADD_PROC(&vi->ver_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-	    "hwrm_min_ver", CTLTYPE_STRING|CTLFLAG_RWTUN, softc, 0,
-	    bnxt_hwrm_min_ver_sysctl, "A",
+	    "hwrm_min_ver", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT,
+	    softc, 0, bnxt_hwrm_min_ver_sysctl, "A",
 	    "minimum hwrm API vesion to support");
 
 	return 0;
@@ -1205,44 +1207,49 @@ bnxt_create_config_sysctls_pre(struct bnxt_softc *softc)
 	children = SYSCTL_CHILDREN(device_get_sysctl_tree(softc->dev));;
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rss_key",
-	    CTLTYPE_STRING|CTLFLAG_RWTUN, softc, 0, bnxt_rss_key_sysctl, "A",
-	    "RSS key");
+	    CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_rss_key_sysctl, "A", "RSS key");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rss_type",
-	    CTLTYPE_STRING|CTLFLAG_RWTUN, softc, 0, bnxt_rss_type_sysctl, "A",
-	    "RSS type bits");
+	    CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_rss_type_sysctl, "A", "RSS type bits");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rx_stall",
-	    CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_rx_stall_sysctl, "I",
+	    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_rx_stall_sysctl, "I",
 	    "buffer rx packets in hardware until the host posts new buffers");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "vlan_strip",
-	    CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_vlan_strip_sysctl, "I",
-	    "strip VLAN tag in the RX path");
+	    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_vlan_strip_sysctl, "I", "strip VLAN tag in the RX path");
 	SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "if_name", CTLFLAG_RD,
 		iflib_get_ifp(softc->ctx)->if_xname, 0, "interface name");
 
         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_coal_rx_usecs",
-                        CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_set_coal_rx_usecs,
-			"I", "interrupt coalescing Rx Usecs");
+            CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_set_coal_rx_usecs, "I", "interrupt coalescing Rx Usecs");
         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_coal_rx_frames",
-                        CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_set_coal_rx_frames,
-			"I", "interrupt coalescing Rx Frames");
+            CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_set_coal_rx_frames, "I", "interrupt coalescing Rx Frames");
         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_coal_rx_usecs_irq",
-                        CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_set_coal_rx_usecs_irq,
-			"I", "interrupt coalescing Rx Usecs IRQ");
+            CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_set_coal_rx_usecs_irq, "I",
+	    "interrupt coalescing Rx Usecs IRQ");
         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_coal_rx_frames_irq",
-                        CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_set_coal_rx_frames_irq,
-			"I", "interrupt coalescing Rx Frames IRQ");
+            CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_set_coal_rx_frames_irq, "I",
+	    "interrupt coalescing Rx Frames IRQ");
         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_coal_tx_usecs",
-                        CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_set_coal_tx_usecs,
-			"I", "interrupt coalescing Tx Usces");
+            CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_set_coal_tx_usecs, "I", "interrupt coalescing Tx Usces");
         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_coal_tx_frames",
-                        CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_set_coal_tx_frames,
-			"I", "interrupt coalescing Tx Frames"); 
+            CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_set_coal_tx_frames, "I", "interrupt coalescing Tx Frames"); 
         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_coal_tx_usecs_irq",
-                        CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_set_coal_tx_usecs_irq,
-			"I", "interrupt coalescing Tx Usecs IRQ"); 
+            CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_set_coal_tx_usecs_irq, "I",
+	    "interrupt coalescing Tx Usecs IRQ"); 
         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_coal_tx_frames_irq",
-                        CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_set_coal_tx_frames_irq,
-			"I", "interrupt coalescing Tx Frames IRQ");
+            CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_set_coal_tx_frames_irq, "I",
+	    "interrupt coalescing Tx Frames IRQ");
 
 	return 0;
 }
@@ -1317,19 +1324,17 @@ bnxt_create_pause_fc_sysctls(struct bnxt_softc *softc)
 		return ENOMEM;
 
 	SYSCTL_ADD_PROC(&softc->flow_ctrl_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-			"tx", CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0,
-			bnxt_flow_ctrl_tx, "A",
-			"Enable or Disable Tx Flow Ctrl: 0 / 1");
+	    "tx", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_flow_ctrl_tx, "A", "Enable or Disable Tx Flow Ctrl: 0 / 1");
 
 	SYSCTL_ADD_PROC(&softc->flow_ctrl_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-			"rx", CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0,
-			bnxt_flow_ctrl_rx, "A",
-			"Enable or Disable Tx Flow Ctrl: 0 / 1");
+	    "rx", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_flow_ctrl_rx, "A", "Enable or Disable Tx Flow Ctrl: 0 / 1");
 
 	SYSCTL_ADD_PROC(&softc->flow_ctrl_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-			"autoneg", CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0,
-			bnxt_flow_ctrl_autoneg, "A",
-			"Enable or Disable Autoneg Flow Ctrl: 0 / 1");
+	    "autoneg", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc,
+	    0, bnxt_flow_ctrl_autoneg, "A",
+	    "Enable or Disable Autoneg Flow Ctrl: 0 / 1");
 
 	return 0;
 }
@@ -1343,31 +1348,31 @@ bnxt_create_hw_lro_sysctls(struct bnxt_softc *softc)
 		return ENOMEM;
 
 	SYSCTL_ADD_PROC(&softc->hw_lro_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-			"enable", CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0,
-			bnxt_hw_lro_enable_disable, "A",
-			"Enable or Disable HW LRO: 0 / 1");
+	    "enable", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc,
+	    0, bnxt_hw_lro_enable_disable, "A",
+	    "Enable or Disable HW LRO: 0 / 1");
 
 	SYSCTL_ADD_PROC(&softc->hw_lro_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-			"gro_mode", CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0,
-			bnxt_hw_lro_set_mode, "A",
-			"Set mode: 1 = GRO mode, 0 = RSC mode");
+	    "gro_mode", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc,
+	    0, bnxt_hw_lro_set_mode, "A",
+	    "Set mode: 1 = GRO mode, 0 = RSC mode");
 
 	SYSCTL_ADD_PROC(&softc->hw_lro_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-			"max_agg_segs", CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0,
-			bnxt_hw_lro_set_max_agg_segs, "A",
-			"Set Max Agg Seg Value (unit is Log2): "
-			"0 (= 1 seg) / 1 (= 2 segs) /  ... / 31 (= 2^31 segs)");
+	    "max_agg_segs", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT,
+	    softc, 0, bnxt_hw_lro_set_max_agg_segs, "A",
+	    "Set Max Agg Seg Value (unit is Log2): "
+	    "0 (= 1 seg) / 1 (= 2 segs) /  ... / 31 (= 2^31 segs)");
 	
         SYSCTL_ADD_PROC(&softc->hw_lro_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-			"max_aggs", CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0,
-			bnxt_hw_lro_set_max_aggs, "A",
-			"Set Max Aggs Value (unit is Log2): "
-			"0 (= 1 agg) / 1 (= 2 aggs) /  ... / 7 (= 2^7 segs)"); 
+	    "max_aggs", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT,
+	    softc, 0, bnxt_hw_lro_set_max_aggs, "A",
+	    "Set Max Aggs Value (unit is Log2): "
+	    "0 (= 1 agg) / 1 (= 2 aggs) /  ... / 7 (= 2^7 segs)"); 
 
 	SYSCTL_ADD_PROC(&softc->hw_lro_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-			"min_agg_len", CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0,
-			bnxt_hw_lro_set_min_agg_len, "A",
-			"Min Agg Len: 1 to 9000");
+	    "min_agg_len", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT,
+	    softc, 0, bnxt_hw_lro_set_min_agg_len, "A",
+	    "Min Agg Len: 1 to 9000");
 
 	return 0;
 }
@@ -1407,7 +1412,8 @@ bnxt_create_config_sysctls_post(struct bnxt_softc *softc)
 	children = SYSCTL_CHILDREN(device_get_sysctl_tree(softc->dev));;
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "vlan_only",
-	    CTLTYPE_INT|CTLFLAG_RWTUN, softc, 0, bnxt_vlan_only_sysctl, "I",
+	    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, softc, 0,
+	    bnxt_vlan_only_sysctl, "I",
 	    "require vlan tag on received packets when vlan is enabled");
 
 	return 0;
diff --git a/sys/dev/bwn/if_bwn.c b/sys/dev/bwn/if_bwn.c
index 6fefaf4ccd89..37d743e15feb 100644
--- a/sys/dev/bwn/if_bwn.c
+++ b/sys/dev/bwn/if_bwn.c
@@ -98,7 +98,7 @@ __FBSDID("$FreeBSD$");
 
 #include "gpio_if.h"
 
-static SYSCTL_NODE(_hw, OID_AUTO, bwn, CTLFLAG_RD, 0,
+static SYSCTL_NODE(_hw, OID_AUTO, bwn, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "Broadcom driver parameters");
 
 /*
diff --git a/sys/dev/bxe/bxe.c b/sys/dev/bxe/bxe.c
index 7dc0154ecda4..c8f37ba459f4 100644
--- a/sys/dev/bxe/bxe.c
+++ b/sys/dev/bxe/bxe.c
@@ -258,7 +258,8 @@ static int load_count[2][3] = { {0} }; /* per-path: 0-common, 1-port0, 2-port1 *
 
 /* Tunable device values... */
 
-SYSCTL_NODE(_hw, OID_AUTO, bxe, CTLFLAG_RD, 0, "bxe driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, bxe, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "bxe driver parameters");
 
 /* Debug */
 unsigned long bxe_debug = 0;
@@ -16163,44 +16164,41 @@ bxe_add_sysctls(struct bxe_softc *sc)
                     CTLFLAG_RW, &sc->rx_budget, 0,
                     "rx processing budget");
 
-   SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pause_param",
-                    CTLTYPE_UINT | CTLFLAG_RW, sc, 0,
-                    bxe_sysctl_pauseparam, "IU",
-                    "need pause frames- DEF:0/TX:1/RX:2/BOTH:3/AUTO:4/AUTOTX:5/AUTORX:6/AUTORXTX:7/NONE:8");
+    SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pause_param",
+        CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+        bxe_sysctl_pauseparam, "IU",
+        "need pause frames- DEF:0/TX:1/RX:2/BOTH:3/AUTO:4/AUTOTX:5/AUTORX:6/AUTORXTX:7/NONE:8");
 
 
     SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "state",
-                    CTLTYPE_UINT | CTLFLAG_RW, sc, 0,
-                    bxe_sysctl_state, "IU", "dump driver state");
+        CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+        bxe_sysctl_state, "IU", "dump driver state");
 
     for (i = 0; i < BXE_NUM_ETH_STATS; i++) {
         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-                        bxe_eth_stats_arr[i].string,
-                        CTLTYPE_U64 | CTLFLAG_RD, sc, i,
-                        bxe_sysctl_eth_stat, "LU",
-                        bxe_eth_stats_arr[i].string);
+            bxe_eth_stats_arr[i].string,
+            CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, i,
+            bxe_sysctl_eth_stat, "LU", bxe_eth_stats_arr[i].string);
     }
 
     /* add a new parent node for all queues "dev.bxe.#.queue" */
     queue_top = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "queue",
-                                CTLFLAG_RD, NULL, "queue");
+        CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "queue");
     queue_top_children = SYSCTL_CHILDREN(queue_top);
 
     for (i = 0; i < sc->num_queues; i++) {
         /* add a new parent node for a single queue "dev.bxe.#.queue.#" */
         snprintf(queue_num_buf, sizeof(queue_num_buf), "%d", i);
         queue = SYSCTL_ADD_NODE(ctx, queue_top_children, OID_AUTO,
-                                queue_num_buf, CTLFLAG_RD, NULL,
-                                "single queue");
+            queue_num_buf, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "single queue");
         queue_children = SYSCTL_CHILDREN(queue);
 
         for (j = 0; j < BXE_NUM_ETH_Q_STATS; j++) {
             q_stat = ((i << 16) | j);
             SYSCTL_ADD_PROC(ctx, queue_children, OID_AUTO,
-                            bxe_eth_q_stats_arr[j].string,
-                            CTLTYPE_U64 | CTLFLAG_RD, sc, q_stat,
-                            bxe_sysctl_eth_q_stat, "LU",
-                            bxe_eth_q_stats_arr[j].string);
+                 bxe_eth_q_stats_arr[j].string,
+                 CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, q_stat,
+                 bxe_sysctl_eth_q_stat, "LU", bxe_eth_q_stats_arr[j].string);
         }
     }
 }
diff --git a/sys/dev/cadence/if_cgem.c b/sys/dev/cadence/if_cgem.c
index e88486a3cb98..98aab2256170 100644
--- a/sys/dev/cadence/if_cgem.c
+++ b/sys/dev/cadence/if_cgem.c
@@ -1494,8 +1494,8 @@ cgem_add_sysctls(device_t dev)
 			&sc->txdefragfails, 0,
 			"Transmit m_defrag() failures");
 
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-			       NULL, "GEM statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "GEM statistics");
 	child = SYSCTL_CHILDREN(tree);
 
 	SYSCTL_ADD_UQUAD(ctx, child, OID_AUTO, "tx_bytes", CTLFLAG_RD,
diff --git a/sys/dev/cardbus/cardbus.c b/sys/dev/cardbus/cardbus.c
index 8f20a6c81fef..95a6316e9feb 100644
--- a/sys/dev/cardbus/cardbus.c
+++ b/sys/dev/cardbus/cardbus.c
@@ -57,7 +57,8 @@ __FBSDID("$FreeBSD$");
 #include "pcib_if.h"
 
 /* sysctl vars */
-static SYSCTL_NODE(_hw, OID_AUTO, cardbus, CTLFLAG_RD, 0, "CardBus parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, cardbus, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "CardBus parameters");
 
 int    cardbus_debug = 0;
 SYSCTL_INT(_hw_cardbus, OID_AUTO, debug, CTLFLAG_RWTUN,
diff --git a/sys/dev/coretemp/coretemp.c b/sys/dev/coretemp/coretemp.c
index e7063ff0aa77..bfbc49835c35 100644
--- a/sys/dev/coretemp/coretemp.c
+++ b/sys/dev/coretemp/coretemp.c
@@ -274,7 +274,8 @@ coretemp_attach(device_t dev)
 
 	oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(pdev)), OID_AUTO,
-	    "coretemp", CTLFLAG_RD, NULL, "Per-CPU thermal information");
+	    "coretemp", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+	    "Per-CPU thermal information");
 
 	/*
 	 * Add the MIBs to dev.cpu.N and dev.cpu.N.coretemp.
diff --git a/sys/dev/cxgb/cxgb_main.c b/sys/dev/cxgb/cxgb_main.c
index ffe2b680e12f..229c88089a51 100644
--- a/sys/dev/cxgb/cxgb_main.c
+++ b/sys/dev/cxgb/cxgb_main.c
@@ -238,7 +238,8 @@ static SLIST_HEAD(, uld_info) t3_uld_list;
  */
 static int msi_allowed = 2;
 
-SYSCTL_NODE(_hw, OID_AUTO, cxgb, CTLFLAG_RD, 0, "CXGB driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, cxgb, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "CXGB driver parameters");
 SYSCTL_INT(_hw_cxgb, OID_AUTO, msi_allowed, CTLFLAG_RDTUN, &msi_allowed, 0,
     "MSI-X, MSI, INTx selector");
 
diff --git a/sys/dev/cxgb/cxgb_sge.c b/sys/dev/cxgb/cxgb_sge.c
index 60876543bf7b..33900b67906c 100644
--- a/sys/dev/cxgb/cxgb_sge.c
+++ b/sys/dev/cxgb/cxgb_sge.c
@@ -3451,13 +3451,13 @@ t3_add_configured_sysctls(adapter_t *sc)
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
 	    "intr_coal",
-	    CTLTYPE_INT|CTLFLAG_RW, sc,
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc,
 	    0, t3_set_coalesce_usecs,
 	    "I", "interrupt coalescing timer (us)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
 	    "pkt_timestamp",
-	    CTLTYPE_INT | CTLFLAG_RW, sc,
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc,
 	    0, t3_pkt_timestamp,
 	    "I", "provide packet timestamp instead of connection hash");
 
@@ -3469,7 +3469,8 @@ t3_add_configured_sysctls(adapter_t *sc)
 		
 		snprintf(pi->namebuf, PORT_NAME_LEN, "port%d", i);
 		poid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, 
-		    pi->namebuf, CTLFLAG_RD, NULL, "port statistics");
+		    pi->namebuf, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+		    "port statistics");
 		poidlist = SYSCTL_CHILDREN(poid);
 		SYSCTL_ADD_UINT(ctx, poidlist, OID_AUTO,
 		    "nqsets", CTLFLAG_RD, &pi->nqsets,
@@ -3487,7 +3488,8 @@ t3_add_configured_sysctls(adapter_t *sc)
 			snprintf(qs->namebuf, QS_NAME_LEN, "qs%d", j);
 			
 			qspoid = SYSCTL_ADD_NODE(ctx, poidlist, OID_AUTO, 
-			    qs->namebuf, CTLFLAG_RD, NULL, "qset statistics");
+			    qs->namebuf, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+			    "qset statistics");
 			qspoidlist = SYSCTL_CHILDREN(qspoid);
 
 			SYSCTL_ADD_UINT(ctx, qspoidlist, OID_AUTO, "fl0_empty",
@@ -3498,19 +3500,23 @@ t3_add_configured_sysctls(adapter_t *sc)
 					"freelist #1 empty");
 
 			rspqpoid = SYSCTL_ADD_NODE(ctx, qspoidlist, OID_AUTO, 
-			    rspq_name, CTLFLAG_RD, NULL, "rspq statistics");
+			    rspq_name, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+			    "rspq statistics");
 			rspqpoidlist = SYSCTL_CHILDREN(rspqpoid);
 
 			txqpoid = SYSCTL_ADD_NODE(ctx, qspoidlist, OID_AUTO, 
-			    txq_names[0], CTLFLAG_RD, NULL, "txq statistics");
+			    txq_names[0], CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+			    "txq statistics");
 			txqpoidlist = SYSCTL_CHILDREN(txqpoid);
 
 			ctrlqpoid = SYSCTL_ADD_NODE(ctx, qspoidlist, OID_AUTO, 
-			    txq_names[2], CTLFLAG_RD, NULL, "ctrlq statistics");
+			    txq_names[2], CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+			    "ctrlq statistics");
 			ctrlqpoidlist = SYSCTL_CHILDREN(ctrlqpoid);
 
 			lropoid = SYSCTL_ADD_NODE(ctx, qspoidlist, OID_AUTO, 
-			    "lro_stats", CTLFLAG_RD, NULL, "LRO statistics");
+			    "lro_stats", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+			    "LRO statistics");
 			lropoidlist = SYSCTL_CHILDREN(lropoid);
 
 			SYSCTL_ADD_UINT(ctx, rspqpoidlist, OID_AUTO, "size",
@@ -3535,8 +3541,9 @@ t3_add_configured_sysctls(adapter_t *sc)
 			    CTLFLAG_RW, &qs->rspq.rspq_dump_count,
 			    0, "#rspq entries to dump");
 			SYSCTL_ADD_PROC(ctx, rspqpoidlist, OID_AUTO, "qdump",
-			    CTLTYPE_STRING | CTLFLAG_RD, &qs->rspq,
-			    0, t3_dump_rspq, "A", "dump of the response queue");
+			    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+			    &qs->rspq, 0, t3_dump_rspq, "A",
+			    "dump of the response queue");
 
 			SYSCTL_ADD_UQUAD(ctx, txqpoidlist, OID_AUTO, "dropped",
 			    CTLFLAG_RD, &qs->txq[TXQ_ETH].txq_mr->br_drops,
@@ -3595,8 +3602,9 @@ t3_add_configured_sysctls(adapter_t *sc)
 			    CTLFLAG_RW, &qs->txq[TXQ_ETH].txq_dump_count,
 			    0, "txq #entries to dump");			
 			SYSCTL_ADD_PROC(ctx, txqpoidlist, OID_AUTO, "qdump",
-			    CTLTYPE_STRING | CTLFLAG_RD, &qs->txq[TXQ_ETH],
-			    0, t3_dump_txq_eth, "A", "dump of the transmit queue");
+			    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+			    &qs->txq[TXQ_ETH], 0, t3_dump_txq_eth, "A",
+			    "dump of the transmit queue");
 
 			SYSCTL_ADD_UINT(ctx, ctrlqpoidlist, OID_AUTO, "dump_start",
 			    CTLFLAG_RW, &qs->txq[TXQ_CTRL].txq_dump_start,
@@ -3605,8 +3613,9 @@ t3_add_configured_sysctls(adapter_t *sc)
 			    CTLFLAG_RW, &qs->txq[TXQ_CTRL].txq_dump_count,
 			    0, "ctrl #entries to dump");			
 			SYSCTL_ADD_PROC(ctx, ctrlqpoidlist, OID_AUTO, "qdump",
-			    CTLTYPE_STRING | CTLFLAG_RD, &qs->txq[TXQ_CTRL],
-			    0, t3_dump_txq_ctrl, "A", "dump of the transmit queue");
+			    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+			    &qs->txq[TXQ_CTRL], 0, t3_dump_txq_ctrl, "A",
+			    "dump of the transmit queue");
 
 			SYSCTL_ADD_U64(ctx, lropoidlist, OID_AUTO, "lro_queued",
 			    CTLFLAG_RD, &qs->lro.ctrl.lro_queued, 0, NULL);
@@ -3620,7 +3629,7 @@ t3_add_configured_sysctls(adapter_t *sc)
 
 		/* Now add a node for mac stats. */
 		poid = SYSCTL_ADD_NODE(ctx, poidlist, OID_AUTO, "mac_stats",
-		    CTLFLAG_RD, NULL, "MAC statistics");
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "MAC statistics");
 		poidlist = SYSCTL_CHILDREN(poid);
 
 		/*
@@ -3636,8 +3645,8 @@ t3_add_configured_sysctls(adapter_t *sc)
 		 * all that here.
 		 */
 #define CXGB_SYSCTL_ADD_QUAD(a)	SYSCTL_ADD_OID(ctx, poidlist, OID_AUTO, #a, \
-    (CTLTYPE_U64 | CTLFLAG_RD), pi, offsetof(struct mac_stats, a), \
-    sysctl_handle_macstat, "QU", 0)
+    CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pi, \
+    offsetof(struct mac_stats, a), sysctl_handle_macstat, "QU", 0)
 		CXGB_SYSCTL_ADD_QUAD(tx_octets);
 		CXGB_SYSCTL_ADD_QUAD(tx_octets_bad);
 		CXGB_SYSCTL_ADD_QUAD(tx_frames);
diff --git a/sys/dev/cxgbe/crypto/t4_crypto.c b/sys/dev/cxgbe/crypto/t4_crypto.c
index 7ea23cb53cd8..5b924125b6e4 100644
--- a/sys/dev/cxgbe/crypto/t4_crypto.c
+++ b/sys/dev/cxgbe/crypto/t4_crypto.c
@@ -2082,8 +2082,8 @@ ccr_sysctls(struct ccr_softc *sc)
 	/*
 	 * dev.ccr.X.stats.
 	 */
-	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "statistics");
+	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "statistics");
 	children = SYSCTL_CHILDREN(oid);
 
 	SYSCTL_ADD_U64(ctx, children, OID_AUTO, "hash", CTLFLAG_RD,
diff --git a/sys/dev/cxgbe/cxgbei/cxgbei.c b/sys/dev/cxgbe/cxgbei/cxgbei.c
index 38bbf2f45bc8..d38cffa21fef 100644
--- a/sys/dev/cxgbe/cxgbei/cxgbei.c
+++ b/sys/dev/cxgbe/cxgbei/cxgbei.c
@@ -223,8 +223,8 @@ cxgbei_init(struct adapter *sc, struct cxgbei_data *ci)
 	oid = device_get_sysctl_tree(sc->dev);	/* dev.t5nex.X */
 	children = SYSCTL_CHILDREN(oid);
 
-	oid = SYSCTL_ADD_NODE(&ci->ctx, children, OID_AUTO, "iscsi", CTLFLAG_RD,
-	    NULL, "iSCSI ULP statistics");
+	oid = SYSCTL_ADD_NODE(&ci->ctx, children, OID_AUTO, "iscsi",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "iSCSI ULP statistics");
 	children = SYSCTL_CHILDREN(oid);
 
 	SYSCTL_ADD_COUNTER_U64(&ci->ctx, children, OID_AUTO, "ddp_setup_ok",
diff --git a/sys/dev/cxgbe/cxgbei/icl_cxgbei.c b/sys/dev/cxgbe/cxgbei/icl_cxgbei.c
index a17675b2dc76..2612a7b1e685 100644
--- a/sys/dev/cxgbe/cxgbei/icl_cxgbei.c
+++ b/sys/dev/cxgbe/cxgbei/icl_cxgbei.c
@@ -100,7 +100,8 @@ __FBSDID("$FreeBSD$");
 #include "tom/t4_tom.h"
 #include "cxgbei.h"
 
-SYSCTL_NODE(_kern_icl, OID_AUTO, cxgbei, CTLFLAG_RD, 0, "Chelsio iSCSI offload");
+SYSCTL_NODE(_kern_icl, OID_AUTO, cxgbei, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Chelsio iSCSI offload");
 static int coalesce = 1;
 SYSCTL_INT(_kern_icl_cxgbei, OID_AUTO, coalesce, CTLFLAG_RWTUN,
 	&coalesce, 0, "Try to coalesce PDUs before sending");
diff --git a/sys/dev/cxgbe/iw_cxgbe/cm.c b/sys/dev/cxgbe/iw_cxgbe/cm.c
index 4fa220e23896..48d7d18f5f33 100644
--- a/sys/dev/cxgbe/iw_cxgbe/cm.c
+++ b/sys/dev/cxgbe/iw_cxgbe/cm.c
@@ -1206,7 +1206,8 @@ process_socket_event(struct c4iw_ep *ep)
 
 }
 
-SYSCTL_NODE(_hw, OID_AUTO, iw_cxgbe, CTLFLAG_RD, 0, "iw_cxgbe driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, iw_cxgbe, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "iw_cxgbe driver parameters");
 
 static int dack_mode = 0;
 SYSCTL_INT(_hw_iw_cxgbe, OID_AUTO, dack_mode, CTLFLAG_RWTUN, &dack_mode, 0,
diff --git a/sys/dev/cxgbe/t4_main.c b/sys/dev/cxgbe/t4_main.c
index 49c8b5efb735..9b95e6f2a074 100644
--- a/sys/dev/cxgbe/t4_main.c
+++ b/sys/dev/cxgbe/t4_main.c
@@ -266,9 +266,12 @@ SLIST_HEAD(, uld_info) t4_uld_list;
  * Tunables applicable to both T4 and T5 are under hw.cxgbe.  Those specific to
  * T5 are under hw.cxl.
  */
-SYSCTL_NODE(_hw, OID_AUTO, cxgbe, CTLFLAG_RD, 0, "cxgbe(4) parameters");
-SYSCTL_NODE(_hw, OID_AUTO, cxl, CTLFLAG_RD, 0, "cxgbe(4) T5+ parameters");
-SYSCTL_NODE(_hw_cxgbe, OID_AUTO, toe, CTLFLAG_RD, 0, "cxgbe(4) TOE parameters");
+SYSCTL_NODE(_hw, OID_AUTO, cxgbe, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "cxgbe(4) parameters");
+SYSCTL_NODE(_hw, OID_AUTO, cxl, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "cxgbe(4) T5+ parameters");
+SYSCTL_NODE(_hw_cxgbe, OID_AUTO, toe, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "cxgbe(4) TOE parameters");
 
 /*
  * Number of queues for tx and rx, NIC and offload.
@@ -364,7 +367,8 @@ SYSCTL_INT(_hw_cxgbe_toe, OID_AUTO, rexmt_count, CTLFLAG_RDTUN,
 static int t4_toe_rexmt_backoff[16] = {
 	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 };
-SYSCTL_NODE(_hw_cxgbe_toe, OID_AUTO, rexmt_backoff, CTLFLAG_RD, 0,
+SYSCTL_NODE(_hw_cxgbe_toe, OID_AUTO, rexmt_backoff,
+    CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "cxgbe(4) TOE retransmit backoff values");
 SYSCTL_INT(_hw_cxgbe_toe_rexmt_backoff, OID_AUTO, 0, CTLFLAG_RDTUN,
     &t4_toe_rexmt_backoff[0], 0, "");
@@ -604,7 +608,7 @@ static int t4_kern_tls = 0;
 SYSCTL_INT(_hw_cxgbe, OID_AUTO, kern_tls, CTLFLAG_RDTUN, &t4_kern_tls, 0,
     "Enable KERN_TLS mode for all supported adapters");
 
-SYSCTL_NODE(_hw_cxgbe, OID_AUTO, tls, CTLFLAG_RD, 0,
+SYSCTL_NODE(_hw_cxgbe, OID_AUTO, tls, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "cxgbe(4) KERN_TLS parameters");
 
 static int t4_tls_inline_keys = 0;
@@ -6230,21 +6234,22 @@ t4_sysctls(struct adapter *sc)
 	    sc->params.nports, "# of ports");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "doorbells",
-	    CTLTYPE_STRING | CTLFLAG_RD, doorbells, (uintptr_t)&sc->doorbells,
-	    sysctl_bitfield_8b, "A", "available doorbells");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, doorbells,
+	    (uintptr_t)&sc->doorbells, sysctl_bitfield_8b, "A",
+	    "available doorbells");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "core_clock", CTLFLAG_RD, NULL,
 	    sc->params.vpd.cclk, "core clock frequency (in KHz)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_timers",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc->params.sge.timer_val,
-	    sizeof(sc->params.sge.timer_val), sysctl_int_array, "A",
-	    "interrupt holdoff timer values (us)");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	    sc->params.sge.timer_val, sizeof(sc->params.sge.timer_val),
+	    sysctl_int_array, "A", "interrupt holdoff timer values (us)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pkt_counts",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc->params.sge.counter_val,
-	    sizeof(sc->params.sge.counter_val), sysctl_int_array, "A",
-	    "interrupt holdoff packet counter values");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	    sc->params.sge.counter_val, sizeof(sc->params.sge.counter_val),
+	    sysctl_int_array, "A", "interrupt holdoff packet counter values");
 
 	t4_sge_sysctls(sc, ctx, children);
 
@@ -6302,8 +6307,9 @@ t4_sysctls(struct adapter *sc)
 
 #define SYSCTL_CAP(name, n, text) \
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, #name, \
-	    CTLTYPE_STRING | CTLFLAG_RD, caps_decoder[n], (uintptr_t)&sc->name, \
-	    sysctl_bitfield_16b, "A", "available " text " capabilities")
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, caps_decoder[n], \
+	    (uintptr_t)&sc->name, sysctl_bitfield_16b, "A", \
+	    "available " text " capabilities")
 
 	SYSCTL_CAP(nbmcaps, 0, "NBM");
 	SYSCTL_CAP(linkcaps, 1, "link");
@@ -6319,26 +6325,28 @@ t4_sysctls(struct adapter *sc)
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nfilters", CTLFLAG_RD,
 	    NULL, sc->tids.nftids, "number of filters");
 
-	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "temperature", CTLTYPE_INT |
-	    CTLFLAG_RD, sc, 0, sysctl_temperature, "I",
-	    "chip temperature (in Celsius)");
-	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "reset_sensor", CTLTYPE_INT |
-	    CTLFLAG_RW, sc, 0, sysctl_reset_sensor, "I",
-	    "reset the chip's temperature sensor.");
+	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "temperature",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    sysctl_temperature, "I", "chip temperature (in Celsius)");
+	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "reset_sensor",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    sysctl_reset_sensor, "I", "reset the chip's temperature sensor.");
 
-	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "loadavg", CTLTYPE_STRING |
-	    CTLFLAG_RD, sc, 0, sysctl_loadavg, "A",
+	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "loadavg",
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    sysctl_loadavg, "A",
 	    "microprocessor load averages (debug firmwares only)");
 
-	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "core_vdd", CTLTYPE_INT |
-	    CTLFLAG_RD, sc, 0, sysctl_vdd, "I", "core Vdd (in mV)");
+	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "core_vdd",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, sysctl_vdd,
+	    "I", "core Vdd (in mV)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "local_cpus",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, LOCAL_CPUS,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, LOCAL_CPUS,
 	    sysctl_cpus, "A", "local CPUs");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_cpus",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, INTR_CPUS,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, INTR_CPUS,
 	    sysctl_cpus, "A", "preferred CPUs for interrupts");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "swintr", CTLFLAG_RW,
@@ -6348,178 +6356,180 @@ t4_sysctls(struct adapter *sc)
 	 * dev.t4nex.X.misc.  Marked CTLFLAG_SKIP to avoid information overload.
 	 */
 	oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "misc",
-	    CTLFLAG_RD | CTLFLAG_SKIP, NULL,
+	    CTLFLAG_RD | CTLFLAG_SKIP | CTLFLAG_MPSAFE, NULL,
 	    "logs and miscellaneous information");
 	children = SYSCTL_CHILDREN(oid);
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cctrl",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_cctrl, "A", "congestion control");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_tp0",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 0 (TP0)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_tp1",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 1,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 1,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 1 (TP1)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_ulp",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 2,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 2,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 2 (ULP)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_sge0",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 3,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 3,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 3 (SGE0)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_sge1",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 4,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 4,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 4 (SGE1)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_ncsi",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 5,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 5,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 5 (NCSI)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_la",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0, sysctl_cim_la,
-	    "A", "CIM logic analyzer");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    sysctl_cim_la, "A", "CIM logic analyzer");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ma_la",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_cim_ma_la, "A", "CIM MA logic analyzer");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp0",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0 + CIM_NUM_IBQ,
-	    sysctl_cim_ibq_obq, "A", "CIM OBQ 0 (ULP0)");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+	    0 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 0 (ULP0)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp1",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 1 + CIM_NUM_IBQ,
-	    sysctl_cim_ibq_obq, "A", "CIM OBQ 1 (ULP1)");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+	    1 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 1 (ULP1)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp2",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 2 + CIM_NUM_IBQ,
-	    sysctl_cim_ibq_obq, "A", "CIM OBQ 2 (ULP2)");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+	    2 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 2 (ULP2)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp3",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 3 + CIM_NUM_IBQ,
-	    sysctl_cim_ibq_obq, "A", "CIM OBQ 3 (ULP3)");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+	    3 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 3 (ULP3)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 4 + CIM_NUM_IBQ,
-	    sysctl_cim_ibq_obq, "A", "CIM OBQ 4 (SGE)");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+	    4 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 4 (SGE)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ncsi",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 5 + CIM_NUM_IBQ,
-	    sysctl_cim_ibq_obq, "A", "CIM OBQ 5 (NCSI)");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+	    5 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 5 (NCSI)");
 
 	if (chip_id(sc) > CHELSIO_T4) {
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge0_rx",
-		    CTLTYPE_STRING | CTLFLAG_RD, sc, 6 + CIM_NUM_IBQ,
-		    sysctl_cim_ibq_obq, "A", "CIM OBQ 6 (SGE0-RX)");
+		    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    6 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A",
+		    "CIM OBQ 6 (SGE0-RX)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge1_rx",
-		    CTLTYPE_STRING | CTLFLAG_RD, sc, 7 + CIM_NUM_IBQ,
-		    sysctl_cim_ibq_obq, "A", "CIM OBQ 7 (SGE1-RX)");
+		    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    7 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A",
+		    "CIM OBQ 7 (SGE1-RX)");
 	}
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_pif_la",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_cim_pif_la, "A", "CIM PIF logic analyzer");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_qcfg",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_cim_qcfg, "A", "CIM queue configuration");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cpl_stats",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_cpl_stats, "A", "CPL statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "ddp_stats",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_ddp_stats, "A", "non-TCP DDP statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "devlog",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_devlog, "A", "firmware's device log");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fcoe_stats",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_fcoe_stats, "A", "FCoE statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "hw_sched",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_hw_sched, "A", "hardware scheduler ");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "l2t",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_l2t, "A", "hardware L2 table");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "smt",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_smt, "A", "hardware source MAC table");
 
 #ifdef INET6
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "clip",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_clip, "A", "active CLIP table entries");
 #endif
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "lb_stats",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_lb_stats, "A", "loopback statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "meminfo",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_meminfo, "A", "memory regions");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "mps_tcam",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    chip_id(sc) <= CHELSIO_T5 ? sysctl_mps_tcam : sysctl_mps_tcam_t6,
 	    "A", "MPS TCAM entries");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "path_mtus",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_path_mtus, "A", "path MTUs");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pm_stats",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_pm_stats, "A", "PM statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rdma_stats",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_rdma_stats, "A", "RDMA statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tcp_stats",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_tcp_stats, "A", "TCP statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tids",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_tids, "A", "TID information");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_err_stats",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_tp_err_stats, "A", "TP error statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_la_mask",
-	    CTLTYPE_INT | CTLFLAG_RW, sc, 0, sysctl_tp_la_mask, "I",
-	    "TP logic analyzer event capture mask");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    sysctl_tp_la_mask, "I", "TP logic analyzer event capture mask");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_la",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_tp_la, "A", "TP logic analyzer");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tx_rate",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_tx_rate, "A", "Tx rate");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "ulprx_la",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_ulprx_la, "A", "ULPRX logic analyzer");
 
 	if (chip_id(sc) >= CHELSIO_T5) {
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "wcwr_stats",
-		    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+		    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 		    sysctl_wcwr_stats, "A", "write combined work requests");
 	}
 
@@ -6528,8 +6538,8 @@ t4_sysctls(struct adapter *sc)
 		/*
 		 * dev.t4nex.0.tls.
 		 */
-		oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "tls", CTLFLAG_RD,
-		    NULL, "KERN_TLS parameters");
+		oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "tls",
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "KERN_TLS parameters");
 		children = SYSCTL_CHILDREN(oid);
 
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "inline_keys",
@@ -6550,8 +6560,8 @@ t4_sysctls(struct adapter *sc)
 		/*
 		 * dev.t4nex.X.toe.
 		 */
-		oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "toe", CTLFLAG_RD,
-		    NULL, "TOE parameters");
+		oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "toe",
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TOE parameters");
 		children = SYSCTL_CHILDREN(oid);
 
 		sc->tt.cong_algorithm = -1;
@@ -6579,8 +6589,9 @@ t4_sysctls(struct adapter *sc)
 		    &sc->tt.tls, 0, "Inline TLS allowed");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tls_rx_ports",
-		    CTLTYPE_INT | CTLFLAG_RW, sc, 0, sysctl_tls_rx_ports,
-		    "I", "TCP ports that use inline TLS+TOE RX");
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+		    sysctl_tls_rx_ports, "I",
+		    "TCP ports that use inline TLS+TOE RX");
 
 		sc->tt.tx_align = -1;
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "tx_align",
@@ -6603,76 +6614,85 @@ t4_sysctls(struct adapter *sc)
 		    "autorcvbuf increment");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "timer_tick",
-		    CTLTYPE_STRING | CTLFLAG_RD, sc, 0, sysctl_tp_tick, "A",
-		    "TP timer tick (us)");
+		    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+		    sysctl_tp_tick, "A", "TP timer tick (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "timestamp_tick",
-		    CTLTYPE_STRING | CTLFLAG_RD, sc, 1, sysctl_tp_tick, "A",
-		    "TCP timestamp tick (us)");
+		    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 1,
+		    sysctl_tp_tick, "A", "TCP timestamp tick (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "dack_tick",
-		    CTLTYPE_STRING | CTLFLAG_RD, sc, 2, sysctl_tp_tick, "A",
-		    "DACK tick (us)");
+		    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 2,
+		    sysctl_tp_tick, "A", "DACK tick (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "dack_timer",
-		    CTLTYPE_UINT | CTLFLAG_RD, sc, 0, sysctl_tp_dack_timer,
-		    "IU", "DACK timer (us)");
+		    CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+		    sysctl_tp_dack_timer, "IU", "DACK timer (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rexmt_min",
-		    CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_RXT_MIN,
-		    sysctl_tp_timer, "LU", "Minimum retransmit interval (us)");
+		    CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    A_TP_RXT_MIN, sysctl_tp_timer, "LU",
+		    "Minimum retransmit interval (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rexmt_max",
-		    CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_RXT_MAX,
-		    sysctl_tp_timer, "LU", "Maximum retransmit interval (us)");
+		    CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    A_TP_RXT_MAX, sysctl_tp_timer, "LU",
+		    "Maximum retransmit interval (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "persist_min",
-		    CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_PERS_MIN,
-		    sysctl_tp_timer, "LU", "Persist timer min (us)");
+		    CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    A_TP_PERS_MIN, sysctl_tp_timer, "LU",
+		    "Persist timer min (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "persist_max",
-		    CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_PERS_MAX,
-		    sysctl_tp_timer, "LU", "Persist timer max (us)");
+		    CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    A_TP_PERS_MAX, sysctl_tp_timer, "LU",
+		    "Persist timer max (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "keepalive_idle",
-		    CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_KEEP_IDLE,
-		    sysctl_tp_timer, "LU", "Keepalive idle timer (us)");
+		    CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    A_TP_KEEP_IDLE, sysctl_tp_timer, "LU",
+		    "Keepalive idle timer (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "keepalive_interval",
-		    CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_KEEP_INTVL,
-		    sysctl_tp_timer, "LU", "Keepalive interval timer (us)");
+		    CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    A_TP_KEEP_INTVL, sysctl_tp_timer, "LU",
+		    "Keepalive interval timer (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "initial_srtt",
-		    CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_INIT_SRTT,
-		    sysctl_tp_timer, "LU", "Initial SRTT (us)");
+		    CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    A_TP_INIT_SRTT, sysctl_tp_timer, "LU", "Initial SRTT (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "finwait2_timer",
-		    CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_FINWAIT2_TIMER,
-		    sysctl_tp_timer, "LU", "FINWAIT2 timer (us)");
+		    CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    A_TP_FINWAIT2_TIMER, sysctl_tp_timer, "LU",
+		    "FINWAIT2 timer (us)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "syn_rexmt_count",
-		    CTLTYPE_UINT | CTLFLAG_RD, sc, S_SYNSHIFTMAX,
-		    sysctl_tp_shift_cnt, "IU",
+		    CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    S_SYNSHIFTMAX, sysctl_tp_shift_cnt, "IU",
 		    "Number of SYN retransmissions before abort");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rexmt_count",
-		    CTLTYPE_UINT | CTLFLAG_RD, sc, S_RXTSHIFTMAXR2,
-		    sysctl_tp_shift_cnt, "IU",
+		    CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    S_RXTSHIFTMAXR2, sysctl_tp_shift_cnt, "IU",
 		    "Number of retransmissions before abort");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "keepalive_count",
-		    CTLTYPE_UINT | CTLFLAG_RD, sc, S_KEEPALIVEMAXR2,
-		    sysctl_tp_shift_cnt, "IU",
+		    CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    S_KEEPALIVEMAXR2, sysctl_tp_shift_cnt, "IU",
 		    "Number of keepalive probes before abort");
 
 		oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "rexmt_backoff",
-		    CTLFLAG_RD, NULL, "TOE retransmit backoffs");
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+		    "TOE retransmit backoffs");
 		children = SYSCTL_CHILDREN(oid);
 		for (i = 0; i < 16; i++) {
 			snprintf(s, sizeof(s), "%u", i);
 			SYSCTL_ADD_PROC(ctx, children, OID_AUTO, s,
-			    CTLTYPE_UINT | CTLFLAG_RD, sc, i, sysctl_tp_backoff,
-			    "IU", "TOE retransmit backoff");
+			    CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+			    i, sysctl_tp_backoff, "IU",
+			    "TOE retransmit backoff");
 		}
 	}
 #endif
@@ -6710,7 +6730,8 @@ vi_sysctls(struct vi_info *vi)
 
 	if (IS_MAIN_VI(vi)) {
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rsrv_noflowq",
-		    CTLTYPE_INT | CTLFLAG_RW, vi, 0, sysctl_noflowq, "IU",
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0,
+		    sysctl_noflowq, "IU",
 		    "Reserve queue 0 for non-flowid packets");
 	}
 
@@ -6723,11 +6744,11 @@ vi_sysctls(struct vi_info *vi)
 		    CTLFLAG_RD, &vi->first_ofld_rxq, 0,
 		    "index of first TOE rx queue");
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_tmr_idx_ofld",
-		    CTLTYPE_INT | CTLFLAG_RW, vi, 0,
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0,
 		    sysctl_holdoff_tmr_idx_ofld, "I",
 		    "holdoff timer index for TOE queues");
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pktc_idx_ofld",
-		    CTLTYPE_INT | CTLFLAG_RW, vi, 0,
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0,
 		    sysctl_holdoff_pktc_idx_ofld, "I",
 		    "holdoff packet counter index for TOE queues");
 	}
@@ -6758,18 +6779,18 @@ vi_sysctls(struct vi_info *vi)
 #endif
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_tmr_idx",
-	    CTLTYPE_INT | CTLFLAG_RW, vi, 0, sysctl_holdoff_tmr_idx, "I",
-	    "holdoff timer index");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0,
+	    sysctl_holdoff_tmr_idx, "I", "holdoff timer index");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pktc_idx",
-	    CTLTYPE_INT | CTLFLAG_RW, vi, 0, sysctl_holdoff_pktc_idx, "I",
-	    "holdoff packet counter index");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0,
+	    sysctl_holdoff_pktc_idx, "I", "holdoff packet counter index");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "qsize_rxq",
-	    CTLTYPE_INT | CTLFLAG_RW, vi, 0, sysctl_qsize_rxq, "I",
-	    "rx queue size");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0,
+	    sysctl_qsize_rxq, "I", "rx queue size");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "qsize_txq",
-	    CTLTYPE_INT | CTLFLAG_RW, vi, 0, sysctl_qsize_txq, "I",
-	    "tx queue size");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0,
+	    sysctl_qsize_txq, "I", "tx queue size");
 }
 
 static void
@@ -6791,28 +6812,32 @@ cxgbe_sysctls(struct port_info *pi)
 	oid = device_get_sysctl_tree(pi->dev);
 	children = SYSCTL_CHILDREN(oid);
 
-	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "linkdnrc", CTLTYPE_STRING |
-	   CTLFLAG_RD, pi, 0, sysctl_linkdnrc, "A", "reason why link is down");
+	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "linkdnrc",
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pi, 0,
+	    sysctl_linkdnrc, "A", "reason why link is down");
 	if (pi->port_type == FW_PORT_TYPE_BT_XAUI) {
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "temperature",
-		    CTLTYPE_INT | CTLFLAG_RD, pi, 0, sysctl_btphy, "I",
-		    "PHY temperature (in Celsius)");
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pi, 0,
+		    sysctl_btphy, "I", "PHY temperature (in Celsius)");
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fw_version",
-		    CTLTYPE_INT | CTLFLAG_RD, pi, 1, sysctl_btphy, "I",
-		    "PHY firmware version");
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pi, 1,
+		    sysctl_btphy, "I", "PHY firmware version");
 	}
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pause_settings",
-	    CTLTYPE_STRING | CTLFLAG_RW, pi, 0, sysctl_pause_settings, "A",
-    "PAUSE settings (bit 0 = rx_pause, 1 = tx_pause, 2 = pause_autoneg)");
+	    CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pi, 0,
+	    sysctl_pause_settings, "A",
+	    "PAUSE settings (bit 0 = rx_pause, 1 = tx_pause, 2 = pause_autoneg)");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fec",
-	    CTLTYPE_STRING | CTLFLAG_RW, pi, 0, sysctl_fec, "A",
+	    CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pi, 0,
+	    sysctl_fec, "A",
 	    "FECs to use (bit 0 = RS, 1 = FC, 2 = none, 5 = auto, 6 = module)");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "module_fec",
-	    CTLTYPE_STRING, pi, 0, sysctl_module_fec, "A",
+	    CTLTYPE_STRING | CTLFLAG_NEEDGIANT, pi, 0, sysctl_module_fec, "A",
 	    "FEC recommended by the cable/transceiver");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "autoneg",
-	    CTLTYPE_INT | CTLFLAG_RW, pi, 0, sysctl_autoneg, "I",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pi, 0,
+	    sysctl_autoneg, "I",
 	    "autonegotiation (-1 = not supported)");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "pcaps", CTLFLAG_RD,
@@ -6835,7 +6860,8 @@ cxgbe_sysctls(struct port_info *pi)
 	/*
 	 * dev.(cxgbe|cxl).X.tc.
 	 */
-	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "tc", CTLFLAG_RD, NULL,
+	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "tc",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
 	    "Tx scheduler traffic classes (cl_rl)");
 	children2 = SYSCTL_CHILDREN(oid);
 	SYSCTL_ADD_UINT(ctx, children2, OID_AUTO, "pktsize",
@@ -6849,32 +6875,33 @@ cxgbe_sysctls(struct port_info *pi)
 
 		snprintf(name, sizeof(name), "%d", i);
 		children2 = SYSCTL_CHILDREN(SYSCTL_ADD_NODE(ctx,
-		    SYSCTL_CHILDREN(oid), OID_AUTO, name, CTLFLAG_RD, NULL,
-		    "traffic class"));
+		    SYSCTL_CHILDREN(oid), OID_AUTO, name,
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "traffic class"));
 		SYSCTL_ADD_PROC(ctx, children2, OID_AUTO, "flags",
-		    CTLTYPE_STRING | CTLFLAG_RD, tc_flags, (uintptr_t)&tc->flags,
-		    sysctl_bitfield_8b, "A", "flags");
+		    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, tc_flags,
+		    (uintptr_t)&tc->flags, sysctl_bitfield_8b, "A", "flags");
 		SYSCTL_ADD_UINT(ctx, children2, OID_AUTO, "refcount",
 		    CTLFLAG_RD, &tc->refcount, 0, "references to this class");
 		SYSCTL_ADD_PROC(ctx, children2, OID_AUTO, "params",
-		    CTLTYPE_STRING | CTLFLAG_RD, sc, (pi->port_id << 16) | i,
-		    sysctl_tc_params, "A", "traffic class parameters");
+		    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    (pi->port_id << 16) | i, sysctl_tc_params, "A",
+		    "traffic class parameters");
 	}
 
 	/*
 	 * dev.cxgbe.X.stats.
 	 */
-	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "port statistics");
+	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "port statistics");
 	children = SYSCTL_CHILDREN(oid);
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "tx_parse_error", CTLFLAG_RD,
 	    &pi->tx_parse_error, 0,
 	    "# of tx packets with invalid length or # of segments");
 
 #define SYSCTL_ADD_T4_REG64(pi, name, desc, reg) \
-	SYSCTL_ADD_OID(ctx, children, OID_AUTO, name, \
-	    CTLTYPE_U64 | CTLFLAG_RD, sc, reg, \
-	    sysctl_handle_t4_reg64, "QU", desc)
+    SYSCTL_ADD_OID(ctx, children, OID_AUTO, name, \
+        CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, reg, \
+        sysctl_handle_t4_reg64, "QU", desc)
 
 	SYSCTL_ADD_T4_REG64(pi, "tx_octets", "# of octets in good frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_BYTES_L));
diff --git a/sys/dev/cxgbe/t4_sge.c b/sys/dev/cxgbe/t4_sge.c
index c5e967998f60..6852cecc62a5 100644
--- a/sys/dev/cxgbe/t4_sge.c
+++ b/sys/dev/cxgbe/t4_sge.c
@@ -935,8 +935,8 @@ t4_sge_sysctls(struct adapter *sc, struct sysctl_ctx_list *ctx,
 	struct sge_params *sp = &sc->params.sge;
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "buffer_sizes",
-	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0, sysctl_bufsizes, "A",
-	    "freelist buffer sizes");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    sysctl_bufsizes, "A", "freelist buffer sizes");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "fl_pktshift", CTLFLAG_RD,
 	    NULL, sp->fl_pktshift, "payload DMA offset in rx buffer (bytes)");
@@ -1006,7 +1006,7 @@ t4_setup_adapter_queues(struct adapter *sc)
 	 * Control queues, one per port.
 	 */
 	oid = SYSCTL_ADD_NODE(&sc->ctx, children, OID_AUTO, "ctrlq",
-	    CTLFLAG_RD, NULL, "control queues");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "control queues");
 	for_each_port(sc, i) {
 		struct sge_wrq *ctrlq = &sc->sge.ctrlq[i];
 
@@ -1094,7 +1094,7 @@ t4_setup_vi_queues(struct vi_info *vi)
 		 * doesn't set off any congestion signal in the chip.
 		 */
 		oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, "nm_rxq",
-		    CTLFLAG_RD, NULL, "rx queues");
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "rx queues");
 		for_each_nm_rxq(vi, i, nm_rxq) {
 			rc = alloc_nm_rxq(vi, nm_rxq, intr_idx, i, oid);
 			if (rc != 0)
@@ -1103,7 +1103,7 @@ t4_setup_vi_queues(struct vi_info *vi)
 		}
 
 		oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, "nm_txq",
-		    CTLFLAG_RD, NULL, "tx queues");
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "tx queues");
 		for_each_nm_txq(vi, i, nm_txq) {
 			iqidx = vi->first_nm_rxq + (i % vi->nnmrxq);
 			rc = alloc_nm_txq(vi, nm_txq, iqidx, i, oid);
@@ -1122,7 +1122,7 @@ t4_setup_vi_queues(struct vi_info *vi)
 	 */
 	maxp = mtu_to_max_payload(sc, mtu);
 	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, "rxq",
-	    CTLFLAG_RD, NULL, "rx queues");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "rx queues");
 	for_each_rxq(vi, i, rxq) {
 
 		init_iq(&rxq->iq, sc, vi->tmr_idx, vi->pktc_idx, vi->qsize_rxq);
@@ -1143,7 +1143,7 @@ t4_setup_vi_queues(struct vi_info *vi)
 #endif
 #ifdef TCP_OFFLOAD
 	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, "ofld_rxq",
-	    CTLFLAG_RD, NULL, "rx queues for offloaded TCP connections");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "rx queues for offloaded TCP connections");
 	for_each_ofld_rxq(vi, i, ofld_rxq) {
 
 		init_iq(&ofld_rxq->iq, sc, vi->ofld_tmr_idx, vi->ofld_pktc_idx,
@@ -1164,8 +1164,8 @@ t4_setup_vi_queues(struct vi_info *vi)
 	/*
 	 * Now the tx queues.
 	 */
-	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, "txq", CTLFLAG_RD,
-	    NULL, "tx queues");
+	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, "txq",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "tx queues");
 	for_each_txq(vi, i, txq) {
 		iqidx = vi->first_rxq + (i % vi->nrxq);
 		snprintf(name, sizeof(name), "%s txq%d",
@@ -1179,7 +1179,7 @@ t4_setup_vi_queues(struct vi_info *vi)
 	}
 #if defined(TCP_OFFLOAD) || defined(RATELIMIT)
 	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, "ofld_txq",
-	    CTLFLAG_RD, NULL, "tx queues for TOE/ETHOFLD");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "tx queues for TOE/ETHOFLD");
 	for_each_ofld_txq(vi, i, ofld_txq) {
 		struct sysctl_oid *oid2;
 
@@ -1198,7 +1198,7 @@ t4_setup_vi_queues(struct vi_info *vi)
 
 		snprintf(name, sizeof(name), "%d", i);
 		oid2 = SYSCTL_ADD_NODE(&vi->ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-		    name, CTLFLAG_RD, NULL, "offload tx queue");
+		    name, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "offload tx queue");
 
 		rc = alloc_wrq(sc, vi, ofld_txq, oid2);
 		if (rc != 0)
@@ -3381,14 +3381,14 @@ add_iq_sysctls(struct sysctl_ctx_list *ctx, struct sysctl_oid *oid,
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "dmalen", CTLFLAG_RD, NULL,
 	    iq->qsize * IQ_ESIZE, "descriptor ring size in bytes");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "abs_id",
-	    CTLTYPE_INT | CTLFLAG_RD, &iq->abs_id, 0, sysctl_uint16, "I",
-	    "absolute id of the queue");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &iq->abs_id, 0,
+	    sysctl_uint16, "I", "absolute id of the queue");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cntxt_id",
-	    CTLTYPE_INT | CTLFLAG_RD, &iq->cntxt_id, 0, sysctl_uint16, "I",
-	    "SGE context id of the queue");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &iq->cntxt_id, 0,
+	    sysctl_uint16, "I", "SGE context id of the queue");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cidx",
-	    CTLTYPE_INT | CTLFLAG_RD, &iq->cidx, 0, sysctl_uint16, "I",
-	    "consumer index");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &iq->cidx, 0,
+	    sysctl_uint16, "I", "consumer index");
 }
 
 static void
@@ -3397,8 +3397,8 @@ add_fl_sysctls(struct adapter *sc, struct sysctl_ctx_list *ctx,
 {
 	struct sysctl_oid_list *children = SYSCTL_CHILDREN(oid);
 
-	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "fl", CTLFLAG_RD, NULL,
-	    "freelist");
+	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "fl",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "freelist");
 	children = SYSCTL_CHILDREN(oid);
 
 	SYSCTL_ADD_UAUTO(ctx, children, OID_AUTO, "ba", CTLFLAG_RD,
@@ -3407,8 +3407,8 @@ add_fl_sysctls(struct adapter *sc, struct sysctl_ctx_list *ctx,
 	    fl->sidx * EQ_ESIZE + sc->params.sge.spg_len,
 	    "desc ring size in bytes");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cntxt_id",
-	    CTLTYPE_INT | CTLFLAG_RD, &fl->cntxt_id, 0, sysctl_uint16, "I",
-	    "SGE context id of the freelist");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &fl->cntxt_id, 0,
+	    sysctl_uint16, "I", "SGE context id of the freelist");
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "padding", CTLFLAG_RD, NULL,
 	    fl_pad ? 1 : 0, "padding enabled");
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "packing", CTLFLAG_RD, NULL,
@@ -3449,8 +3449,8 @@ alloc_fwq(struct adapter *sc)
 		return (rc);
 	}
 
-	oid = SYSCTL_ADD_NODE(&sc->ctx, children, OID_AUTO, "fwq", CTLFLAG_RD,
-	    NULL, "firmware event queue");
+	oid = SYSCTL_ADD_NODE(&sc->ctx, children, OID_AUTO, "fwq",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "firmware event queue");
 	add_iq_sysctls(&sc->ctx, oid, fwq);
 
 	return (0);
@@ -3477,8 +3477,8 @@ alloc_ctrlq(struct adapter *sc, struct sge_wrq *ctrlq, int idx,
 
 	children = SYSCTL_CHILDREN(oid);
 	snprintf(name, sizeof(name), "%d", idx);
-	oid = SYSCTL_ADD_NODE(&sc->ctx, children, OID_AUTO, name, CTLFLAG_RD,
-	    NULL, "ctrl queue");
+	oid = SYSCTL_ADD_NODE(&sc->ctx, children, OID_AUTO, name,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "ctrl queue");
 	rc = alloc_wrq(sc, NULL, ctrlq, oid);
 
 	return (rc);
@@ -3542,8 +3542,8 @@ alloc_rxq(struct vi_info *vi, struct sge_rxq *rxq, int intr_idx, int idx,
 	children = SYSCTL_CHILDREN(oid);
 
 	snprintf(name, sizeof(name), "%d", idx);
-	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, name, CTLFLAG_RD,
-	    NULL, "rx queue");
+	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, name,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "rx queue");
 	children = SYSCTL_CHILDREN(oid);
 
 	add_iq_sysctls(&vi->ctx, oid, &rxq->iq);
@@ -3600,8 +3600,8 @@ alloc_ofld_rxq(struct vi_info *vi, struct sge_ofld_rxq *ofld_rxq,
 	children = SYSCTL_CHILDREN(oid);
 
 	snprintf(name, sizeof(name), "%d", idx);
-	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, name, CTLFLAG_RD,
-	    NULL, "rx queue");
+	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, name,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "rx queue");
 	add_iq_sysctls(&vi->ctx, oid, &ofld_rxq->iq);
 	add_fl_sysctls(pi->adapter, &vi->ctx, oid, &ofld_rxq->fl);
 
@@ -3662,28 +3662,28 @@ alloc_nm_rxq(struct vi_info *vi, struct sge_nm_rxq *nm_rxq, int intr_idx,
 	children = SYSCTL_CHILDREN(oid);
 
 	snprintf(name, sizeof(name), "%d", idx);
-	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, name, CTLFLAG_RD, NULL,
-	    "rx queue");
+	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, name,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "rx queue");
 	children = SYSCTL_CHILDREN(oid);
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "abs_id",
-	    CTLTYPE_INT | CTLFLAG_RD, &nm_rxq->iq_abs_id, 0, sysctl_uint16,
-	    "I", "absolute id of the queue");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &nm_rxq->iq_abs_id,
+	    0, sysctl_uint16, "I", "absolute id of the queue");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cntxt_id",
-	    CTLTYPE_INT | CTLFLAG_RD, &nm_rxq->iq_cntxt_id, 0, sysctl_uint16,
-	    "I", "SGE context id of the queue");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &nm_rxq->iq_cntxt_id,
+	    0, sysctl_uint16, "I", "SGE context id of the queue");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cidx",
-	    CTLTYPE_INT | CTLFLAG_RD, &nm_rxq->iq_cidx, 0, sysctl_uint16, "I",
-	    "consumer index");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &nm_rxq->iq_cidx, 0,
+	    sysctl_uint16, "I", "consumer index");
 
 	children = SYSCTL_CHILDREN(oid);
-	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "fl", CTLFLAG_RD, NULL,
-	    "freelist");
+	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "fl",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "freelist");
 	children = SYSCTL_CHILDREN(oid);
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cntxt_id",
-	    CTLTYPE_INT | CTLFLAG_RD, &nm_rxq->fl_cntxt_id, 0, sysctl_uint16,
-	    "I", "SGE context id of the freelist");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &nm_rxq->fl_cntxt_id,
+	    0, sysctl_uint16, "I", "SGE context id of the freelist");
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "cidx", CTLFLAG_RD,
 	    &nm_rxq->fl_cidx, 0, "consumer index");
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "pidx", CTLFLAG_RD,
@@ -3743,18 +3743,18 @@ alloc_nm_txq(struct vi_info *vi, struct sge_nm_txq *nm_txq, int iqidx, int idx,
 	nm_txq->cntxt_id = INVALID_NM_TXQ_CNTXT_ID;
 
 	snprintf(name, sizeof(name), "%d", idx);
-	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, name, CTLFLAG_RD,
-	    NULL, "netmap tx queue");
+	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, name,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "netmap tx queue");
 	children = SYSCTL_CHILDREN(oid);
 
 	SYSCTL_ADD_UINT(&vi->ctx, children, OID_AUTO, "cntxt_id", CTLFLAG_RD,
 	    &nm_txq->cntxt_id, 0, "SGE context id of the queue");
 	SYSCTL_ADD_PROC(&vi->ctx, children, OID_AUTO, "cidx",
-	    CTLTYPE_INT | CTLFLAG_RD, &nm_txq->cidx, 0, sysctl_uint16, "I",
-	    "consumer index");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &nm_txq->cidx, 0,
+	    sysctl_uint16, "I", "consumer index");
 	SYSCTL_ADD_PROC(&vi->ctx, children, OID_AUTO, "pidx",
-	    CTLTYPE_INT | CTLFLAG_RD, &nm_txq->pidx, 0, sysctl_uint16, "I",
-	    "producer index");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &nm_txq->pidx, 0,
+	    sysctl_uint16, "I", "producer index");
 
 	return (rc);
 }
@@ -4071,11 +4071,11 @@ alloc_wrq(struct adapter *sc, struct vi_info *vi, struct sge_wrq *wrq,
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "cntxt_id", CTLFLAG_RD,
 	    &wrq->eq.cntxt_id, 0, "SGE context id of the queue");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cidx",
-	    CTLTYPE_INT | CTLFLAG_RD, &wrq->eq.cidx, 0, sysctl_uint16, "I",
-	    "consumer index");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &wrq->eq.cidx, 0,
+	    sysctl_uint16, "I", "consumer index");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pidx",
-	    CTLTYPE_INT | CTLFLAG_RD, &wrq->eq.pidx, 0, sysctl_uint16, "I",
-	    "producer index");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &wrq->eq.pidx, 0,
+	    sysctl_uint16, "I", "producer index");
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "sidx", CTLFLAG_RD, NULL,
 	    wrq->eq.sidx, "status page index");
 	SYSCTL_ADD_UQUAD(ctx, children, OID_AUTO, "tx_wrs_direct", CTLFLAG_RD,
@@ -4151,8 +4151,8 @@ alloc_txq(struct vi_info *vi, struct sge_txq *txq, int idx,
 	    M_ZERO | M_WAITOK);
 
 	snprintf(name, sizeof(name), "%d", idx);
-	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, name, CTLFLAG_RD,
-	    NULL, "tx queue");
+	oid = SYSCTL_ADD_NODE(&vi->ctx, children, OID_AUTO, name,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "tx queue");
 	children = SYSCTL_CHILDREN(oid);
 
 	SYSCTL_ADD_UAUTO(&vi->ctx, children, OID_AUTO, "ba", CTLFLAG_RD,
@@ -4165,17 +4165,17 @@ alloc_txq(struct vi_info *vi, struct sge_txq *txq, int idx,
 	SYSCTL_ADD_UINT(&vi->ctx, children, OID_AUTO, "cntxt_id", CTLFLAG_RD,
 	    &eq->cntxt_id, 0, "SGE context id of the queue");
 	SYSCTL_ADD_PROC(&vi->ctx, children, OID_AUTO, "cidx",
-	    CTLTYPE_INT | CTLFLAG_RD, &eq->cidx, 0, sysctl_uint16, "I",
-	    "consumer index");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &eq->cidx, 0,
+	    sysctl_uint16, "I", "consumer index");
 	SYSCTL_ADD_PROC(&vi->ctx, children, OID_AUTO, "pidx",
-	    CTLTYPE_INT | CTLFLAG_RD, &eq->pidx, 0, sysctl_uint16, "I",
-	    "producer index");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, &eq->pidx, 0,
+	    sysctl_uint16, "I", "producer index");
 	SYSCTL_ADD_INT(&vi->ctx, children, OID_AUTO, "sidx", CTLFLAG_RD, NULL,
 	    eq->sidx, "status page index");
 
 	SYSCTL_ADD_PROC(&vi->ctx, children, OID_AUTO, "tc",
-	    CTLTYPE_INT | CTLFLAG_RW, vi, idx, sysctl_tc, "I",
-	    "traffic class (-1 means none)");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, idx, sysctl_tc,
+	    "I", "traffic class (-1 means none)");
 
 	SYSCTL_ADD_UQUAD(&vi->ctx, children, OID_AUTO, "txcsum", CTLFLAG_RD,
 	    &txq->txcsum, "# of times hardware assisted with checksum");
diff --git a/sys/dev/dcons/dcons_os.c b/sys/dev/dcons/dcons_os.c
index 97a00760d031..1a5585598065 100644
--- a/sys/dev/dcons/dcons_os.c
+++ b/sys/dev/dcons/dcons_os.c
@@ -102,7 +102,8 @@ static u_int poll_idle = DCONS_POLL_HZ * DCONS_POLL_IDLE;
 
 static struct dcons_softc sc[DCONS_NPORT];
 
-static SYSCTL_NODE(_kern, OID_AUTO, dcons, CTLFLAG_RD, 0, "Dumb Console");
+static SYSCTL_NODE(_kern, OID_AUTO, dcons, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Dumb Console");
 SYSCTL_INT(_kern_dcons, OID_AUTO, poll_hz, CTLFLAG_RW, &poll_hz, 0,
 				"dcons polling rate");
 
diff --git a/sys/dev/efidev/efirt.c b/sys/dev/efidev/efirt.c
index 2f7f5187b8fc..df1f62f39126 100644
--- a/sys/dev/efidev/efirt.c
+++ b/sys/dev/efidev/efirt.c
@@ -109,7 +109,8 @@ efi_status_to_errno(efi_status status)
 }
 
 static struct mtx efi_lock;
-static SYSCTL_NODE(_hw, OID_AUTO, efi, CTLFLAG_RWTUN, NULL, "EFI");
+static SYSCTL_NODE(_hw, OID_AUTO, efi, CTLFLAG_RWTUN | CTLFLAG_MPSAFE, NULL,
+    "EFI");
 static bool efi_poweroff = true;
 SYSCTL_BOOL(_hw_efi, OID_AUTO, poweroff, CTLFLAG_RWTUN, &efi_poweroff, 0,
     "If true, use EFI runtime services to power off in preference to ACPI");
diff --git a/sys/dev/ena/ena_sysctl.c b/sys/dev/ena/ena_sysctl.c
index 97c8007deea4..0272837027c2 100644
--- a/sys/dev/ena/ena_sysctl.c
+++ b/sys/dev/ena/ena_sysctl.c
@@ -38,7 +38,8 @@ static void	ena_sysctl_add_tuneables(struct ena_adapter *);
 static int	ena_sysctl_buf_ring_size(SYSCTL_HANDLER_ARGS);
 static int	ena_sysctl_rx_queue_size(SYSCTL_HANDLER_ARGS);
 
-static SYSCTL_NODE(_hw, OID_AUTO, ena, CTLFLAG_RD, 0, "ENA driver parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, ena, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "ENA driver parameters");
 
 /*
  * Logging level for changing verbosity of the output
@@ -150,12 +151,12 @@ ena_sysctl_add_stats(struct ena_adapter *adapter)
 		snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
 
 		queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO,
-		    namebuf, CTLFLAG_RD, NULL, "Queue Name");
+		    namebuf, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue Name");
 		queue_list = SYSCTL_CHILDREN(queue_node);
 
 		/* TX specific stats */
 		tx_node = SYSCTL_ADD_NODE(ctx, queue_list, OID_AUTO,
-		    "tx_ring", CTLFLAG_RD, NULL, "TX ring");
+		    "tx_ring", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX ring");
 		tx_list = SYSCTL_CHILDREN(tx_node);
 
 		tx_stats = &tx_ring->tx_stats;
@@ -203,7 +204,7 @@ ena_sysctl_add_stats(struct ena_adapter *adapter)
 
 		/* RX specific stats */
 		rx_node = SYSCTL_ADD_NODE(ctx, queue_list, OID_AUTO,
-		    "rx_ring", CTLFLAG_RD, NULL, "RX ring");
+		    "rx_ring", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX ring");
 		rx_list = SYSCTL_CHILDREN(rx_node);
 
 		rx_stats = &rx_ring->rx_stats;
@@ -242,7 +243,7 @@ ena_sysctl_add_stats(struct ena_adapter *adapter)
 
 	/* Stats read from device */
 	hw_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "hw_stats",
-	    CTLFLAG_RD, NULL, "Statistics from hardware");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Statistics from hardware");
 	hw_list = SYSCTL_CHILDREN(hw_node);
 
 	SYSCTL_ADD_COUNTER_U64(ctx, hw_list, OID_AUTO, "rx_packets", CTLFLAG_RD,
@@ -258,7 +259,7 @@ ena_sysctl_add_stats(struct ena_adapter *adapter)
 
 	/* ENA Admin queue stats */
 	admin_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "admin_stats",
-	    CTLFLAG_RD, NULL, "ENA Admin Queue statistics");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "ENA Admin Queue statistics");
 	admin_list = SYSCTL_CHILDREN(admin_node);
 
 	SYSCTL_ADD_U32(ctx, admin_list, OID_AUTO, "aborted_cmd", CTLFLAG_RD,
@@ -289,15 +290,15 @@ ena_sysctl_add_tuneables(struct ena_adapter *adapter)
 	child = SYSCTL_CHILDREN(tree);
 
 	/* Tuneable number of buffers in the buf-ring (drbr) */
-	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "buf_ring_size", CTLTYPE_INT |
-	    CTLFLAG_RW, adapter, 0, ena_sysctl_buf_ring_size, "I",
-	    "Size of the bufring");
+	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "buf_ring_size",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, adapter, 0,
+	    ena_sysctl_buf_ring_size, "I", "Size of the bufring");
 
 	/* Tuneable number of Rx ring size */
-	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rx_queue_size", CTLTYPE_INT |
-	    CTLFLAG_RW, adapter, 0, ena_sysctl_rx_queue_size, "I",
-	    "Size of the Rx ring. The size should be a power of 2. "
-	    "Max value is 8K");
+	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rx_queue_size",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, adapter, 0,
+	    ena_sysctl_rx_queue_size, "I", "Size of the Rx ring. "
+	    "The size should be a power of 2. Max value is 8K");
 }
 
 
diff --git a/sys/dev/et/if_et.c b/sys/dev/et/if_et.c
index f8d29bf9f997..99865142bf37 100644
--- a/sys/dev/et/if_et.c
+++ b/sys/dev/et/if_et.c
@@ -2450,10 +2450,11 @@ et_add_sysctls(struct et_softc * sc)
 	children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rx_intr_npkts",
-	    CTLTYPE_INT | CTLFLAG_RW, sc, 0, et_sysctl_rx_intr_npkts, "I",
-	    "RX IM, # packets per RX interrupt");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    et_sysctl_rx_intr_npkts, "I", "RX IM, # packets per RX interrupt");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rx_intr_delay",
-	    CTLTYPE_INT | CTLFLAG_RW, sc, 0, et_sysctl_rx_intr_delay, "I",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    et_sysctl_rx_intr_delay, "I",
 	    "RX IM, RX interrupt delay (x10 usec)");
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "tx_intr_nsegs",
 	    CTLFLAG_RW, &sc->sc_tx_intr_nsegs, 0,
@@ -2461,8 +2462,8 @@ et_add_sysctls(struct et_softc * sc)
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "timer",
 	    CTLFLAG_RW, &sc->sc_timer, 0, "TX timer");
 
-	tree = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "ET statistics");
+	tree = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "ET statistics");
         parent = SYSCTL_CHILDREN(tree);
 
 	/* TX/RX statistics. */
@@ -2483,8 +2484,8 @@ et_add_sysctls(struct et_softc * sc)
 	    "1519 to 1522 bytes frames");
 
 	/* RX statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "RX MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX MAC statistics");
 	children = SYSCTL_CHILDREN(tree);
 	ET_SYSCTL_STAT_ADD64(ctx, children, "bytes",
 	    &stats->rx_bytes, "Good bytes");
@@ -2522,8 +2523,8 @@ et_add_sysctls(struct et_softc * sc)
 	    &stats->rx_drop, "Dropped frames");
 
 	/* TX statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "TX MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX MAC statistics");
 	children = SYSCTL_CHILDREN(tree);
 	ET_SYSCTL_STAT_ADD64(ctx, children, "bytes",
 	    &stats->tx_bytes, "Good bytes");
diff --git a/sys/dev/etherswitch/mtkswitch/mtkswitch.c b/sys/dev/etherswitch/mtkswitch/mtkswitch.c
index d3a6efa487ca..81df2ec82012 100644
--- a/sys/dev/etherswitch/mtkswitch/mtkswitch.c
+++ b/sys/dev/etherswitch/mtkswitch/mtkswitch.c
@@ -64,7 +64,8 @@
 #define DEBUG
 
 #if defined(DEBUG)
-static SYSCTL_NODE(_debug, OID_AUTO, mtkswitch, CTLFLAG_RD, 0, "mtkswitch");
+static SYSCTL_NODE(_debug, OID_AUTO, mtkswitch, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "mtkswitch");
 #endif
 
 static inline int mtkswitch_portforphy(int phy);
diff --git a/sys/dev/etherswitch/rtl8366/rtl8366rb.c b/sys/dev/etherswitch/rtl8366/rtl8366rb.c
index 279c33bcaf4a..de35e2dc62ba 100644
--- a/sys/dev/etherswitch/rtl8366/rtl8366rb.c
+++ b/sys/dev/etherswitch/rtl8366/rtl8366rb.c
@@ -107,7 +107,8 @@ struct rtl8366rb_softc {
 static int callout_blocked = 0;
 static int iic_select_retries = 0;
 static int phy_access_retries = 0;
-static SYSCTL_NODE(_debug, OID_AUTO, rtl8366rb, CTLFLAG_RD, 0, "rtl8366rb");
+static SYSCTL_NODE(_debug, OID_AUTO, rtl8366rb, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "rtl8366rb");
 SYSCTL_INT(_debug_rtl8366rb, OID_AUTO, callout_blocked, CTLFLAG_RW, &callout_blocked, 0,
 	"number of times the callout couldn't acquire the bus");
 SYSCTL_INT(_debug_rtl8366rb, OID_AUTO, iic_select_retries, CTLFLAG_RW, &iic_select_retries, 0,
diff --git a/sys/dev/evdev/evdev.c b/sys/dev/evdev/evdev.c
index c3ebabc7144d..4a79e7276d00 100644
--- a/sys/dev/evdev/evdev.c
+++ b/sys/dev/evdev/evdev.c
@@ -69,7 +69,8 @@ MALLOC_DEFINE(M_EVDEV, "evdev", "evdev memory");
 int evdev_rcpt_mask = EVDEV_RCPT_SYSMOUSE | EVDEV_RCPT_KBDMUX;
 int evdev_sysmouse_t_axis = 0;
 
-SYSCTL_NODE(_kern, OID_AUTO, evdev, CTLFLAG_RW, 0, "Evdev args");
+SYSCTL_NODE(_kern, OID_AUTO, evdev, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "Evdev args");
 #ifdef EVDEV_SUPPORT
 SYSCTL_INT(_kern_evdev, OID_AUTO, rcpt_mask, CTLFLAG_RW, &evdev_rcpt_mask, 0,
     "Who is receiving events: bit0 - sysmouse, bit1 - kbdmux, "
@@ -77,7 +78,7 @@ SYSCTL_INT(_kern_evdev, OID_AUTO, rcpt_mask, CTLFLAG_RW, &evdev_rcpt_mask, 0,
 SYSCTL_INT(_kern_evdev, OID_AUTO, sysmouse_t_axis, CTLFLAG_RW,
     &evdev_sysmouse_t_axis, 0, "Extract T-axis from 0-none, 1-ums, 2-psm");
 #endif
-SYSCTL_NODE(_kern_evdev, OID_AUTO, input, CTLFLAG_RD, 0,
+SYSCTL_NODE(_kern_evdev, OID_AUTO, input, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "Evdev input devices");
 
 static void evdev_start_repeat(struct evdev_dev *, uint16_t);
@@ -209,7 +210,8 @@ evdev_sysctl_create(struct evdev_dev *evdev)
 
 	ev_sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&evdev->ev_sysctl_ctx,
 	    SYSCTL_STATIC_CHILDREN(_kern_evdev_input), OID_AUTO,
-	    ev_unit_str, CTLFLAG_RD, NULL, "", "device index");
+	    ev_unit_str, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "",
+	    "device index");
 
 	SYSCTL_ADD_STRING(&evdev->ev_sysctl_ctx,
 	    SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "name", CTLFLAG_RD,
diff --git a/sys/dev/extres/clk/clk.c b/sys/dev/extres/clk/clk.c
index 9c70f01b10a6..a6c8cdcd9863 100644
--- a/sys/dev/extres/clk/clk.c
+++ b/sys/dev/extres/clk/clk.c
@@ -50,7 +50,8 @@ __FBSDID("$FreeBSD$");
 #endif
 #include <dev/extres/clk/clk.h>
 
-SYSCTL_NODE(_hw, OID_AUTO, clock, CTLFLAG_RD, NULL, "Clocks");
+SYSCTL_NODE(_hw, OID_AUTO, clock, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+    "Clocks");
 
 MALLOC_DEFINE(M_CLOCK, "clocks", "Clock framework");
 
@@ -400,12 +401,11 @@ clkdom_create(device_t dev)
 #endif
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-	  SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-	  OID_AUTO, "clocks",
-	  CTLTYPE_STRING | CTLFLAG_RD,
-		    clkdom, 0, clkdom_sysctl,
-		    "A",
-		    "Clock list for the domain");
+	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
+	    OID_AUTO, "clocks",
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	    clkdom, 0, clkdom_sysctl, "A",
+	    "Clock list for the domain");
 
 	return (clkdom);
 }
@@ -630,7 +630,7 @@ clknode_create(struct clkdom * clkdom, clknode_class_t clknode_class,
 	clknode_oid = SYSCTL_ADD_NODE(&clknode->sysctl_ctx,
 	    SYSCTL_STATIC_CHILDREN(_hw_clock),
 	    OID_AUTO, clknode->name,
-	    CTLFLAG_RD, 0, "A clock node");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "A clock node");
 
 	SYSCTL_ADD_U64(&clknode->sysctl_ctx,
 	    SYSCTL_CHILDREN(clknode_oid),
@@ -639,21 +639,21 @@ clknode_create(struct clkdom * clkdom, clknode_class_t clknode_class,
 	SYSCTL_ADD_PROC(&clknode->sysctl_ctx,
 	    SYSCTL_CHILDREN(clknode_oid),
 	    OID_AUTO, "parent",
-	    CTLTYPE_STRING | CTLFLAG_RD,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    clknode, CLKNODE_SYSCTL_PARENT, clknode_sysctl,
 	    "A",
 	    "The clock parent");
 	SYSCTL_ADD_PROC(&clknode->sysctl_ctx,
 	    SYSCTL_CHILDREN(clknode_oid),
 	    OID_AUTO, "parents",
-	    CTLTYPE_STRING | CTLFLAG_RD,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    clknode, CLKNODE_SYSCTL_PARENTS_LIST, clknode_sysctl,
 	    "A",
 	    "The clock parents list");
 	SYSCTL_ADD_PROC(&clknode->sysctl_ctx,
 	    SYSCTL_CHILDREN(clknode_oid),
 	    OID_AUTO, "childrens",
-	    CTLTYPE_STRING | CTLFLAG_RD,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    clknode, CLKNODE_SYSCTL_CHILDREN_LIST, clknode_sysctl,
 	    "A",
 	    "The clock childrens list");
diff --git a/sys/dev/extres/regulator/regulator.c b/sys/dev/extres/regulator/regulator.c
index 7d74df2ada43..63b7d116f416 100644
--- a/sys/dev/extres/regulator/regulator.c
+++ b/sys/dev/extres/regulator/regulator.c
@@ -51,7 +51,8 @@ __FBSDID("$FreeBSD$");
 
 #include "regdev_if.h"
 
-SYSCTL_NODE(_hw, OID_AUTO, regulator, CTLFLAG_RD, NULL, "Regulators");
+SYSCTL_NODE(_hw, OID_AUTO, regulator, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+    "Regulators");
 
 MALLOC_DEFINE(M_REGULATOR, "regulator", "Regulator framework");
 
@@ -402,7 +403,7 @@ regnode_create(device_t pdev, regnode_class_t regnode_class,
 	regnode_oid = SYSCTL_ADD_NODE(&regnode->sysctl_ctx,
 	    SYSCTL_STATIC_CHILDREN(_hw_regulator),
 	    OID_AUTO, regnode->name,
-	    CTLFLAG_RD, 0, "A regulator node");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "A regulator node");
 
 	SYSCTL_ADD_INT(&regnode->sysctl_ctx,
 	    SYSCTL_CHILDREN(regnode_oid),
@@ -453,7 +454,7 @@ regnode_create(device_t pdev, regnode_class_t regnode_class,
 	SYSCTL_ADD_PROC(&regnode->sysctl_ctx,
 	    SYSCTL_CHILDREN(regnode_oid),
 	    OID_AUTO, "uvolt",
-	    CTLTYPE_INT | CTLFLAG_RD,
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    regnode, 0, regnode_uvolt_sysctl,
 	    "I",
 	    "Current voltage (in uV)");
diff --git a/sys/dev/fb/vesa.c b/sys/dev/fb/vesa.c
index ac981cad34ce..f1d75873f983 100644
--- a/sys/dev/fb/vesa.c
+++ b/sys/dev/fb/vesa.c
@@ -102,7 +102,8 @@ static size_t vesa_bios_size;
 /* VESA video adapter */
 static video_adapter_t *vesa_adp;
 
-static SYSCTL_NODE(_debug, OID_AUTO, vesa, CTLFLAG_RD, NULL, "VESA debugging");
+static SYSCTL_NODE(_debug, OID_AUTO, vesa, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+    "VESA debugging");
 static int vesa_shadow_rom;
 SYSCTL_INT(_debug_vesa, OID_AUTO, shadow_rom, CTLFLAG_RDTUN, &vesa_shadow_rom,
     0, "Enable video BIOS shadow");
diff --git a/sys/dev/fdc/fdc.c b/sys/dev/fdc/fdc.c
index ab938725c089..424ae339536b 100644
--- a/sys/dev/fdc/fdc.c
+++ b/sys/dev/fdc/fdc.c
@@ -270,7 +270,8 @@ static driver_filter_t fdc_intr_fast;
 static void fdc_reset(struct fdc_data *);
 static int fd_probe_disk(struct fd_data *, int *);
 
-static SYSCTL_NODE(_debug, OID_AUTO, fdc, CTLFLAG_RW, 0, "fdc driver");
+static SYSCTL_NODE(_debug, OID_AUTO, fdc, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "fdc driver");
 
 static int fifo_threshold = 8;
 SYSCTL_INT(_debug_fdc, OID_AUTO, fifo, CTLFLAG_RW, &fifo_threshold, 0,
diff --git a/sys/dev/fdt/fdt_common.c b/sys/dev/fdt/fdt_common.c
index 415a7834d605..107c91e11425 100644
--- a/sys/dev/fdt/fdt_common.c
+++ b/sys/dev/fdt/fdt_common.c
@@ -63,7 +63,8 @@ __FBSDID("$FreeBSD$");
 #define FDT_REG_CELLS	4
 #define FDT_RANGES_SIZE 48
 
-SYSCTL_NODE(_hw, OID_AUTO, fdt, CTLFLAG_RD, 0, "Flattened Device Tree");
+SYSCTL_NODE(_hw, OID_AUTO, fdt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Flattened Device Tree");
 
 vm_paddr_t fdt_immr_pa;
 vm_offset_t fdt_immr_va;
diff --git a/sys/dev/firewire/firewire.c b/sys/dev/firewire/firewire.c
index 5e8cb3b83273..bf197406a767 100644
--- a/sys/dev/firewire/firewire.c
+++ b/sys/dev/firewire/firewire.c
@@ -68,7 +68,8 @@ struct crom_src_buf {
 int firewire_debug = 0, try_bmr = 1, hold_count = 0;
 SYSCTL_INT(_debug, OID_AUTO, firewire_debug, CTLFLAG_RW, &firewire_debug, 0,
 	"FireWire driver debug flag");
-SYSCTL_NODE(_hw, OID_AUTO, firewire, CTLFLAG_RD, 0, "FireWire Subsystem");
+SYSCTL_NODE(_hw, OID_AUTO, firewire, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "FireWire Subsystem");
 SYSCTL_INT(_hw_firewire, OID_AUTO, try_bmr, CTLFLAG_RW, &try_bmr, 0,
 	"Try to be a bus manager");
 SYSCTL_INT(_hw_firewire, OID_AUTO, hold_count, CTLFLAG_RW, &hold_count, 0,
diff --git a/sys/dev/firewire/fwmem.c b/sys/dev/firewire/fwmem.c
index 2faa4d3d3618..f2d947bcc5cd 100644
--- a/sys/dev/firewire/fwmem.c
+++ b/sys/dev/firewire/fwmem.c
@@ -65,8 +65,9 @@ __FBSDID("$FreeBSD$");
 static int fwmem_speed = 2, fwmem_debug = 0;
 static struct fw_eui64 fwmem_eui64;
 SYSCTL_DECL(_hw_firewire);
-static SYSCTL_NODE(_hw_firewire, OID_AUTO, fwmem, CTLFLAG_RD, 0,
-	"FireWire Memory Access");
+static SYSCTL_NODE(_hw_firewire, OID_AUTO, fwmem,
+    CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "FireWire Memory Access");
 SYSCTL_UINT(_hw_firewire_fwmem, OID_AUTO, eui64_hi, CTLFLAG_RW,
 	&fwmem_eui64.hi, 0, "Fwmem target EUI64 high");
 SYSCTL_UINT(_hw_firewire_fwmem, OID_AUTO, eui64_lo, CTLFLAG_RW,
diff --git a/sys/dev/firewire/if_fwe.c b/sys/dev/firewire/if_fwe.c
index cf9996475415..35d1a41fad6f 100644
--- a/sys/dev/firewire/if_fwe.c
+++ b/sys/dev/firewire/if_fwe.c
@@ -85,8 +85,8 @@ static int rx_queue_len = FWMAXQUEUE;
 static MALLOC_DEFINE(M_FWE, "if_fwe", "Ethernet over FireWire interface");
 SYSCTL_INT(_debug, OID_AUTO, if_fwe_debug, CTLFLAG_RWTUN, &fwedebug, 0, "");
 SYSCTL_DECL(_hw_firewire);
-static SYSCTL_NODE(_hw_firewire, OID_AUTO, fwe, CTLFLAG_RD, 0,
-	"Ethernet emulation subsystem");
+static SYSCTL_NODE(_hw_firewire, OID_AUTO, fwe, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Ethernet emulation subsystem");
 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, stream_ch, CTLFLAG_RWTUN, &stream_ch, 0,
 	"Stream channel to use");
 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, tx_speed, CTLFLAG_RWTUN, &tx_speed, 0,
diff --git a/sys/dev/firewire/if_fwip.c b/sys/dev/firewire/if_fwip.c
index 6d2b3fb59221..46cd56e30748 100644
--- a/sys/dev/firewire/if_fwip.c
+++ b/sys/dev/firewire/if_fwip.c
@@ -99,7 +99,7 @@ static int rx_queue_len = FWMAXQUEUE;
 static MALLOC_DEFINE(M_FWIP, "if_fwip", "IP over FireWire interface");
 SYSCTL_INT(_debug, OID_AUTO, if_fwip_debug, CTLFLAG_RW, &fwipdebug, 0, "");
 SYSCTL_DECL(_hw_firewire);
-static SYSCTL_NODE(_hw_firewire, OID_AUTO, fwip, CTLFLAG_RD, 0,
+static SYSCTL_NODE(_hw_firewire, OID_AUTO, fwip, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
 	"Firewire ip subsystem");
 SYSCTL_INT(_hw_firewire_fwip, OID_AUTO, rx_queue_len, CTLFLAG_RWTUN, &rx_queue_len,
 	0, "Length of the receive queue");
diff --git a/sys/dev/firewire/sbp.c b/sys/dev/firewire/sbp.c
index 38e44193cf58..04e454d6c66e 100644
--- a/sys/dev/firewire/sbp.c
+++ b/sys/dev/firewire/sbp.c
@@ -112,8 +112,8 @@ static int use_doorbell = 0;
 static int sbp_tags = 0;
 
 SYSCTL_DECL(_hw_firewire);
-static SYSCTL_NODE(_hw_firewire, OID_AUTO, sbp, CTLFLAG_RD, 0,
-	"SBP-II Subsystem");
+static SYSCTL_NODE(_hw_firewire, OID_AUTO, sbp, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "SBP-II Subsystem");
 SYSCTL_INT(_debug, OID_AUTO, sbp_debug, CTLFLAG_RWTUN, &debug, 0,
 	"SBP debug flag");
 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, auto_login, CTLFLAG_RWTUN, &auto_login, 0,
diff --git a/sys/dev/fxp/if_fxp.c b/sys/dev/fxp/if_fxp.c
index a764e0576a49..d89d19632a9a 100644
--- a/sys/dev/fxp/if_fxp.c
+++ b/sys/dev/fxp/if_fxp.c
@@ -3153,12 +3153,12 @@ fxp_sysctl_node(struct fxp_softc *sc)
 	ctx = device_get_sysctl_ctx(sc->dev);
 	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));
 
-	SYSCTL_ADD_PROC(ctx, child,
-	    OID_AUTO, "int_delay", CTLTYPE_INT | CTLFLAG_RW,
+	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_delay",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    &sc->tunable_int_delay, 0, sysctl_hw_fxp_int_delay, "I",
 	    "FXP driver receive interrupt microcode bundling delay");
-	SYSCTL_ADD_PROC(ctx, child,
-	    OID_AUTO, "bundle_max", CTLTYPE_INT | CTLFLAG_RW,
+	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "bundle_max",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    &sc->tunable_bundle_max, 0, sysctl_hw_fxp_bundle_max, "I",
 	    "FXP driver receive interrupt microcode bundle size limit");
 	SYSCTL_ADD_INT(ctx, child,OID_AUTO, "rnr", CTLFLAG_RD, &sc->rnr, 0,
@@ -3176,13 +3176,13 @@ fxp_sysctl_node(struct fxp_softc *sc)
 	sc->rnr = 0;
 
 	hsp = &sc->fxp_hwstats;
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "FXP statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "FXP statistics");
 	parent = SYSCTL_CHILDREN(tree);
 
 	/* Rx MAC statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "Rx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Rx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	FXP_SYSCTL_STAT_ADD(ctx, child, "good_frames",
 	    &hsp->rx_good, "Good frames");
@@ -3209,8 +3209,8 @@ fxp_sysctl_node(struct fxp_softc *sc)
 		    &hsp->rx_tco, "TCO frames");
 
 	/* Tx MAC statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "Tx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Tx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	FXP_SYSCTL_STAT_ADD(ctx, child, "good_frames",
 	    &hsp->tx_good, "Good frames");
diff --git a/sys/dev/gpio/gpiobacklight.c b/sys/dev/gpio/gpiobacklight.c
index 24636e0a65dd..48766e8b649c 100644
--- a/sys/dev/gpio/gpiobacklight.c
+++ b/sys/dev/gpio/gpiobacklight.c
@@ -131,7 +131,7 @@ gpiobacklight_attach(device_t dev)
 	ctx = device_get_sysctl_ctx(dev);
 	tree = device_get_sysctl_tree(dev);
 	sc->sc_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-	    "brightness", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
+	    "brightness", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
 	    gpiobacklight_sysctl, "I", "backlight brightness");
 
 	return (0);
diff --git a/sys/dev/hifn/hifn7751.c b/sys/dev/hifn/hifn7751.c
index f1a7ea52c257..ce0f060aa7d2 100644
--- a/sys/dev/hifn/hifn7751.c
+++ b/sys/dev/hifn/hifn7751.c
@@ -180,8 +180,8 @@ READ_REG_1(struct hifn_softc *sc, bus_size_t reg)
 }
 #define	WRITE_REG_1(sc, reg, val)	hifn_write_reg_1(sc, reg, val)
 
-static SYSCTL_NODE(_hw, OID_AUTO, hifn, CTLFLAG_RD, 0,
-	    "Hifn driver parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, hifn, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Hifn driver parameters");
 
 #ifdef HIFN_DEBUG
 static	int hifn_debug = 0;
diff --git a/sys/dev/hptmv/hptproc.c b/sys/dev/hptmv/hptproc.c
index c9ee38a4d41a..90d65250c752 100644
--- a/sys/dev/hptmv/hptproc.c
+++ b/sys/dev/hptmv/hptproc.c
@@ -639,13 +639,16 @@ out:
 
 #if __FreeBSD_version >= 1100024
 #define hptregister_node(name) \
-	SYSCTL_ROOT_NODE(OID_AUTO, name, CTLFLAG_RW, 0, "Get/Set " #name " state root node"); \
-	SYSCTL_OID(_ ## name, OID_AUTO, status, CTLTYPE_STRING|CTLFLAG_RW, \
-	NULL, 0, hpt_status, "A", "Get/Set " #name " state")
+    SYSCTL_ROOT_NODE(OID_AUTO, name, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, \
+        "Get/Set " #name " state root node"); \
+        SYSCTL_OID(_ ## name, OID_AUTO, status, \
+            CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, \
+            NULL, 0, hpt_status, "A", "Get/Set " #name " state")
 #else
 #define hptregister_node(name) \
 	SYSCTL_NODE(, OID_AUTO, name, CTLFLAG_RW, 0, "Get/Set " #name " state root node"); \
-	SYSCTL_OID(_ ## name, OID_AUTO, status, CTLTYPE_STRING|CTLFLAG_RW, \
+	SYSCTL_OID(_ ## name, OID_AUTO, status, \
+	CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE, \
 	NULL, 0, hpt_status, "A", "Get/Set " #name " state")
 #endif
 	
diff --git a/sys/dev/hwpmc/hwpmc_mod.c b/sys/dev/hwpmc/hwpmc_mod.c
index 3c3f848d5667..49667704ff64 100644
--- a/sys/dev/hwpmc/hwpmc_mod.c
+++ b/sys/dev/hwpmc/hwpmc_mod.c
@@ -275,7 +275,8 @@ static void pmc_process_allproc(struct pmc *pm);
  */
 
 SYSCTL_DECL(_kern_hwpmc);
-SYSCTL_NODE(_kern_hwpmc, OID_AUTO, stats, CTLFLAG_RW, 0, "HWPMC stats");
+SYSCTL_NODE(_kern_hwpmc, OID_AUTO, stats, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "HWPMC stats");
 
 
 /* Stats. */
@@ -313,8 +314,9 @@ char	pmc_debugstr[PMC_DEBUG_STRSIZE];
 TUNABLE_STR(PMC_SYSCTL_NAME_PREFIX "debugflags", pmc_debugstr,
     sizeof(pmc_debugstr));
 SYSCTL_PROC(_kern_hwpmc, OID_AUTO, debugflags,
-    CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_NOFETCH,
-    0, 0, pmc_debugflags_sysctl_handler, "A", "debug flags");
+    CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_NOFETCH | CTLFLAG_NEEDGIANT,
+    0, 0, pmc_debugflags_sysctl_handler, "A",
+    "debug flags");
 #endif
 
 
diff --git a/sys/dev/hyperv/netvsc/if_hn.c b/sys/dev/hyperv/netvsc/if_hn.c
index e9d1b9439671..6c1e62c22d6f 100644
--- a/sys/dev/hyperv/netvsc/if_hn.c
+++ b/sys/dev/hyperv/netvsc/if_hn.c
@@ -576,12 +576,16 @@ SYSCTL_INT(_hw_hn, OID_AUTO, tx_agg_pkts, CTLFLAG_RDTUN,
     &hn_tx_agg_pkts, 0, "Packet transmission aggregation packet limit");
 
 /* VF list */
-SYSCTL_PROC(_hw_hn, OID_AUTO, vflist, CTLFLAG_RD | CTLTYPE_STRING,
-    0, 0, hn_vflist_sysctl, "A", "VF list");
+SYSCTL_PROC(_hw_hn, OID_AUTO, vflist,
+    CTLFLAG_RD | CTLTYPE_STRING | CTLFLAG_NEEDGIANT, 0, 0,
+    hn_vflist_sysctl, "A",
+    "VF list");
 
 /* VF mapping */
-SYSCTL_PROC(_hw_hn, OID_AUTO, vfmap, CTLFLAG_RD | CTLTYPE_STRING,
-    0, 0, hn_vfmap_sysctl, "A", "VF mapping");
+SYSCTL_PROC(_hw_hn, OID_AUTO, vfmap,
+    CTLFLAG_RD | CTLTYPE_STRING | CTLFLAG_NEEDGIANT, 0, 0,
+    hn_vfmap_sysctl, "A",
+    "VF mapping");
 
 /* Transparent VF */
 static int			hn_xpnt_vf = 1;
diff --git a/sys/dev/if_ndis/if_ndis_usb.c b/sys/dev/if_ndis/if_ndis_usb.c
index d88dc59c1968..7ed8e37b0e53 100644
--- a/sys/dev/if_ndis/if_ndis_usb.c
+++ b/sys/dev/if_ndis/if_ndis_usb.c
@@ -68,7 +68,8 @@ __FBSDID("$FreeBSD$");
 #include <compat/ndis/usbd_var.h>
 #include <dev/if_ndis/if_ndisvar.h>
 
-SYSCTL_NODE(_hw, OID_AUTO, ndisusb, CTLFLAG_RD, 0, "NDIS USB driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, ndisusb, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "NDIS USB driver parameters");
 
 MODULE_DEPEND(ndis, usb, 1, 1, 1);
 
diff --git a/sys/dev/iicbus/ad7417.c b/sys/dev/iicbus/ad7417.c
index 11ed09855d52..96178e52a368 100644
--- a/sys/dev/iicbus/ad7417.c
+++ b/sys/dev/iicbus/ad7417.c
@@ -416,7 +416,7 @@ ad7417_attach(device_t dev)
 	ctx = device_get_sysctl_ctx(dev);
 	sensroot_oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensor",
-	    CTLFLAG_RD, 0, "AD7417 Sensor Information");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "AD7417 Sensor Information");
 
 	/* Now we can fill the properties into the allocated struct. */
 	sc->sc_nsensors = ad7417_fill_sensor_prop(dev);
@@ -432,9 +432,8 @@ ad7417_attach(device_t dev)
 		sysctl_name[j] = 0;
 
 		oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sensroot_oid),
-				      OID_AUTO,
-				      sysctl_name, CTLFLAG_RD, 0,
-				      "Sensor Information");
+		    OID_AUTO, sysctl_name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+		    "Sensor Information");
 
 		if (sc->sc_sensors[i].type == ADC7417_TEMP_SENSOR) {
 			unit = "temp";
@@ -445,10 +444,10 @@ ad7417_attach(device_t dev)
 		}
 		/* I use i to pass the sensor id. */
 		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-				unit, CTLTYPE_INT | CTLFLAG_RD, dev,
-				i, ad7417_sensor_sysctl,
-				sc->sc_sensors[i].type == ADC7417_TEMP_SENSOR ?
-				"IK" : "I", desc);
+		    unit, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, dev,
+		    i, ad7417_sensor_sysctl,
+		    sc->sc_sensors[i].type == ADC7417_TEMP_SENSOR ? "IK" : "I",
+		    desc);
 	}
 	/* Dump sensor location, ID & type. */
 	if (bootverbose) {
diff --git a/sys/dev/iicbus/ad7418.c b/sys/dev/iicbus/ad7418.c
index 034597768790..b2743d0f0b57 100644
--- a/sys/dev/iicbus/ad7418.c
+++ b/sys/dev/iicbus/ad7418.c
@@ -118,11 +118,11 @@ ad7418_attach(device_t dev)
 	sx_init(&sc->sc_lock, "ad7418");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-		"temp", CTLTYPE_INT | CTLFLAG_RD, sc, 0,
-		ad7418_sysctl_temp, "I", "operating temperature");
+	    "temp", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    ad7418_sysctl_temp, "I", "operating temperature");
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-		"volt", CTLTYPE_INT | CTLFLAG_RD, sc, 0,
-		ad7418_sysctl_voltage, "I", "input voltage");
+	    "volt", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    ad7418_sysctl_voltage, "I", "input voltage");
 
 	/* enable chip if configured in shutdown mode */
 	conf = ad7418_read_1(dev, AD7418_CONF);
diff --git a/sys/dev/iicbus/ads111x.c b/sys/dev/iicbus/ads111x.c
index 1bf9b8c19334..724b2a9a0fd7 100644
--- a/sys/dev/iicbus/ads111x.c
+++ b/sys/dev/iicbus/ads111x.c
@@ -407,16 +407,18 @@ ads111x_setup_channel(struct ads111x_softc *sc, int chan, int gainidx, int ratei
 	devtree = device_get_sysctl_tree(sc->dev);
 	snprintf(chanstr, sizeof(chanstr), "%d", chan);
 	chantree = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(devtree), OID_AUTO,
-	    chanstr, CTLFLAG_RD, NULL, "channel data");
+	    chanstr, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "channel data");
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(chantree), OID_AUTO,
-	    "gain_index", CTLTYPE_INT | CTLFLAG_RWTUN, sc, chan,
-	    ads111x_sysctl_gainidx, "I", "programmable gain amp setting, 0-7");
+	    "gain_index", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT,
+	    sc, chan, ads111x_sysctl_gainidx, "I",
+	    "programmable gain amp setting, 0-7");
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(chantree), OID_AUTO,
-	    "rate_index", CTLTYPE_INT | CTLFLAG_RWTUN, sc, chan,
-	    ads111x_sysctl_rateidx, "I", "sample rate setting, 0-7");
+	    "rate_index", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT,
+	    sc, chan, ads111x_sysctl_rateidx, "I", "sample rate setting, 0-7");
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(chantree), OID_AUTO,
-	    "voltage", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_SKIP, sc, chan,
-	    ads111x_sysctl_voltage, "I", "sampled voltage in microvolts");
+	    "voltage",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_SKIP | CTLFLAG_NEEDGIANT, sc,
+	    chan, ads111x_sysctl_voltage, "I", "sampled voltage in microvolts");
 
 	c->configured = true;
 }
@@ -556,13 +558,13 @@ ads111x_attach(device_t dev)
 	ctx = device_get_sysctl_ctx(dev);
 	tree = device_get_sysctl_tree(dev);
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-	    "config", CTLTYPE_INT | CTLFLAG_RWTUN, sc, 0,
+	    "config", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, sc, 0,
 	    ads111x_sysctl_config, "I", "configuration register word");
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-	    "lo_thresh", CTLTYPE_INT | CTLFLAG_RWTUN, sc, 0,
+	    "lo_thresh", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, sc, 0,
 	    ads111x_sysctl_lothresh, "I", "comparator low threshold");
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-	    "hi_thresh", CTLTYPE_INT | CTLFLAG_RWTUN, sc, 0,
+	    "hi_thresh", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, sc, 0,
 	    ads111x_sysctl_hithresh, "I", "comparator high threshold");
 
 	/* Set up channels based on metadata or default config. */
diff --git a/sys/dev/iicbus/adt746x.c b/sys/dev/iicbus/adt746x.c
index 3b908453a0d7..435075e78e4a 100644
--- a/sys/dev/iicbus/adt746x.c
+++ b/sys/dev/iicbus/adt746x.c
@@ -495,7 +495,7 @@ adt746x_attach_fans(device_t dev)
 	ctx = device_get_sysctl_ctx(dev);
 	fanroot_oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "fans",
-	    CTLFLAG_RD, 0, "ADT Fan Information");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "ADT Fan Information");
 
 	/* Now we can fill the properties into the allocated struct. */
 	sc->sc_nfans = adt746x_fill_fan_prop(dev);
@@ -517,12 +517,13 @@ adt746x_attach_fans(device_t dev)
 			adt746x_fan_get_pwm(&sc->sc_fans[i]);
 
 		oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(fanroot_oid),
-		    OID_AUTO, sysctl_name, CTLFLAG_RD, 0, "Fan Information");
+		    OID_AUTO, sysctl_name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+		    "Fan Information");
 
 		/* I use i to pass the fan id. */
 		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-				"pwm", CTLTYPE_INT | CTLFLAG_RW, dev, i,
-				adt746x_fanrpm_sysctl, "I", "Fan PWM in %");
+		    "pwm", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, dev,
+		    i, adt746x_fanrpm_sysctl, "I", "Fan PWM in %");
 	}
 
 	/* Dump fan location & type. */
@@ -621,7 +622,7 @@ adt746x_attach_sensors(device_t dev)
 	ctx = device_get_sysctl_ctx(dev);
 	sensroot_oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensors",
-	    CTLFLAG_RD, 0, "ADT Sensor Information");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "ADT Sensor Information");
 
 	/* Add the sysctl for the sensors. */
 	for (i = 0; i < sc->sc_nsensors; i++) {
@@ -632,9 +633,8 @@ adt746x_attach_sensors(device_t dev)
 		}
 		sysctl_name[j] = 0;
 		oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sensroot_oid),
-				      OID_AUTO,
-				      sysctl_name, CTLFLAG_RD, 0,
-				      "Sensor Information");
+		    OID_AUTO, sysctl_name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 
+		    "Sensor Information");
 		if (sc->sc_sensors[i].type == ADT746X_SENSOR_TEMP) {
 			unit = "temp";
 			desc = "sensor unit (C)";
@@ -647,10 +647,10 @@ adt746x_attach_sensors(device_t dev)
 		}
 		/* I use i to pass the sensor id. */
 		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
-				unit, CTLTYPE_INT | CTLFLAG_RD, dev, i,
-				adt746x_sensor_sysctl,
-				sc->sc_sensors[i].type == ADT746X_SENSOR_TEMP ?
-				"IK" : "I", desc);
+		    unit, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, dev, i,
+		    adt746x_sensor_sysctl,
+		    sc->sc_sensors[i].type == ADT746X_SENSOR_TEMP ?
+		    "IK" : "I", desc);
 	}
 
 	/* Dump sensor location & type. */
diff --git a/sys/dev/iicbus/ds1631.c b/sys/dev/iicbus/ds1631.c
index 81fe62fd9ed4..bce4e36a240e 100644
--- a/sys/dev/iicbus/ds1631.c
+++ b/sys/dev/iicbus/ds1631.c
@@ -314,7 +314,7 @@ ds1631_start(void *xdev)
 	ctx = device_get_sysctl_ctx(dev);
 	sensroot_oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensor",
-	    CTLFLAG_RD, 0, "DS1631 Sensor Information");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "DS1631 Sensor Information");
 
 	if (OF_getprop(child, "hwsensor-zone", &sc->sc_sensor.zone,
 		       sizeof(int)) < 0)
@@ -358,8 +358,8 @@ ds1631_start(void *xdev)
 
 	sprintf(sysctl_desc,"%s %s", sc->sc_sensor.name, "(C)");
 	oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sensroot_oid),
-			      OID_AUTO, sysctl_name, CTLFLAG_RD, 0,
-			      "Sensor Information");
+	    OID_AUTO, sysctl_name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+	    "Sensor Information");
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "temp",
 			CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, dev,
 			0, ds1631_sensor_sysctl, "IK", sysctl_desc);
diff --git a/sys/dev/iicbus/ds1775.c b/sys/dev/iicbus/ds1775.c
index f303125c779b..2df1b13abf2e 100644
--- a/sys/dev/iicbus/ds1775.c
+++ b/sys/dev/iicbus/ds1775.c
@@ -189,7 +189,7 @@ ds1775_start(void *xdev)
 	ctx = device_get_sysctl_ctx(dev);
 	sensroot_oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensor",
-	    CTLFLAG_RD, 0, "DS1775 Sensor Information");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "DS1775 Sensor Information");
 
 	if (OF_getprop(child, "hwsensor-zone", &sc->sc_sensor.zone,
 		       sizeof(int)) < 0)
@@ -225,8 +225,8 @@ ds1775_start(void *xdev)
 
 	sprintf(sysctl_desc,"%s %s", sc->sc_sensor.name, "(C)");
 	oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sensroot_oid),
-			      OID_AUTO, sysctl_name, CTLFLAG_RD, 0,
-			      "Sensor Information");
+	    OID_AUTO, sysctl_name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+	    "Sensor Information");
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "temp",
 			CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, dev,
 			0, ds1775_sensor_sysctl, "IK", sysctl_desc);
diff --git a/sys/dev/iicbus/max6690.c b/sys/dev/iicbus/max6690.c
index af3aeee4be34..b0c1a9f8ddcb 100644
--- a/sys/dev/iicbus/max6690.c
+++ b/sys/dev/iicbus/max6690.c
@@ -276,7 +276,7 @@ max6690_start(void *xdev)
 	ctx = device_get_sysctl_ctx(dev);
 	sensroot_oid = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensor",
-	    CTLFLAG_RD, 0, "MAX6690 Sensor Information");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "MAX6690 Sensor Information");
 
 	/* Now we can fill the properties into the allocated struct. */
 	sc->sc_nsensors = max6690_fill_sensor_prop(dev);
@@ -298,13 +298,12 @@ max6690_start(void *xdev)
 		sprintf(sysctl_desc,"%s %s", sc->sc_sensors[i].therm.name,
 			"(C)");
 		oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sensroot_oid),
-				      OID_AUTO,
-				      sysctl_name, CTLFLAG_RD, 0,
-				      "Sensor Information");
+		    OID_AUTO, sysctl_name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+		    "Sensor Information");
 		/* I use i to pass the sensor id. */
 		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "temp",
-				CTLTYPE_INT | CTLFLAG_RD, dev, i % 2,
-				max6690_sensor_sysctl, "IK", sysctl_desc);
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, dev, i % 2,
+		    max6690_sensor_sysctl, "IK", sysctl_desc);
 
 	}
 	/* Dump sensor location & ID. */
diff --git a/sys/dev/ioat/ioat.c b/sys/dev/ioat/ioat.c
index caa15c125d89..f9660a2b233d 100644
--- a/sys/dev/ioat/ioat.c
+++ b/sys/dev/ioat/ioat.c
@@ -114,7 +114,8 @@ static void ioat_drain_locked(struct ioat_softc *);
 } while (0)
 
 MALLOC_DEFINE(M_IOAT, "ioat", "ioat driver memory allocations");
-SYSCTL_NODE(_hw, OID_AUTO, ioat, CTLFLAG_RD, 0, "ioat node");
+SYSCTL_NODE(_hw, OID_AUTO, ioat, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "ioat node");
 
 static int g_force_legacy_interrupts;
 SYSCTL_INT(_hw_ioat, OID_AUTO, force_legacy_interrupts, CTLFLAG_RDTUN,
@@ -1932,8 +1933,8 @@ ioat_setup_sysctl(device_t device)
 	    &ioat->intrdelay_max, 0,
 	    "Maximum configurable INTRDELAY on this channel (microseconds)");
 
-	tmp = SYSCTL_ADD_NODE(ctx, par, OID_AUTO, "state", CTLFLAG_RD, NULL,
-	    "IOAT channel internal state");
+	tmp = SYSCTL_ADD_NODE(ctx, par, OID_AUTO, "state",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "IOAT channel internal state");
 	state = SYSCTL_CHILDREN(tmp);
 
 	SYSCTL_ADD_UINT(ctx, state, OID_AUTO, "ring_size_order", CTLFLAG_RD,
@@ -1951,23 +1952,24 @@ ioat_setup_sysctl(device_t device)
 	    "submitter processing");
 
 	SYSCTL_ADD_PROC(ctx, state, OID_AUTO, "chansts",
-	    CTLTYPE_STRING | CTLFLAG_RD, ioat, 0, sysctl_handle_chansts, "A",
-	    "String of the channel status");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, ioat, 0,
+	    sysctl_handle_chansts, "A", "String of the channel status");
 
 	SYSCTL_ADD_U16(ctx, state, OID_AUTO, "intrdelay", CTLFLAG_RD,
 	    &ioat->cached_intrdelay, 0,
 	    "Current INTRDELAY on this channel (cached, microseconds)");
 
-	tmp = SYSCTL_ADD_NODE(ctx, par, OID_AUTO, "hammer", CTLFLAG_RD, NULL,
+	tmp = SYSCTL_ADD_NODE(ctx, par, OID_AUTO, "hammer",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
 	    "Big hammers (mostly for testing)");
 	hammer = SYSCTL_CHILDREN(tmp);
 
 	SYSCTL_ADD_PROC(ctx, hammer, OID_AUTO, "force_hw_reset",
-	    CTLTYPE_INT | CTLFLAG_RW, ioat, 0, sysctl_handle_reset, "I",
-	    "Set to non-zero to reset the hardware");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, ioat, 0,
+	    sysctl_handle_reset, "I", "Set to non-zero to reset the hardware");
 
-	tmp = SYSCTL_ADD_NODE(ctx, par, OID_AUTO, "stats", CTLFLAG_RD, NULL,
-	    "IOAT channel statistics");
+	tmp = SYSCTL_ADD_NODE(ctx, par, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "IOAT channel statistics");
 	statpar = SYSCTL_CHILDREN(tmp);
 
 	SYSCTL_ADD_UQUAD(ctx, statpar, OID_AUTO, "interrupts",
@@ -1990,8 +1992,8 @@ ioat_setup_sysctl(device_t device)
 	    "The raw CHANERR when the channel was last halted");
 
 	SYSCTL_ADD_PROC(ctx, statpar, OID_AUTO, "desc_per_interrupt",
-	    CTLTYPE_STRING | CTLFLAG_RD, ioat, 0, sysctl_handle_dpi, "A",
-	    "Descriptors per interrupt");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, ioat, 0,
+	    sysctl_handle_dpi, "A", "Descriptors per interrupt");
 }
 
 static void
diff --git a/sys/dev/ioat/ioat_test.c b/sys/dev/ioat/ioat_test.c
index 43405c87623c..0bd6a3377bea 100644
--- a/sys/dev/ioat/ioat_test.c
+++ b/sys/dev/ioat/ioat_test.c
@@ -576,8 +576,9 @@ sysctl_enable_ioat_test(SYSCTL_HANDLER_ARGS)
 	enable_ioat_test(enabled);
 	return (0);
 }
-SYSCTL_PROC(_hw_ioat, OID_AUTO, enable_ioat_test, CTLTYPE_INT | CTLFLAG_RW,
-    0, 0, sysctl_enable_ioat_test, "I",
+SYSCTL_PROC(_hw_ioat, OID_AUTO, enable_ioat_test,
+    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 0, 0,
+    sysctl_enable_ioat_test, "I",
     "Non-zero: Enable the /dev/ioat_test device");
 
 void
diff --git a/sys/dev/ipmi/ipmi.c b/sys/dev/ipmi/ipmi.c
index 612c58b54dbc..da44e70dbcbc 100644
--- a/sys/dev/ipmi/ipmi.c
+++ b/sys/dev/ipmi/ipmi.c
@@ -93,7 +93,7 @@ static int wd_startup_countdown = 0; /* sec */
 static int wd_pretimeout_countdown = 120; /* sec */
 static int cycle_wait = 10; /* sec */
 
-static SYSCTL_NODE(_hw, OID_AUTO, ipmi, CTLFLAG_RD, 0,
+static SYSCTL_NODE(_hw, OID_AUTO, ipmi, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "IPMI driver parameters");
 SYSCTL_INT(_hw_ipmi, OID_AUTO, on, CTLFLAG_RWTUN,
 	&on, 0, "");
diff --git a/sys/dev/ipw/if_ipw.c b/sys/dev/ipw/if_ipw.c
index 99587155ab34..74898589631e 100644
--- a/sys/dev/ipw/if_ipw.c
+++ b/sys/dev/ipw/if_ipw.c
@@ -330,13 +330,14 @@ ipw_attach(device_t dev)
 	 */
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "radio",
-	    CTLTYPE_INT | CTLFLAG_RD, sc, 0, ipw_sysctl_radio, "I",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    ipw_sysctl_radio, "I",
 	    "radio transmitter switch state (0=off, 1=on)");
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "stats",
-	    CTLTYPE_OPAQUE | CTLFLAG_RD, sc, 0, ipw_sysctl_stats, "S",
-	    "statistics");
+	    CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    ipw_sysctl_stats, "S", "statistics");
 
 	/*
 	 * Hook our interrupt after all initialization is complete.
diff --git a/sys/dev/isci/isci_sysctl.c b/sys/dev/isci/isci_sysctl.c
index af47f9a5766e..5741d4c2d516 100644
--- a/sys/dev/isci/isci_sysctl.c
+++ b/sys/dev/isci/isci_sysctl.c
@@ -249,40 +249,44 @@ void isci_sysctl_initialize(struct isci_softc *isci)
 	struct sysctl_oid *sysctl_tree = device_get_sysctl_tree(isci->device);
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "coalesce_timeout", CTLTYPE_UINT | CTLFLAG_RW, isci, 0,
-	    isci_sysctl_coalesce_timeout, "IU",
+	    "coalesce_timeout", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    isci, 0, isci_sysctl_coalesce_timeout, "IU",
 	    "Interrupt coalescing timeout (in microseconds)");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "coalesce_number", CTLTYPE_UINT | CTLFLAG_RW, isci, 0,
-	    isci_sysctl_coalesce_number, "IU",
+	    "coalesce_number", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    isci, 0, isci_sysctl_coalesce_number, "IU",
 	    "Interrupt coalescing number");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "reset_remote_device_on_controller0", CTLTYPE_UINT| CTLFLAG_RW,
-	    isci, 0, isci_sysctl_reset_remote_device_on_controller0, "IU",
+	    "reset_remote_device_on_controller0",
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, isci, 0,
+	    isci_sysctl_reset_remote_device_on_controller0, "IU",
 	    "Reset remote device on controller 0");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "reset_remote_device_on_controller1", CTLTYPE_UINT| CTLFLAG_RW,
+	    "reset_remote_device_on_controller1",
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    isci, 0, isci_sysctl_reset_remote_device_on_controller1, "IU",
 	    "Reset remote device on controller 1");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "stop_phy", CTLTYPE_UINT| CTLFLAG_RW, isci, 0, isci_sysctl_stop_phy,
-	    "IU", "Stop PHY on a controller");
+	    "stop_phy", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, isci,
+	    0, isci_sysctl_stop_phy, "IU", "Stop PHY on a controller");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "start_phy", CTLTYPE_UINT| CTLFLAG_RW, isci, 0,
-	    isci_sysctl_start_phy, "IU", "Start PHY on a controller");
+	    "start_phy", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, isci,
+	    0, isci_sysctl_start_phy, "IU", "Start PHY on a controller");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "log_frozen_lun_masks", CTLTYPE_UINT| CTLFLAG_RW, isci, 0,
+	    "log_frozen_lun_masks",
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, isci, 0,
 	    isci_sysctl_log_frozen_lun_masks, "IU",
 	    "Log frozen lun masks to kernel log");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "fail_on_task_timeout", CTLTYPE_UINT | CTLFLAG_RW, isci, 0,
+	    "fail_on_task_timeout",
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, isci, 0,
 	    isci_sysctl_fail_on_task_timeout, "IU",
 	    "Fail a command that has encountered a task management timeout");
 }
diff --git a/sys/dev/iscsi_initiator/isc_sm.c b/sys/dev/iscsi_initiator/isc_sm.c
index 588c674c06f2..8cc4a4a69293 100644
--- a/sys/dev/iscsi_initiator/isc_sm.c
+++ b/sys/dev/iscsi_initiator/isc_sm.c
@@ -637,14 +637,14 @@ isc_add_sysctls(isc_session_t *sp)
 			       SYSCTL_CHILDREN(sp->isc->oid),
 			       OID_AUTO,
 			       devtoname(sp->dev) + 5, // iscsi0
-			       CTLFLAG_RD,
+			       CTLFLAG_RD | CTLFLAG_MPSAFE,
 			       0,
 			       "initiator");
      SYSCTL_ADD_PROC(&sp->clist,
 		     SYSCTL_CHILDREN(sp->oid),
 		     OID_AUTO,
 		     "targetname",
-		     CTLTYPE_STRING | CTLFLAG_RD,
+		     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		     (void *)&sp->opt.targetName, 0,
 		     sysctl_handle_string, "A", "target name");
 
@@ -652,7 +652,7 @@ isc_add_sysctls(isc_session_t *sp)
 		     SYSCTL_CHILDREN(sp->oid),
 		     OID_AUTO,
 		     "targeaddress",
-		     CTLTYPE_STRING | CTLFLAG_RD,
+		     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		     (void *)&sp->opt.targetAddress, 0,
 		     sysctl_handle_string, "A", "target address");
 
@@ -660,7 +660,7 @@ isc_add_sysctls(isc_session_t *sp)
 		     SYSCTL_CHILDREN(sp->oid),
 		     OID_AUTO,
 		     "stats",
-		     CTLTYPE_STRING | CTLFLAG_RD,
+		     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 		     (void *)sp, 0,
 		     isc_dump_stats, "A", "statistics");
 
diff --git a/sys/dev/iscsi_initiator/iscsi.c b/sys/dev/iscsi_initiator/iscsi.c
index 2a3eb19eaa8a..a081ecc7bbea 100644
--- a/sys/dev/iscsi_initiator/iscsi.c
+++ b/sys/dev/iscsi_initiator/iscsi.c
@@ -737,7 +737,7 @@ iscsi_start(void)
 			       SYSCTL_STATIC_CHILDREN(_net),
 			       OID_AUTO,
 			       "iscsi_initiator",
-			       CTLFLAG_RD,
+			       CTLFLAG_RD | CTLFLAG_MPSAFE,
 			       0,
 			       "iSCSI Subsystem");
 
diff --git a/sys/dev/iser/icl_iser.c b/sys/dev/iser/icl_iser.c
index 622178ab4dd3..be09a3649dd9 100644
--- a/sys/dev/iser/icl_iser.c
+++ b/sys/dev/iser/icl_iser.c
@@ -26,7 +26,8 @@
 
 #include "icl_iser.h"
 
-SYSCTL_NODE(_kern, OID_AUTO, iser, CTLFLAG_RW, 0, "iSER module");
+SYSCTL_NODE(_kern, OID_AUTO, iser, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "iSER module");
 int iser_debug = 0;
 SYSCTL_INT(_kern_iser, OID_AUTO, debug, CTLFLAG_RWTUN,
     &iser_debug, 0, "Enable iser debug messages");
diff --git a/sys/dev/isl/isl.c b/sys/dev/isl/isl.c
index ef77985df19c..9203cf090917 100644
--- a/sys/dev/isl/isl.c
+++ b/sys/dev/isl/isl.c
@@ -205,38 +205,38 @@ isl_attach(device_t dev)
 
 	if (use_als) {
 		SYSCTL_ADD_PROC(sysctl_ctx,
-			SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-			    "als", CTLTYPE_INT | CTLFLAG_RD,
-			    sc, ISL_METHOD_ALS, isl_sysctl, "I",
-			    "Current ALS sensor read-out");
+		    SYSCTL_CHILDREN(sysctl_tree), OID_AUTO, "als",
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    ISL_METHOD_ALS, isl_sysctl, "I",
+		    "Current ALS sensor read-out");
 	}
 
 	if (use_ir) {
 		SYSCTL_ADD_PROC(sysctl_ctx,
-			SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-			    "ir", CTLTYPE_INT | CTLFLAG_RD,
-			    sc, ISL_METHOD_IR, isl_sysctl, "I",
-			    "Current IR sensor read-out");
+		    SYSCTL_CHILDREN(sysctl_tree), OID_AUTO, "ir",
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    ISL_METHOD_IR, isl_sysctl, "I",
+		    "Current IR sensor read-out");
 	}
 
 	if (use_prox) {
 		SYSCTL_ADD_PROC(sysctl_ctx,
-			SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-			    "prox", CTLTYPE_INT | CTLFLAG_RD,
-			    sc, ISL_METHOD_PROX, isl_sysctl, "I",
-			    "Current proximity sensor read-out");
+		    SYSCTL_CHILDREN(sysctl_tree), OID_AUTO, "prox",
+		    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+		    ISL_METHOD_PROX, isl_sysctl, "I",
+		    "Current proximity sensor read-out");
 	}
 
 	SYSCTL_ADD_PROC(sysctl_ctx,
-		SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-		    "resolution", CTLTYPE_INT | CTLFLAG_RD,
-		    sc, ISL_METHOD_RESOLUTION, isl_sysctl, "I",
-		    "Current proximity sensor resolution");
+	    SYSCTL_CHILDREN(sysctl_tree), OID_AUTO, "resolution",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+	    ISL_METHOD_RESOLUTION, isl_sysctl, "I",
+	    "Current proximity sensor resolution");
 
 	SYSCTL_ADD_PROC(sysctl_ctx,
-	SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "range", CTLTYPE_INT | CTLFLAG_RD,
-	    sc, ISL_METHOD_RANGE, isl_sysctl, "I",
+	    SYSCTL_CHILDREN(sysctl_tree), OID_AUTO, "range",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc,
+	    ISL_METHOD_RANGE, isl_sysctl, "I",
 	    "Current proximity sensor range");
 
 	return (0);
diff --git a/sys/dev/isp/isp_freebsd.c b/sys/dev/isp/isp_freebsd.c
index 788572d61539..3857d52bc0b0 100644
--- a/sys/dev/isp/isp_freebsd.c
+++ b/sys/dev/isp/isp_freebsd.c
@@ -203,7 +203,8 @@ isp_attach_chan(ispsoftc_t *isp, struct cam_devq *devq, int chan)
 		if (chan > 0) {
 			snprintf(name, sizeof(name), "chan%d", chan);
 			tree = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree),
-			    OID_AUTO, name, CTLFLAG_RW, 0, "Virtual channel");
+			    OID_AUTO, name, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+			    "Virtual channel");
 		}
 		SYSCTL_ADD_QUAD(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
 		    "wwnn", CTLFLAG_RD, &fcp->isp_wwnn,
@@ -223,8 +224,8 @@ isp_attach_chan(ispsoftc_t *isp, struct cam_devq *devq, int chan)
 		    "Cause a Lost Frame on a Read");
 #endif
 		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-		    "role", CTLTYPE_INT | CTLFLAG_RW, isp, chan,
-		    isp_role_sysctl, "I", "Current role");
+		    "role", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+		    isp, chan, isp_role_sysctl, "I", "Current role");
 		SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
 		    "speed", CTLFLAG_RD, &fcp->isp_gbspeed, 0,
 		    "Connection speed in gigabits");
diff --git a/sys/dev/iwi/if_iwi.c b/sys/dev/iwi/if_iwi.c
index 2facc93eade1..360020e01b19 100644
--- a/sys/dev/iwi/if_iwi.c
+++ b/sys/dev/iwi/if_iwi.c
@@ -3334,12 +3334,13 @@ iwi_sysctlattach(struct iwi_softc *sc)
 	struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "radio",
-	    CTLTYPE_INT | CTLFLAG_RD, sc, 0, iwi_sysctl_radio, "I",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    iwi_sysctl_radio, "I",
 	    "radio transmitter switch state (0=off, 1=on)");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "stats",
-	    CTLTYPE_OPAQUE | CTLFLAG_RD, sc, 0, iwi_sysctl_stats, "S",
-	    "statistics");
+	    CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    iwi_sysctl_stats, "S", "statistics");
 
 	sc->bluetooth = 0;
 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "bluetooth",
@@ -3513,8 +3514,8 @@ iwi_ledattach(struct iwi_softc *sc)
 	callout_init_mtx(&sc->sc_ledtimer, &sc->sc_mtx, 0);
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-		"softled", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
-		iwi_sysctl_softled, "I", "enable/disable software LED support");
+	    "softled", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    iwi_sysctl_softled, "I", "enable/disable software LED support");
 	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
 		"ledpin", CTLFLAG_RW, &sc->sc_ledpin, 0,
 		"pin setting to turn activity LED on");
diff --git a/sys/dev/jme/if_jme.c b/sys/dev/jme/if_jme.c
index a4395ce20c72..fc0297e70d26 100644
--- a/sys/dev/jme/if_jme.c
+++ b/sys/dev/jme/if_jme.c
@@ -994,24 +994,24 @@ jme_sysctl_node(struct jme_softc *sc)
 	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->jme_dev));
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "tx_coal_to",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->jme_tx_coal_to, 0,
-	    sysctl_hw_jme_tx_coal_to, "I", "jme tx coalescing timeout");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->jme_tx_coal_to,
+	    0, sysctl_hw_jme_tx_coal_to, "I", "jme tx coalescing timeout");
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "tx_coal_pkt",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->jme_tx_coal_pkt, 0,
-	    sysctl_hw_jme_tx_coal_pkt, "I", "jme tx coalescing packet");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->jme_tx_coal_pkt,
+	    0, sysctl_hw_jme_tx_coal_pkt, "I", "jme tx coalescing packet");
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rx_coal_to",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->jme_rx_coal_to, 0,
-	    sysctl_hw_jme_rx_coal_to, "I", "jme rx coalescing timeout");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->jme_rx_coal_to,
+	    0, sysctl_hw_jme_rx_coal_to, "I", "jme rx coalescing timeout");
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rx_coal_pkt",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->jme_rx_coal_pkt, 0,
-	    sysctl_hw_jme_rx_coal_pkt, "I", "jme rx coalescing packet");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->jme_rx_coal_pkt,
+	    0, sysctl_hw_jme_rx_coal_pkt, "I", "jme rx coalescing packet");
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "process_limit",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->jme_process_limit, 0,
-	    sysctl_hw_jme_proc_limit, "I",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    &sc->jme_process_limit, 0, sysctl_hw_jme_proc_limit, "I",
 	    "max number of Rx events to process");
 
 	/* Pull in device tunables. */
@@ -1084,13 +1084,13 @@ jme_sysctl_node(struct jme_softc *sc)
 	if ((sc->jme_flags & JME_FLAG_HWMIB) == 0)
 		return;
 
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "JME statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "JME statistics");
 	parent = SYSCTL_CHILDREN(tree);
 
 	/* Rx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "Rx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Rx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	JME_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
 	    &stats->rx_good_frames, "Good frames");
@@ -1106,8 +1106,8 @@ jme_sysctl_node(struct jme_softc *sc)
 	    &stats->rx_bad_frames, "Bad frames");
 
 	/* Tx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "Tx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Tx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	JME_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
 	    &stats->tx_good_frames, "Good frames");
diff --git a/sys/dev/kbd/kbd.c b/sys/dev/kbd/kbd.c
index e69cbb24fb3c..fd996f7a06ad 100644
--- a/sys/dev/kbd/kbd.c
+++ b/sys/dev/kbd/kbd.c
@@ -85,7 +85,8 @@ static keyboard_t	*kbd_ini;
 static keyboard_t	**keyboard = &kbd_ini;
 
 static int keymap_restrict_change;
-static SYSCTL_NODE(_hw, OID_AUTO, kbd, CTLFLAG_RD, 0, "kbd");
+static SYSCTL_NODE(_hw, OID_AUTO, kbd, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "kbd");
 SYSCTL_INT(_hw_kbd, OID_AUTO, keymap_restrict_change, CTLFLAG_RW,
     &keymap_restrict_change, 0, "restrict ability to change keymap");
 
diff --git a/sys/dev/liquidio/lio_sysctl.c b/sys/dev/liquidio/lio_sysctl.c
index e4c02a791c9f..cee520e63b60 100644
--- a/sys/dev/liquidio/lio_sysctl.c
+++ b/sys/dev/liquidio/lio_sysctl.c
@@ -155,48 +155,46 @@ lio_add_hw_stats(struct lio *lio)
 			  oct_dev->fw_info.lio_firmware_version, 0,
 			  "Firmware version");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "stats_interval",
-			CTLTYPE_INT | CTLFLAG_RW, lio, 0,
-			lio_set_stats_interval,	"I",
-			"Set Stats Updation Timer in milli seconds");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, lio, 0,
+	    lio_set_stats_interval, "I",
+	    "Set Stats Updation Timer in milli seconds");
 	SYSCTL_ADD_UQUAD(ctx, child, OID_AUTO, "link_state_changes",
 			 CTLFLAG_RD, &lio->link_changes, "Link Change Counter");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "eeprom-dump",
 			CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, lio, 0,
 			lio_get_eeprom, "A", "EEPROM information");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "fc",
-			CTLTYPE_INT | CTLFLAG_RW, lio, 0,
-			lio_get_set_pauseparam, "I",
-			"Get and set pause parameters.\n" \
-			"0 - off\n" \
-			"1 - rx pause\n" \
-			"2 - tx pause \n" \
-			"3 - rx and tx pause");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, lio, 0,
+	    lio_get_set_pauseparam, "I",
+	    "Get and set pause parameters.\n" \
+	    "0 - off\n" \
+	    "1 - rx pause\n" \
+	    "2 - tx pause \n" \
+	    "3 - rx and tx pause");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "register-dump",
-			CTLTYPE_STRING | CTLFLAG_RD,
-			lio, 0, lio_get_regs, "A",
-			"Dump registers in raw format");
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, lio, 0,
+	    lio_get_regs, "A", "Dump registers in raw format");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "fwmsglevel",
-			CTLTYPE_INT | CTLFLAG_RW, lio, 0,
-			lio_get_set_fwmsglevel,
-			"I", "Get or set firmware message level");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, lio, 0,
+	    lio_get_set_fwmsglevel, "I", "Get or set firmware message level");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rxq_descriptors",
-			CTLTYPE_INT | CTLFLAG_RW, lio, LIO_SET_RING_RX,
-			lio_set_ringparam, "I", "Set RX ring parameter");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, lio, LIO_SET_RING_RX,
+	    lio_set_ringparam, "I", "Set RX ring parameter");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "txq_descriptors",
-			CTLTYPE_INT | CTLFLAG_RW, lio, LIO_SET_RING_TX,
-			lio_set_ringparam, "I", "Set TX ring parameter");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, lio, LIO_SET_RING_TX,
+	    lio_set_ringparam, "I", "Set TX ring parameter");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "max_rxq_descriptors",
-			CTLTYPE_INT | CTLFLAG_RD, lio, LIO_SET_RING_RX,
-			lio_get_ringparam, "I", "Max RX descriptors");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, lio, LIO_SET_RING_RX,
+	    lio_get_ringparam, "I", "Max RX descriptors");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "max_txq_descriptors",
-			CTLTYPE_INT | CTLFLAG_RD, lio, LIO_SET_RING_TX,
-			lio_get_ringparam, "I", "Max TX descriptors");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, lio, LIO_SET_RING_TX,
+	    lio_get_ringparam, "I", "Max TX descriptors");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "active_queues",
-			CTLTYPE_INT | CTLFLAG_RW, lio, 0, lio_set_channels,
-			"I", "Set channels information");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, lio, 0,
+	    lio_set_channels, "I", "Set channels information");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "max_queues",
-			CTLTYPE_INT | CTLFLAG_RD, lio, 0, lio_get_channels,
-			"I", "Get channels information");
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, lio, 0,
+	    lio_get_channels, "I", "Get channels information");
 	SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_budget",
 			CTLFLAG_RW, &oct_dev->tx_budget,
 			0, "TX process pkt budget");
@@ -206,7 +204,7 @@ lio_add_hw_stats(struct lio *lio)
 
 	/* IRQ Coalescing Parameters */
 	root_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "coalesce",
-				    CTLFLAG_RD, NULL, "Get and Set Coalesce");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Get and Set Coalesce");
 
 	root_list = SYSCTL_CHILDREN(root_node);
 
@@ -271,13 +269,13 @@ lio_add_hw_stats(struct lio *lio)
 			"QU", NULL);
 
 	/* Root Node of all the Stats */
-	root_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-				    NULL, "Root Node of all the Stats");
+	root_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Root Node of all the Stats");
 	root_list = SYSCTL_CHILDREN(root_node);
 
 	/* Firmware Tx Stats */
-	stat_node = SYSCTL_ADD_NODE(ctx, root_list, OID_AUTO, "fwtx",CTLFLAG_RD,
-				    NULL, "Firmware Tx Statistics");
+	stat_node = SYSCTL_ADD_NODE(ctx, root_list, OID_AUTO, "fwtx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Firmware Tx Statistics");
 	stat_list = SYSCTL_CHILDREN(stat_node);
 
 	SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "tx_total_sent", CTLFLAG_RD,
@@ -317,7 +315,7 @@ lio_add_hw_stats(struct lio *lio)
 
 	/* MAC Tx Stats */
 	stat_node = SYSCTL_ADD_NODE(ctx, root_list, OID_AUTO, "mactx",
-				    CTLFLAG_RD, NULL, "MAC Tx Statistics");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "MAC Tx Statistics");
 	stat_list = SYSCTL_CHILDREN(stat_node);
 
 	SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "mac_tx_total_pkts",
@@ -370,7 +368,7 @@ lio_add_hw_stats(struct lio *lio)
 
 	/* Firmware Rx Stats */
 	stat_node = SYSCTL_ADD_NODE(ctx, root_list, OID_AUTO, "fwrx",
-				    CTLFLAG_RD, NULL, "Firmware Rx Statistics");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Firmware Rx Statistics");
 	stat_list = SYSCTL_CHILDREN(stat_node);
 
 	SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "rx_total_rcvd", CTLFLAG_RD,
@@ -437,7 +435,7 @@ lio_add_hw_stats(struct lio *lio)
 			 "Firmware Rx Packets Forward Rate");
 	/* MAC Rx Stats */
 	stat_node = SYSCTL_ADD_NODE(ctx, root_list, OID_AUTO, "macrx",
-				    CTLFLAG_RD, NULL, "MAC Rx Statistics");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "MAC Rx Statistics");
 	stat_list = SYSCTL_CHILDREN(stat_node);
 
 	SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "mac_rx_total_rcvd",
@@ -484,7 +482,7 @@ lio_add_hw_stats(struct lio *lio)
 
 		snprintf(namebuf, QUEUE_NAME_LEN, "tx-%d", i);
 		queue_node = SYSCTL_ADD_NODE(ctx, root_list, OID_AUTO, namebuf,
-					     CTLFLAG_RD, NULL, "Input Queue Name");
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Input Queue Name");
 		queue_list = SYSCTL_CHILDREN(queue_node);
 
 		/* packets to network port */
@@ -567,8 +565,7 @@ lio_add_hw_stats(struct lio *lio)
 
 		snprintf(namebuf, QUEUE_NAME_LEN, "rx-%d", i);
 		queue_node = SYSCTL_ADD_NODE(ctx, root_list, OID_AUTO, namebuf,
-					     CTLFLAG_RD, NULL,
-					     "Output Queue Name");
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Output Queue Name");
 		queue_list = SYSCTL_CHILDREN(queue_node);
 
 		/* packets send to TCP/IP network stack */
diff --git a/sys/dev/malo/if_malo.c b/sys/dev/malo/if_malo.c
index a7823dd6003d..742c09436d96 100644
--- a/sys/dev/malo/if_malo.c
+++ b/sys/dev/malo/if_malo.c
@@ -64,7 +64,7 @@ __FBSDID("$FreeBSD$");
 
 #include <dev/malo/if_malo.h>
 
-SYSCTL_NODE(_hw, OID_AUTO, malo, CTLFLAG_RD, 0,
+SYSCTL_NODE(_hw, OID_AUTO, malo, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "Marvell 88w8335 driver parameters");
 
 static	int malo_txcoalesce = 8;	/* # tx pkts to q before poking f/w*/
diff --git a/sys/dev/malo/if_malo_pci.c b/sys/dev/malo/if_malo_pci.c
index 895bc179af10..0d1b7f9995a0 100644
--- a/sys/dev/malo/if_malo_pci.c
+++ b/sys/dev/malo/if_malo_pci.c
@@ -84,7 +84,7 @@ struct malo_pci_softc {
  * Tunable variables.
  */
 SYSCTL_DECL(_hw_malo);
-static SYSCTL_NODE(_hw_malo, OID_AUTO, pci, CTLFLAG_RD, 0,
+static SYSCTL_NODE(_hw_malo, OID_AUTO, pci, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "Marvell 88W8335 driver PCI parameters");
 
 static int msi_disable = 0;				/* MSI disabled  */
diff --git a/sys/dev/mfi/mfi.c b/sys/dev/mfi/mfi.c
index 46fe586e0b5f..a9cb001a58e2 100644
--- a/sys/dev/mfi/mfi.c
+++ b/sys/dev/mfi/mfi.c
@@ -130,7 +130,8 @@ static int mfi_check_command_pre(struct mfi_softc *sc, struct mfi_command *cm);
 static void mfi_check_command_post(struct mfi_softc *sc, struct mfi_command *cm);
 static int mfi_check_for_sscd(struct mfi_softc *sc, struct mfi_command *cm);
 
-SYSCTL_NODE(_hw, OID_AUTO, mfi, CTLFLAG_RD, 0, "MFI driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, mfi, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "MFI driver parameters");
 static int	mfi_event_locale = MFI_EVT_LOCALE_ALL;
 SYSCTL_INT(_hw_mfi, OID_AUTO, event_locale, CTLFLAG_RWTUN, &mfi_event_locale,
            0, "event message locale");
diff --git a/sys/dev/mge/if_mge.c b/sys/dev/mge/if_mge.c
index b7667af87248..dc044749ae72 100644
--- a/sys/dev/mge/if_mge.c
+++ b/sys/dev/mge/if_mge.c
@@ -2143,15 +2143,15 @@ mge_add_sysctls(struct mge_softc *sc)
 	ctx = device_get_sysctl_ctx(sc->dev);
 	children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));
 	tree = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "int_coal",
-	    CTLFLAG_RD, 0, "MGE Interrupts coalescing");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "MGE Interrupts coalescing");
 	children = SYSCTL_CHILDREN(tree);
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rx_time",
-	    CTLTYPE_UINT | CTLFLAG_RW, sc, MGE_IC_RX, mge_sysctl_ic,
-	    "I", "IC RX time threshold");
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, MGE_IC_RX,
+	    mge_sysctl_ic, "I", "IC RX time threshold");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tx_time",
-	    CTLTYPE_UINT | CTLFLAG_RW, sc, MGE_IC_TX, mge_sysctl_ic,
-	    "I", "IC TX time threshold");
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, MGE_IC_TX,
+	    mge_sysctl_ic, "I", "IC TX time threshold");
 }
 
 static int
diff --git a/sys/dev/mlx4/mlx4_core/mlx4_main.c b/sys/dev/mlx4/mlx4_core/mlx4_main.c
index cb5c655b13d6..14b563bb8ff1 100644
--- a/sys/dev/mlx4/mlx4_core/mlx4_main.c
+++ b/sys/dev/mlx4/mlx4_core/mlx4_main.c
@@ -3792,7 +3792,8 @@ static int mlx4_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 	ctx = &dev->hw_ctx;
 	sysctl_ctx_init(ctx);
 	node = SYSCTL_ADD_NODE(ctx,SYSCTL_CHILDREN(pdev->dev.kobj.oidp),
-	    OID_AUTO, "hw" , CTLFLAG_RD, 0, "mlx4 dev hw information");
+	    OID_AUTO, "hw" , CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+	    "mlx4 dev hw information");
 	if (node != NULL) {
 		node_list = SYSCTL_CHILDREN(node);
 		SYSCTL_ADD_STRING(ctx, node_list, OID_AUTO,
diff --git a/sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c b/sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c
index f7671d9f94e9..5f6199144def 100644
--- a/sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c
+++ b/sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c
@@ -2664,9 +2664,10 @@ static void mlx4_en_sysctl_conf(struct mlx4_en_priv *priv)
 
         sysctl_ctx_init(ctx);
         priv->conf_sysctl = SYSCTL_ADD_NODE(ctx, SYSCTL_STATIC_CHILDREN(_hw),
-            OID_AUTO, dev->if_xname, CTLFLAG_RD, 0, "mlx4 10gig ethernet");
+            OID_AUTO, dev->if_xname, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+	    "mlx4 10gig ethernet");
         node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(priv->conf_sysctl), OID_AUTO,
-            "conf", CTLFLAG_RD, NULL, "Configuration");
+            "conf", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Configuration");
         node_list = SYSCTL_CHILDREN(node);
 
         SYSCTL_ADD_UINT(ctx, node_list, OID_AUTO, "msg_enable",
@@ -2698,7 +2699,8 @@ static void mlx4_en_sysctl_conf(struct mlx4_en_priv *priv)
 	    "PCI device name");
         /* Add coalescer configuration. */
         coal = SYSCTL_ADD_NODE(ctx, node_list, OID_AUTO,
-            "coalesce", CTLFLAG_RD, NULL, "Interrupt coalesce configuration");
+            "coalesce", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+	    "Interrupt coalesce configuration");
         coal_list = SYSCTL_CHILDREN(coal);
         SYSCTL_ADD_UINT(ctx, coal_list, OID_AUTO, "pkt_rate_low",
             CTLFLAG_RW, &priv->pkt_rate_low, 0,
@@ -2738,7 +2740,7 @@ static void mlx4_en_sysctl_stat(struct mlx4_en_priv *priv)
 	ctx = &priv->stat_ctx;
 	sysctl_ctx_init(ctx);
 	priv->stat_sysctl = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(priv->conf_sysctl), OID_AUTO,
-	    "stat", CTLFLAG_RD, NULL, "Statistics");
+	    "stat", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Statistics");
 	node_list = SYSCTL_CHILDREN(priv->stat_sysctl);
 
 #ifdef MLX4_EN_PERF_STAT
@@ -2860,7 +2862,7 @@ static void mlx4_en_sysctl_stat(struct mlx4_en_priv *priv)
 		tx_ring = priv->tx_ring[i];
 		snprintf(namebuf, sizeof(namebuf), "tx_ring%d", i);
 		ring_node = SYSCTL_ADD_NODE(ctx, node_list, OID_AUTO, namebuf,
-		    CTLFLAG_RD, NULL, "TX Ring");
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX Ring");
 		ring_list = SYSCTL_CHILDREN(ring_node);
 		SYSCTL_ADD_U64(ctx, ring_list, OID_AUTO, "packets",
 		    CTLFLAG_RD, &tx_ring->packets, 0, "TX packets");
@@ -2877,7 +2879,7 @@ static void mlx4_en_sysctl_stat(struct mlx4_en_priv *priv)
 		rx_ring = priv->rx_ring[i];
 		snprintf(namebuf, sizeof(namebuf), "rx_ring%d", i);
 		ring_node = SYSCTL_ADD_NODE(ctx, node_list, OID_AUTO, namebuf,
-		    CTLFLAG_RD, NULL, "RX Ring");
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX Ring");
 		ring_list = SYSCTL_CHILDREN(ring_node);
 		SYSCTL_ADD_U64(ctx, ring_list, OID_AUTO, "packets",
 		    CTLFLAG_RD, &rx_ring->packets, 0, "RX packets");
diff --git a/sys/dev/mlx5/mlx5_core/mlx5_main.c b/sys/dev/mlx5/mlx5_core/mlx5_main.c
index f5809a285406..dba6733c4fe6 100644
--- a/sys/dev/mlx5/mlx5_core/mlx5_main.c
+++ b/sys/dev/mlx5/mlx5_core/mlx5_main.c
@@ -56,7 +56,8 @@ MODULE_DEPEND(mlx5, mlxfw, 1, 1, 1);
 MODULE_DEPEND(mlx5, firmware, 1, 1, 1);
 MODULE_VERSION(mlx5, 1);
 
-SYSCTL_NODE(_hw, OID_AUTO, mlx5, CTLFLAG_RW, 0, "mlx5 hardware controls");
+SYSCTL_NODE(_hw, OID_AUTO, mlx5, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "mlx5 hardware controls");
 
 int mlx5_core_debug_mask;
 SYSCTL_INT(_hw_mlx5, OID_AUTO, debug_mask, CTLFLAG_RWTUN,
@@ -1332,7 +1333,7 @@ static int init_one(struct pci_dev *pdev,
 
 	pme_sysctl_node = SYSCTL_ADD_NODE(&dev->sysctl_ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(bsddev)),
-	    OID_AUTO, "pme_stats", CTLFLAG_RD, NULL,
+	    OID_AUTO, "pme_stats", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
 	    "Port module event statistics");
 	if (pme_sysctl_node == NULL) {
 		err = -ENOMEM;
@@ -1340,7 +1341,7 @@ static int init_one(struct pci_dev *pdev,
 	}
 	pme_err_sysctl_node = SYSCTL_ADD_NODE(&dev->sysctl_ctx,
 	    SYSCTL_CHILDREN(pme_sysctl_node),
-	    OID_AUTO, "errors", CTLFLAG_RD, NULL,
+	    OID_AUTO, "errors", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
 	    "Port module event error statistics");
 	if (pme_err_sysctl_node == NULL) {
 		err = -ENOMEM;
diff --git a/sys/dev/mlx5/mlx5_en/mlx5_en_ethtool.c b/sys/dev/mlx5/mlx5_en/mlx5_en_ethtool.c
index 7e742fb9ab39..916102ee960f 100644
--- a/sys/dev/mlx5/mlx5_en/mlx5_en_ethtool.c
+++ b/sys/dev/mlx5/mlx5_en/mlx5_en_ethtool.c
@@ -39,7 +39,7 @@ mlx5e_create_stats(struct sysctl_ctx_list *ctx,
 	sysctl_ctx_init(ctx);
 
 	node = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO,
-	    buffer, CTLFLAG_RD, NULL, "Statistics");
+	    buffer, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Statistics");
 	if (node == NULL)
 		return;
 	for (x = 0; x != num; x++) {
@@ -59,7 +59,7 @@ mlx5e_create_counter_stats(struct sysctl_ctx_list *ctx,
 	sysctl_ctx_init(ctx);
 
 	node = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO,
-	    buffer, CTLFLAG_RD, NULL, "Statistics");
+	    buffer, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Statistics");
 	if (node == NULL)
 		return;
 	for (x = 0; x != num; x++) {
@@ -1317,7 +1317,7 @@ mlx5e_create_diagnostics(struct mlx5e_priv *priv)
 	/* create root node */
 	node = SYSCTL_ADD_NODE(ctx,
 	    SYSCTL_CHILDREN(priv->sysctl_ifnet), OID_AUTO,
-	    "diagnostics", CTLFLAG_RD, NULL, "Diagnostics");
+	    "diagnostics", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Diagnostics");
 	if (node == NULL)
 		return;
 
@@ -1389,7 +1389,7 @@ mlx5e_create_ethtool(struct mlx5e_priv *priv)
 	/* create root node */
 	node = SYSCTL_ADD_NODE(&priv->sysctl_ctx,
 	    SYSCTL_CHILDREN(priv->sysctl_ifnet), OID_AUTO,
-	    "conf", CTLFLAG_RW, NULL, "Configuration");
+	    "conf", CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, "Configuration");
 	if (node == NULL)
 		return;
 	for (x = 0; x != MLX5E_PARAMS_NUM; x++) {
@@ -1431,7 +1431,8 @@ mlx5e_create_ethtool(struct mlx5e_priv *priv)
 	/* create fec node */
 	fec_node = SYSCTL_ADD_NODE(&priv->sysctl_ctx,
 	    SYSCTL_CHILDREN(node), OID_AUTO,
-	    "fec", CTLFLAG_RW, NULL, "Forward Error Correction");
+	    "fec", CTLFLAG_RW | CTLFLAG_MPSAFE, NULL,
+	    "Forward Error Correction");
 	if (fec_node == NULL)
 		return;
 
@@ -1493,7 +1494,8 @@ mlx5e_create_ethtool(struct mlx5e_priv *priv)
 	/* create qos node */
 	qos_node = SYSCTL_ADD_NODE(&priv->sysctl_ctx,
 	    SYSCTL_CHILDREN(node), OID_AUTO,
-	    "qos", CTLFLAG_RW, NULL, "Quality Of Service configuration");
+	    "qos", CTLFLAG_RW | CTLFLAG_MPSAFE, NULL,
+	    "Quality Of Service configuration");
 	if (qos_node == NULL)
 		return;
 
diff --git a/sys/dev/mlx5/mlx5_en/mlx5_en_hw_tls.c b/sys/dev/mlx5/mlx5_en/mlx5_en_hw_tls.c
index 3ac35540368f..c96151383acc 100644
--- a/sys/dev/mlx5/mlx5_en/mlx5_en_hw_tls.c
+++ b/sys/dev/mlx5/mlx5_en/mlx5_en_hw_tls.c
@@ -143,7 +143,7 @@ mlx5e_tls_init(struct mlx5e_priv *priv)
 
 	node = SYSCTL_ADD_NODE(&priv->sysctl_ctx,
 	    SYSCTL_CHILDREN(priv->sysctl_ifnet), OID_AUTO,
-	    "tls", CTLFLAG_RW, NULL, "Hardware TLS offload");
+	    "tls", CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, "Hardware TLS offload");
 	if (node == NULL)
 		return (0);
 
diff --git a/sys/dev/mlx5/mlx5_en/mlx5_en_main.c b/sys/dev/mlx5/mlx5_en/mlx5_en_main.c
index 45aa824eae9b..951cbee61c2b 100644
--- a/sys/dev/mlx5/mlx5_en/mlx5_en_main.c
+++ b/sys/dev/mlx5/mlx5_en/mlx5_en_main.c
@@ -1108,7 +1108,7 @@ static int mlx5e_calibration_duration = 20;
 static int mlx5e_fast_calibration = 1;
 static int mlx5e_normal_calibration = 30;
 
-static SYSCTL_NODE(_hw_mlx5, OID_AUTO, calibr, CTLFLAG_RW, 0,
+static SYSCTL_NODE(_hw_mlx5, OID_AUTO, calibr, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
     "MLX5 timestamp calibration parameteres");
 
 SYSCTL_INT(_hw_mlx5_calibr, OID_AUTO, duration, CTLFLAG_RWTUN,
@@ -3843,8 +3843,8 @@ static void
 mlx5e_add_hw_stats(struct mlx5e_priv *priv)
 {
 	SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(priv->sysctl_hw),
-	    OID_AUTO, "fw_version", CTLTYPE_STRING | CTLFLAG_RD, priv, 0,
-	    sysctl_firmware, "A", "HCA firmware version");
+	    OID_AUTO, "fw_version", CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    priv, 0, sysctl_firmware, "A", "HCA firmware version");
 
 	SYSCTL_ADD_STRING(&priv->sysctl_ctx, SYSCTL_CHILDREN(priv->sysctl_hw),
 	    OID_AUTO, "board_id", CTLFLAG_RD, priv->mdev->board_id, 0,
@@ -4321,14 +4321,16 @@ mlx5e_create_ifp(struct mlx5_core_dev *mdev)
 	/* ifnet sysctl tree */
 	sysctl_ctx_init(&priv->sysctl_ctx);
 	priv->sysctl_ifnet = SYSCTL_ADD_NODE(&priv->sysctl_ctx, SYSCTL_STATIC_CHILDREN(_dev),
-	    OID_AUTO, ifp->if_dname, CTLFLAG_RD, 0, "MLX5 ethernet - interface name");
+	    OID_AUTO, ifp->if_dname, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+	    "MLX5 ethernet - interface name");
 	if (priv->sysctl_ifnet == NULL) {
 		mlx5_core_err(mdev, "SYSCTL_ADD_NODE() failed\n");
 		goto err_free_sysctl;
 	}
 	snprintf(unit, sizeof(unit), "%d", ifp->if_dunit);
 	priv->sysctl_ifnet = SYSCTL_ADD_NODE(&priv->sysctl_ctx, SYSCTL_CHILDREN(priv->sysctl_ifnet),
-	    OID_AUTO, unit, CTLFLAG_RD, 0, "MLX5 ethernet - interface unit");
+	    OID_AUTO, unit, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+	    "MLX5 ethernet - interface unit");
 	if (priv->sysctl_ifnet == NULL) {
 		mlx5_core_err(mdev, "SYSCTL_ADD_NODE() failed\n");
 		goto err_free_sysctl;
@@ -4337,7 +4339,8 @@ mlx5e_create_ifp(struct mlx5_core_dev *mdev)
 	/* HW sysctl tree */
 	child = SYSCTL_CHILDREN(device_get_sysctl_tree(mdev->pdev->dev.bsddev));
 	priv->sysctl_hw = SYSCTL_ADD_NODE(&priv->sysctl_ctx, child,
-	    OID_AUTO, "hw", CTLFLAG_RD, 0, "MLX5 ethernet dev hw");
+	    OID_AUTO, "hw", CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+	    "MLX5 ethernet dev hw");
 	if (priv->sysctl_hw == NULL) {
 		mlx5_core_err(mdev, "SYSCTL_ADD_NODE() failed\n");
 		goto err_free_sysctl;
diff --git a/sys/dev/mlx5/mlx5_en/mlx5_en_rl.c b/sys/dev/mlx5/mlx5_en/mlx5_en_rl.c
index be70af01a6d4..b60487c53636 100644
--- a/sys/dev/mlx5/mlx5_en/mlx5_en_rl.c
+++ b/sys/dev/mlx5/mlx5_en/mlx5_en_rl.c
@@ -770,7 +770,7 @@ mlx5e_rl_init(struct mlx5e_priv *priv)
 	/* create root node */
 	node = SYSCTL_ADD_NODE(&rl->ctx,
 	    SYSCTL_CHILDREN(priv->sysctl_ifnet), OID_AUTO,
-	    "rate_limit", CTLFLAG_RW, NULL, "Rate limiting support");
+	    "rate_limit", CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, "Rate limiting support");
 
 	if (node != NULL) {
 		/* create SYSCTLs */
@@ -782,7 +782,7 @@ mlx5e_rl_init(struct mlx5e_priv *priv)
 		}
 
 		stats = SYSCTL_ADD_NODE(&rl->ctx, SYSCTL_CHILDREN(node),
-		    OID_AUTO, "stats", CTLFLAG_RD, NULL,
+		    OID_AUTO, "stats", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
 		    "Rate limiting statistics");
 		if (stats != NULL) {
 			/* create SYSCTLs */
diff --git a/sys/dev/mlx5/mlx5_ib/mlx5_ib_cong.c b/sys/dev/mlx5/mlx5_ib/mlx5_ib_cong.c
index 14cac913779e..0fc6694bde82 100644
--- a/sys/dev/mlx5/mlx5_ib/mlx5_ib_cong.c
+++ b/sys/dev/mlx5/mlx5_ib/mlx5_ib_cong.c
@@ -423,12 +423,14 @@ mlx5_ib_init_congestion(struct mlx5_ib_dev *dev)
 		return (err);
 
 	parent = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(dev->ib_dev.dev.kobj.oidp),
-	    OID_AUTO, "cong", CTLFLAG_RW, NULL, "Congestion control");
+	    OID_AUTO, "cong", CTLFLAG_RW | CTLFLAG_MPSAFE, NULL,
+	    "Congestion control");
 	if (parent == NULL)
 		return (-ENOMEM);
 
 	node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(parent),
-	    OID_AUTO, "conf", CTLFLAG_RW, NULL, "Configuration");
+	    OID_AUTO, "conf", CTLFLAG_RW | CTLFLAG_MPSAFE, NULL,
+	    "Configuration");
 	if (node == NULL) {
 		sysctl_ctx_free(&dev->congestion.ctx);
 		return (-ENOMEM);
@@ -444,7 +446,8 @@ mlx5_ib_init_congestion(struct mlx5_ib_dev *dev)
 	}
 
 	node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(parent),
-	    OID_AUTO, "stats", CTLFLAG_RD, NULL, "Statistics");
+	    OID_AUTO, "stats", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+	    "Statistics");
 	if (node == NULL) {
 		sysctl_ctx_free(&dev->congestion.ctx);
 		return (-ENOMEM);
diff --git a/sys/dev/mmc/mmc.c b/sys/dev/mmc/mmc.c
index 5a318ffe8c68..e44dd11e7250 100644
--- a/sys/dev/mmc/mmc.c
+++ b/sys/dev/mmc/mmc.c
@@ -134,7 +134,8 @@ static const struct mmc_quirk mmc_quirks[] = {
 	{ 0x0, 0x0, NULL, 0x0 }
 };
 
-static SYSCTL_NODE(_hw, OID_AUTO, mmc, CTLFLAG_RD, NULL, "mmc driver");
+static SYSCTL_NODE(_hw, OID_AUTO, mmc, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+    "mmc driver");
 
 static int mmc_debug;
 SYSCTL_INT(_hw_mmc, OID_AUTO, debug, CTLFLAG_RWTUN, &mmc_debug, 0,
diff --git a/sys/dev/mmc/mmcsd.c b/sys/dev/mmc/mmcsd.c
index f9637ac4427f..2a55a9be1548 100644
--- a/sys/dev/mmc/mmcsd.c
+++ b/sys/dev/mmc/mmcsd.c
@@ -156,7 +156,8 @@ static const char *errmsg[] =
 	"NO MEMORY"
 };
 
-static SYSCTL_NODE(_hw, OID_AUTO, mmcsd, CTLFLAG_RD, NULL, "mmcsd driver");
+static SYSCTL_NODE(_hw, OID_AUTO, mmcsd, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+    "mmcsd driver");
 
 static int mmcsd_cache = 1;
 SYSCTL_INT(_hw_mmcsd, OID_AUTO, cache, CTLFLAG_RDTUN, &mmcsd_cache, 0,
diff --git a/sys/dev/mpr/mpr.c b/sys/dev/mpr/mpr.c
index c5b1a9c01811..9c61b5ebba95 100644
--- a/sys/dev/mpr/mpr.c
+++ b/sys/dev/mpr/mpr.c
@@ -112,7 +112,8 @@ static int mpr_debug_sysctl(SYSCTL_HANDLER_ARGS);
 static int mpr_dump_reqs(SYSCTL_HANDLER_ARGS);
 static void mpr_parse_debug(struct mpr_softc *sc, char *list);
 
-SYSCTL_NODE(_hw, OID_AUTO, mpr, CTLFLAG_RD, 0, "MPR Driver Parameters");
+SYSCTL_NODE(_hw, OID_AUTO, mpr, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "MPR Driver Parameters");
 
 MALLOC_DEFINE(M_MPR, "mpr", "mpr driver memory");
 
@@ -1799,7 +1800,7 @@ mpr_setup_sysctl(struct mpr_softc *sc)
 		sysctl_ctx_init(&sc->sysctl_ctx);
 		sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 		    SYSCTL_STATIC_CHILDREN(_hw_mpr), OID_AUTO, tmpstr2,
-		    CTLFLAG_RD, 0, tmpstr);
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, tmpstr);
 		if (sc->sysctl_tree == NULL)
 			return;
 		sysctl_ctx = &sc->sysctl_ctx;
@@ -1889,8 +1890,9 @@ mpr_setup_sysctl(struct mpr_softc *sc)
 	    "spinup after SATA ID error");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
-	    OID_AUTO, "dump_reqs", CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_SKIP, sc, 0,
-	    mpr_dump_reqs, "I", "Dump Active Requests");
+	    OID_AUTO, "dump_reqs",
+	    CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_SKIP | CTLFLAG_NEEDGIANT,
+	    sc, 0, mpr_dump_reqs, "I", "Dump Active Requests");
 
 	SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 	    OID_AUTO, "use_phy_num", CTLFLAG_RD, &sc->use_phynum, 0,
diff --git a/sys/dev/mps/mps.c b/sys/dev/mps/mps.c
index cff2e2aa080d..9802296f06f8 100644
--- a/sys/dev/mps/mps.c
+++ b/sys/dev/mps/mps.c
@@ -110,7 +110,8 @@ static int mps_debug_sysctl(SYSCTL_HANDLER_ARGS);
 static int mps_dump_reqs(SYSCTL_HANDLER_ARGS);
 static void mps_parse_debug(struct mps_softc *sc, char *list);
 
-SYSCTL_NODE(_hw, OID_AUTO, mps, CTLFLAG_RD, 0, "MPS Driver Parameters");
+SYSCTL_NODE(_hw, OID_AUTO, mps, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "MPS Driver Parameters");
 
 MALLOC_DEFINE(M_MPT2, "mps", "mpt2 driver memory");
 MALLOC_DECLARE(M_MPSUSER);
@@ -1704,7 +1705,7 @@ mps_setup_sysctl(struct mps_softc *sc)
 		sysctl_ctx_init(&sc->sysctl_ctx);
 		sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 		    SYSCTL_STATIC_CHILDREN(_hw_mps), OID_AUTO, tmpstr2,
-		    CTLFLAG_RD, 0, tmpstr);
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, tmpstr);
 		if (sc->sysctl_tree == NULL)
 			return;
 		sysctl_ctx = &sc->sysctl_ctx;
@@ -1798,16 +1799,19 @@ mps_setup_sysctl(struct mps_softc *sc)
 	    "spinup after SATA ID error");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
-	    OID_AUTO, "mapping_table_dump", CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    OID_AUTO, "mapping_table_dump",
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    mps_mapping_dump, "A", "Mapping Table Dump");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
-	    OID_AUTO, "encl_table_dump", CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
+	    OID_AUTO, "encl_table_dump",
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    mps_mapping_encl_dump, "A", "Enclosure Table Dump");
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
-	    OID_AUTO, "dump_reqs", CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_SKIP, sc, 0,
-	    mps_dump_reqs, "I", "Dump Active Requests");
+	    OID_AUTO, "dump_reqs",
+	    CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_SKIP | CTLFLAG_NEEDGIANT,
+	    sc, 0, mps_dump_reqs, "I", "Dump Active Requests");
 
 	SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 	    OID_AUTO, "use_phy_num", CTLFLAG_RD, &sc->use_phynum, 0,
diff --git a/sys/dev/mpt/mpt_raid.c b/sys/dev/mpt/mpt_raid.c
index 5aa5fe6a613b..84fb951749b0 100644
--- a/sys/dev/mpt/mpt_raid.c
+++ b/sys/dev/mpt/mpt_raid.c
@@ -1826,19 +1826,19 @@ mpt_raid_sysctl_attach(struct mpt_softc *mpt)
 	struct sysctl_oid *tree = device_get_sysctl_tree(mpt->dev);
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"vol_member_wce", CTLTYPE_STRING | CTLFLAG_RW, mpt, 0,
-			mpt_raid_sysctl_vol_member_wce, "A",
-			"volume member WCE(On,Off,On-During-Rebuild,NC)");
+	    "vol_member_wce", CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    mpt, 0, mpt_raid_sysctl_vol_member_wce, "A",
+	    "volume member WCE(On,Off,On-During-Rebuild,NC)");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"vol_queue_depth", CTLTYPE_INT | CTLFLAG_RW, mpt, 0,
-			mpt_raid_sysctl_vol_queue_depth, "I",
-			"default volume queue depth");
+	    "vol_queue_depth", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    mpt, 0, mpt_raid_sysctl_vol_queue_depth, "I",
+	    "default volume queue depth");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"vol_resync_rate", CTLTYPE_INT | CTLFLAG_RW, mpt, 0,
-			mpt_raid_sysctl_vol_resync_rate, "I",
-			"volume resync priority (0 == NC, 1 - 255)");
+	    "vol_resync_rate", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    mpt, 0, mpt_raid_sysctl_vol_resync_rate, "I",
+	    "volume resync priority (0 == NC, 1 - 255)");
 	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
 			"nonoptimal_volumes", CTLFLAG_RD,
 			&mpt->raid_nonopt_volumes, 0,
diff --git a/sys/dev/mrsas/mrsas.c b/sys/dev/mrsas/mrsas.c
index 00e8b6aa2cd2..3172803dbf64 100644
--- a/sys/dev/mrsas/mrsas.c
+++ b/sys/dev/mrsas/mrsas.c
@@ -178,7 +178,8 @@ mrsas_write_64bit_req_desc(struct mrsas_softc *sc, u_int32_t req_desc_lo,
     u_int32_t req_desc_hi);
 
 
-SYSCTL_NODE(_hw, OID_AUTO, mrsas, CTLFLAG_RD, 0, "MRSAS Driver Parameters");
+SYSCTL_NODE(_hw, OID_AUTO, mrsas, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "MRSAS Driver Parameters");
 
 /*
  * PCI device struct and table
@@ -429,7 +430,7 @@ mrsas_setup_sysctl(struct mrsas_softc *sc)
 		sysctl_ctx_init(&sc->sysctl_ctx);
 		sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 		    SYSCTL_STATIC_CHILDREN(_hw_mrsas), OID_AUTO, tmpstr2,
-		    CTLFLAG_RD, 0, tmpstr);
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, tmpstr);
 		if (sc->sysctl_tree == NULL)
 			return;
 		sysctl_ctx = &sc->sysctl_ctx;
diff --git a/sys/dev/msk/if_msk.c b/sys/dev/msk/if_msk.c
index 307d9aec35c7..cf206c8f7971 100644
--- a/sys/dev/msk/if_msk.c
+++ b/sys/dev/msk/if_msk.c
@@ -1798,7 +1798,8 @@ mskc_attach(device_t dev)
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-	    OID_AUTO, "process_limit", CTLTYPE_INT | CTLFLAG_RW,
+	    OID_AUTO, "process_limit",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    &sc->msk_process_limit, 0, sysctl_hw_msk_proc_limit, "I",
 	    "max number of Rx events to process");
 
@@ -4480,11 +4481,13 @@ msk_sysctl_stat64(SYSCTL_HANDLER_ARGS)
 #undef MSK_READ_MIB64
 
 #define MSK_SYSCTL_STAT32(sc, c, o, p, n, d) 				\
-	SYSCTL_ADD_PROC(c, p, OID_AUTO, o, CTLTYPE_UINT | CTLFLAG_RD, 	\
+	SYSCTL_ADD_PROC(c, p, OID_AUTO, o,				\
+	    CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,	 	\
 	    sc, offsetof(struct msk_hw_stats, n), msk_sysctl_stat32,	\
 	    "IU", d)
 #define MSK_SYSCTL_STAT64(sc, c, o, p, n, d) 				\
-	SYSCTL_ADD_PROC(c, p, OID_AUTO, o, CTLTYPE_U64 | CTLFLAG_RD, 	\
+	SYSCTL_ADD_PROC(c, p, OID_AUTO, o,				\
+	    CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT,	 	\
 	    sc, offsetof(struct msk_hw_stats, n), msk_sysctl_stat64,	\
 	    "QU", d)
 
@@ -4498,11 +4501,11 @@ msk_sysctl_node(struct msk_if_softc *sc_if)
 	ctx = device_get_sysctl_ctx(sc_if->msk_if_dev);
 	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc_if->msk_if_dev));
 
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "MSK Statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "MSK Statistics");
 	schild = SYSCTL_CHILDREN(tree);
-	tree = SYSCTL_ADD_NODE(ctx, schild, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "MSK RX Statistics");
+	tree = SYSCTL_ADD_NODE(ctx, schild, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "MSK RX Statistics");
 	child = SYSCTL_CHILDREN(tree);
 	MSK_SYSCTL_STAT32(sc_if, ctx, "ucast_frames",
 	    child, rx_ucast_frames, "Good unicast frames");
@@ -4539,8 +4542,8 @@ msk_sysctl_node(struct msk_if_softc *sc_if)
 	MSK_SYSCTL_STAT32(sc_if, ctx, "overflows",
 	    child, rx_fifo_oflows, "FIFO overflows");
 
-	tree = SYSCTL_ADD_NODE(ctx, schild, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "MSK TX Statistics");
+	tree = SYSCTL_ADD_NODE(ctx, schild, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "MSK TX Statistics");
 	child = SYSCTL_CHILDREN(tree);
 	MSK_SYSCTL_STAT32(sc_if, ctx, "ucast_frames",
 	    child, tx_ucast_frames, "Unicast frames");
diff --git a/sys/dev/mwl/if_mwl.c b/sys/dev/mwl/if_mwl.c
index 9918366f2c75..2e98db0201c9 100644
--- a/sys/dev/mwl/if_mwl.c
+++ b/sys/dev/mwl/if_mwl.c
@@ -188,7 +188,8 @@ static int	mwl_getchannels(struct mwl_softc *);
 static void	mwl_sysctlattach(struct mwl_softc *);
 static void	mwl_announce(struct mwl_softc *);
 
-SYSCTL_NODE(_hw, OID_AUTO, mwl, CTLFLAG_RD, 0, "Marvell driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, mwl, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Marvell driver parameters");
 
 static	int mwl_rxdesc = MWL_RXDESC;		/* # rx desc's to allocate */
 SYSCTL_INT(_hw_mwl, OID_AUTO, rxdesc, CTLFLAG_RW, &mwl_rxdesc,
@@ -4787,9 +4788,9 @@ mwl_sysctlattach(struct mwl_softc *sc)
 	struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
 
 	sc->sc_debug = mwl_debug;
-	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-		"debug", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
-		mwl_sysctl_debug, "I", "control debugging printfs");
+	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "debug",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    mwl_sysctl_debug, "I", "control debugging printfs");
 #endif
 }
 
diff --git a/sys/dev/mwl/mwlhal.c b/sys/dev/mwl/mwlhal.c
index d66941919288..4e341f49e85e 100644
--- a/sys/dev/mwl/mwlhal.c
+++ b/sys/dev/mwl/mwlhal.c
@@ -192,7 +192,7 @@ static void dumpresult(struct mwl_hal_priv *, int showresult);
 #endif /* MWLHAL_DEBUG */
 
 SYSCTL_DECL(_hw_mwl);
-static SYSCTL_NODE(_hw_mwl, OID_AUTO, hal, CTLFLAG_RD, 0,
+static SYSCTL_NODE(_hw_mwl, OID_AUTO, hal, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "Marvell HAL parameters");
 
 static __inline void
diff --git a/sys/dev/mxge/if_mxge.c b/sys/dev/mxge/if_mxge.c
index 146d64ec188d..3364b29fecad 100644
--- a/sys/dev/mxge/if_mxge.c
+++ b/sys/dev/mxge/if_mxge.c
@@ -1507,22 +1507,19 @@ mxge_add_sysctls(mxge_softc_t *sc)
 
 	/* performance related tunables */
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"intr_coal_delay",
-			CTLTYPE_INT|CTLFLAG_RW, sc,
-			0, mxge_change_intr_coal,
-			"I", "interrupt coalescing delay in usecs");
+	    "intr_coal_delay", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
+	    sc, 0, mxge_change_intr_coal, "I",
+	    "interrupt coalescing delay in usecs");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"throttle",
-			CTLTYPE_INT|CTLFLAG_RW, sc,
-			0, mxge_change_throttle,
-			"I", "transmit throttling");
+	    "throttle", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
+	    mxge_change_throttle, "I", "transmit throttling");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"flow_control_enabled",
-			CTLTYPE_INT|CTLFLAG_RW, sc,
-			0, mxge_change_flow_control,
-			"I", "interrupt coalescing delay in usecs");
+	    "flow_control_enabled",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
+	    mxge_change_flow_control, "I",
+	    "interrupt coalescing delay in usecs");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
 		       "deassert_wait",
@@ -1532,77 +1529,61 @@ mxge_add_sysctls(mxge_softc_t *sc)
 	/* stats block from firmware is in network byte order.
 	   Need to swap it */
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"link_up",
-			CTLTYPE_INT|CTLFLAG_RD, &fw->link_up,
-			0, mxge_handle_be32,
-			"I", "link up");
+	    "link_up", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->link_up, 0, mxge_handle_be32, "I", "link up");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"rdma_tags_available",
-			CTLTYPE_INT|CTLFLAG_RD, &fw->rdma_tags_available,
-			0, mxge_handle_be32,
-			"I", "rdma_tags_available");
+	    "rdma_tags_available", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->rdma_tags_available, 0, mxge_handle_be32, "I",
+	    "rdma_tags_available");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_bad_crc32",
-			CTLTYPE_INT|CTLFLAG_RD,
-			&fw->dropped_bad_crc32,
-			0, mxge_handle_be32,
-			"I", "dropped_bad_crc32");
+	    "dropped_bad_crc32", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_bad_crc32, 0, mxge_handle_be32, "I",
+	    "dropped_bad_crc32");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_bad_phy",
-			CTLTYPE_INT|CTLFLAG_RD,
-			&fw->dropped_bad_phy,
-			0, mxge_handle_be32,
-			"I", "dropped_bad_phy");
+	    "dropped_bad_phy", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_bad_phy, 0, mxge_handle_be32, "I", "dropped_bad_phy");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_link_error_or_filtered",
-			CTLTYPE_INT|CTLFLAG_RD,
-			&fw->dropped_link_error_or_filtered,
-			0, mxge_handle_be32,
-			"I", "dropped_link_error_or_filtered");
+	    "dropped_link_error_or_filtered",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_link_error_or_filtered, 0, mxge_handle_be32, "I",
+	    "dropped_link_error_or_filtered");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_link_overflow",
-			CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_link_overflow,
-			0, mxge_handle_be32,
-			"I", "dropped_link_overflow");
+	    "dropped_link_overflow",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_link_overflow, 0, mxge_handle_be32, "I",
+	    "dropped_link_overflow");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_multicast_filtered",
-			CTLTYPE_INT|CTLFLAG_RD,
-			&fw->dropped_multicast_filtered,
-			0, mxge_handle_be32,
-			"I", "dropped_multicast_filtered");
+	    "dropped_multicast_filtered",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_multicast_filtered, 0, mxge_handle_be32, "I",
+	    "dropped_multicast_filtered");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_no_big_buffer",
-			CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_no_big_buffer,
-			0, mxge_handle_be32,
-			"I", "dropped_no_big_buffer");
+	    "dropped_no_big_buffer",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_no_big_buffer, 0, mxge_handle_be32, "I",
+	    "dropped_no_big_buffer");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_no_small_buffer",
-			CTLTYPE_INT|CTLFLAG_RD,
-			&fw->dropped_no_small_buffer,
-			0, mxge_handle_be32,
-			"I", "dropped_no_small_buffer");
+	    "dropped_no_small_buffer",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_no_small_buffer, 0, mxge_handle_be32, "I",
+	    "dropped_no_small_buffer");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_overrun",
-			CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_overrun,
-			0, mxge_handle_be32,
-			"I", "dropped_overrun");
+	    "dropped_overrun",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_overrun, 0, mxge_handle_be32, "I",
+	    "dropped_overrun");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_pause",
-			CTLTYPE_INT|CTLFLAG_RD,
-			&fw->dropped_pause,
-			0, mxge_handle_be32,
-			"I", "dropped_pause");
+	    "dropped_pause", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_pause, 0, mxge_handle_be32, "I", "dropped_pause");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_runt",
-			CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_runt,
-			0, mxge_handle_be32,
-			"I", "dropped_runt");
+	    "dropped_runt", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_runt, 0, mxge_handle_be32, "I", "dropped_runt");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-			"dropped_unicast_filtered",
-			CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_unicast_filtered,
-			0, mxge_handle_be32,
-			"I", "dropped_unicast_filtered");
+	    "dropped_unicast_filtered",
+	    CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+	    &fw->dropped_unicast_filtered, 0, mxge_handle_be32, "I",
+	    "dropped_unicast_filtered");
 
 	/* verbose printing? */
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
@@ -1614,7 +1595,7 @@ mxge_add_sysctls(mxge_softc_t *sc)
 	sysctl_ctx_init(&sc->slice_sysctl_ctx);
 	sc->slice_sysctl_tree =
 		SYSCTL_ADD_NODE(&sc->slice_sysctl_ctx, children, OID_AUTO,
-				"slice", CTLFLAG_RD, 0, "");
+		    "slice", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
 
 	for (slice = 0; slice < sc->num_slices; slice++) {
 		ss = &sc->ss[slice];
@@ -1624,7 +1605,7 @@ mxge_add_sysctls(mxge_softc_t *sc)
 		sprintf(slice_num, "%d", slice);
 		ss->sysctl_tree =
 			SYSCTL_ADD_NODE(ctx, children, OID_AUTO, slice_num,
-					CTLFLAG_RD, 0, "");
+			    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
 		children = SYSCTL_CHILDREN(ss->sysctl_tree);
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO,
 			       "rx_small_cnt",
diff --git a/sys/dev/neta/if_mvneta.c b/sys/dev/neta/if_mvneta.c
index 88926331f143..fbf7ade862c4 100644
--- a/sys/dev/neta/if_mvneta.c
+++ b/sys/dev/neta/if_mvneta.c
@@ -3479,10 +3479,10 @@ sysctl_mvneta_init(struct mvneta_softc *sc)
 	children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));
 
 	tree = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "rx",
-	    CTLFLAG_RD, 0, "NETA RX");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "NETA RX");
 	rxchildren = SYSCTL_CHILDREN(tree);
 	tree = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "mib",
-	    CTLFLAG_RD, 0, "NETA MIB");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "NETA MIB");
 	mchildren = SYSCTL_CHILDREN(tree);
 
 
@@ -3502,8 +3502,9 @@ sysctl_mvneta_init(struct mvneta_softc *sc)
 		mib_arg->index = i;
 		SYSCTL_ADD_PROC(ctx, mchildren, OID_AUTO,
 		    mvneta_mib_list[i].sysctl_name,
-		    CTLTYPE_U64|CTLFLAG_RD, (void *)mib_arg, 0,
-		    sysctl_read_mib, "I", mvneta_mib_list[i].desc);
+		    CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+		    (void *)mib_arg, 0, sysctl_read_mib, "I",
+		    mvneta_mib_list[i].desc);
 	}
 	SYSCTL_ADD_UQUAD(ctx, mchildren, OID_AUTO, "rx_discard",
 	    CTLFLAG_RD, &sc->counter_pdfc, "Port Rx Discard Frame Counter");
@@ -3513,8 +3514,8 @@ sysctl_mvneta_init(struct mvneta_softc *sc)
 	    CTLFLAG_RD, &sc->counter_watchdog, 0, "TX Watchdog Counter");
 
 	SYSCTL_ADD_PROC(ctx, mchildren, OID_AUTO, "reset",
-	    CTLTYPE_INT|CTLFLAG_RW, (void *)sc, 0,
-	    sysctl_clear_mib, "I", "Reset MIB counters");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    (void *)sc, 0, sysctl_clear_mib, "I", "Reset MIB counters");
 
 	for (q = 0; q < MVNETA_RX_QNUM_MAX; q++) {
 		rxarg = &sc->sysctl_rx_queue[q];
@@ -3525,13 +3526,13 @@ sysctl_mvneta_init(struct mvneta_softc *sc)
 
 		/* hw.mvneta.mvneta[unit].rx.[queue] */
 		tree = SYSCTL_ADD_NODE(ctx, rxchildren, OID_AUTO,
-		    sysctl_queue_names[q], CTLFLAG_RD, 0,
+		    sysctl_queue_names[q], CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
 		    sysctl_queue_descrs[q]);
 		qchildren = SYSCTL_CHILDREN(tree);
 
 		/* hw.mvneta.mvneta[unit].rx.[queue].threshold_timer_us */
 		SYSCTL_ADD_PROC(ctx, qchildren, OID_AUTO, "threshold_timer_us",
-		    CTLTYPE_UINT | CTLFLAG_RW, rxarg, 0,
+		    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, rxarg, 0,
 		    sysctl_set_queue_rxthtime, "I",
 		    "interrupt coalescing threshold timer [us]");
 	}
diff --git a/sys/dev/netmap/netmap.c b/sys/dev/netmap/netmap.c
index 4edcc58cbe0b..701263168305 100644
--- a/sys/dev/netmap/netmap.c
+++ b/sys/dev/netmap/netmap.c
@@ -540,7 +540,8 @@ int ptnet_vnet_hdr = 1;
 SYSBEGIN(main_init);
 
 SYSCTL_DECL(_dev_netmap);
-SYSCTL_NODE(_dev, OID_AUTO, netmap, CTLFLAG_RW, 0, "Netmap args");
+SYSCTL_NODE(_dev, OID_AUTO, netmap, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "Netmap args");
 SYSCTL_INT(_dev_netmap, OID_AUTO, verbose,
 		CTLFLAG_RW, &netmap_verbose, 0, "Verbose mode");
 #ifdef CONFIG_NETMAP_DEBUG
diff --git a/sys/dev/nfe/if_nfe.c b/sys/dev/nfe/if_nfe.c
index 246e257e3b2b..ade2002551dc 100644
--- a/sys/dev/nfe/if_nfe.c
+++ b/sys/dev/nfe/if_nfe.c
@@ -3121,8 +3121,8 @@ nfe_sysctl_node(struct nfe_softc *sc)
 	stats = &sc->nfe_stats;
 	ctx = device_get_sysctl_ctx(sc->nfe_dev);
 	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->nfe_dev));
-	SYSCTL_ADD_PROC(ctx, child,
-	    OID_AUTO, "process_limit", CTLTYPE_INT | CTLFLAG_RW,
+	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "process_limit",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    &sc->nfe_process_limit, 0, sysctl_hw_nfe_proc_limit, "I",
 	    "max number of Rx events to process");
 
@@ -3143,13 +3143,13 @@ nfe_sysctl_node(struct nfe_softc *sc)
 	if ((sc->nfe_flags & (NFE_MIB_V1 | NFE_MIB_V2 | NFE_MIB_V3)) == 0)
 		return;
 
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "NFE statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "NFE statistics");
 	parent = SYSCTL_CHILDREN(tree);
 
 	/* Rx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "Rx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Rx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 
 	NFE_SYSCTL_STAT_ADD32(ctx, child, "frame_errors",
@@ -3186,8 +3186,8 @@ nfe_sysctl_node(struct nfe_softc *sc)
 	}
 
 	/* Tx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "Tx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Tx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	NFE_SYSCTL_STAT_ADD64(ctx, child, "octets",
 	    &stats->tx_octets, "Octets");
diff --git a/sys/dev/nge/if_nge.c b/sys/dev/nge/if_nge.c
index fe1e29e8d47d..c099896d7bc8 100644
--- a/sys/dev/nge/if_nge.c
+++ b/sys/dev/nge/if_nge.c
@@ -2652,8 +2652,8 @@ nge_sysctl_node(struct nge_softc *sc)
 	ctx = device_get_sysctl_ctx(sc->nge_dev);
 	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->nge_dev));
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_holdoff",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->nge_int_holdoff, 0,
-	    sysctl_hw_nge_int_holdoff, "I", "NGE interrupt moderation");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->nge_int_holdoff,
+	    0, sysctl_hw_nge_int_holdoff, "I", "NGE interrupt moderation");
 	/* Pull in device tunables. */
 	sc->nge_int_holdoff = NGE_INT_HOLDOFF_DEFAULT;
 	error = resource_int_value(device_get_name(sc->nge_dev),
@@ -2671,13 +2671,13 @@ nge_sysctl_node(struct nge_softc *sc)
 	}
 
 	stats = &sc->nge_stats;
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "NGE statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "NGE statistics");
 	parent = SYSCTL_CHILDREN(tree);
 
 	/* Rx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "Rx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Rx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	NGE_SYSCTL_STAT_ADD32(ctx, child, "pkts_errs",
 	    &stats->rx_pkts_errs,
@@ -2701,8 +2701,8 @@ nge_sysctl_node(struct nge_softc *sc)
 	    &stats->rx_pause, "Pause frames");
 
 	/* Tx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "Tx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Tx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	NGE_SYSCTL_STAT_ADD32(ctx, child, "pause",
 	    &stats->tx_pause, "Pause frames");
diff --git a/sys/dev/ntb/if_ntb/if_ntb.c b/sys/dev/ntb/if_ntb/if_ntb.c
index 3bae01aae49d..2724db4f8a06 100644
--- a/sys/dev/ntb/if_ntb/if_ntb.c
+++ b/sys/dev/ntb/if_ntb/if_ntb.c
@@ -75,7 +75,8 @@ __FBSDID("$FreeBSD$");
 				    CSUM_IP_CHECKED | CSUM_IP_VALID | \
 				    CSUM_SCTP_VALID)
 
-static SYSCTL_NODE(_hw, OID_AUTO, if_ntb, CTLFLAG_RW, 0, "if_ntb");
+static SYSCTL_NODE(_hw, OID_AUTO, if_ntb, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "if_ntb");
 
 static unsigned g_if_ntb_num_queues = UINT_MAX;
 SYSCTL_UINT(_hw_if_ntb, OID_AUTO, num_queues, CTLFLAG_RWTUN,
diff --git a/sys/dev/ntb/ntb.c b/sys/dev/ntb/ntb.c
index ca71e99de190..d6b564725aaf 100644
--- a/sys/dev/ntb/ntb.c
+++ b/sys/dev/ntb/ntb.c
@@ -39,7 +39,8 @@ __FBSDID("$FreeBSD$");
 #include "ntb.h"
 
 devclass_t ntb_hw_devclass;
-SYSCTL_NODE(_hw, OID_AUTO, ntb, CTLFLAG_RW, 0, "NTB sysctls");
+SYSCTL_NODE(_hw, OID_AUTO, ntb, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "NTB sysctls");
 
 struct ntb_child {
 	device_t	dev;
diff --git a/sys/dev/ntb/ntb_hw/ntb_hw_intel.c b/sys/dev/ntb/ntb_hw/ntb_hw_intel.c
index 441093146fa2..9182461fe9a5 100644
--- a/sys/dev/ntb/ntb_hw/ntb_hw_intel.c
+++ b/sys/dev/ntb/ntb_hw/ntb_hw_intel.c
@@ -583,7 +583,7 @@ static struct ntb_b2b_addr xeon_b2b_dsd_addr = {
 	.bar5_addr32 = XEON_B2B_BAR5_ADDR32,
 };
 
-SYSCTL_NODE(_hw_ntb, OID_AUTO, xeon_b2b, CTLFLAG_RW, 0,
+SYSCTL_NODE(_hw_ntb, OID_AUTO, xeon_b2b, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
     "B2B MW segment overrides -- MUST be the same on both sides");
 
 SYSCTL_UQUAD(_hw_ntb_xeon_b2b, OID_AUTO, usd_bar2_addr64, CTLFLAG_RDTUN,
@@ -2225,7 +2225,7 @@ intel_ntb_link_sta_width(struct ntb_softc *ntb)
 	return (NTB_LNK_STA_WIDTH(ntb->lnk_sta));
 }
 
-SYSCTL_NODE(_hw_ntb, OID_AUTO, debug_info, CTLFLAG_RW, 0,
+SYSCTL_NODE(_hw_ntb, OID_AUTO, debug_info, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
     "Driver state, statistics, and HW registers");
 
 #define NTB_REGSZ_MASK	(3ul << 30)
@@ -2249,18 +2249,21 @@ intel_ntb_sysctl_init(struct ntb_softc *ntb)
 	globals = SYSCTL_CHILDREN(device_get_sysctl_tree(ntb->device));
 
 	SYSCTL_ADD_PROC(ctx, globals, OID_AUTO, "link_status",
-	    CTLFLAG_RD | CTLTYPE_STRING, ntb, 0,
+	    CTLFLAG_RD | CTLTYPE_STRING | CTLFLAG_NEEDGIANT, ntb, 0,
 	    sysctl_handle_link_status_human, "A",
 	    "Link status (human readable)");
 	SYSCTL_ADD_PROC(ctx, globals, OID_AUTO, "active",
-	    CTLFLAG_RD | CTLTYPE_UINT, ntb, 0, sysctl_handle_link_status,
-	    "IU", "Link status (1=active, 0=inactive)");
+	    CTLFLAG_RD | CTLTYPE_UINT | CTLFLAG_NEEDGIANT, ntb, 0,
+	    sysctl_handle_link_status, "IU",
+	    "Link status (1=active, 0=inactive)");
 	SYSCTL_ADD_PROC(ctx, globals, OID_AUTO, "admin_up",
-	    CTLFLAG_RW | CTLTYPE_UINT, ntb, 0, sysctl_handle_link_admin,
-	    "IU", "Set/get interface status (1=UP, 0=DOWN)");
+	    CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT, ntb, 0,
+	    sysctl_handle_link_admin, "IU",
+	    "Set/get interface status (1=UP, 0=DOWN)");
 
 	tree = SYSCTL_ADD_NODE(ctx, globals, OID_AUTO, "debug_info",
-	    CTLFLAG_RD, NULL, "Driver state, statistics, and HW registers");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+	    "Driver state, statistics, and HW registers");
 	tree_par = SYSCTL_CHILDREN(tree);
 
 	SYSCTL_ADD_UINT(ctx, tree_par, OID_AUTO, "conn_type", CTLFLAG_RD,
@@ -2280,8 +2283,8 @@ intel_ntb_sysctl_init(struct ntb_softc *ntb)
 	}
 
 	SYSCTL_ADD_PROC(ctx, tree_par, OID_AUTO, "features",
-	    CTLFLAG_RD | CTLTYPE_STRING, ntb, 0, sysctl_handle_features, "A",
-	    "Features/errata of this NTB device");
+	    CTLFLAG_RD | CTLTYPE_STRING | CTLFLAG_NEEDGIANT, ntb, 0,
+	    sysctl_handle_features, "A", "Features/errata of this NTB device");
 
 	SYSCTL_ADD_UINT(ctx, tree_par, OID_AUTO, "ntb_ctl", CTLFLAG_RD,
 	    __DEVOLATILE(uint32_t *, &ntb->ntb_ctl), 0,
@@ -2309,67 +2312,68 @@ intel_ntb_sysctl_init(struct ntb_softc *ntb)
 	    &ntb->db_mask, "Doorbell mask (cached)");
 
 	tmptree = SYSCTL_ADD_NODE(ctx, tree_par, OID_AUTO, "registers",
-	    CTLFLAG_RD, NULL, "Raw HW registers (big-endian)");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+	    "Raw HW registers (big-endian)");
 	regpar = SYSCTL_CHILDREN(tmptree);
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "ntbcntl",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb, NTB_REG_32 |
-	    ntb->reg->ntb_ctl, sysctl_handle_register, "IU",
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
+	    NTB_REG_32 | ntb->reg->ntb_ctl, sysctl_handle_register, "IU",
 	    "NTB Control register");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "lnkcap",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb, NTB_REG_32 |
-	    0x19c, sysctl_handle_register, "IU",
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
+	    NTB_REG_32 | 0x19c, sysctl_handle_register, "IU",
 	    "NTB Link Capabilities");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "lnkcon",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb, NTB_REG_32 |
-	    0x1a0, sysctl_handle_register, "IU",
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
+	    NTB_REG_32 | 0x1a0, sysctl_handle_register, "IU",
 	    "NTB Link Control register");
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "db_mask",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_64 | NTB_DB_READ | ntb->self_reg->db_mask,
 	    sysctl_handle_register, "QU", "Doorbell mask register");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "db_bell",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_64 | NTB_DB_READ | ntb->self_reg->db_bell,
 	    sysctl_handle_register, "QU", "Doorbell register");
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_xlat23",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_64 | ntb->xlat_reg->bar2_xlat,
 	    sysctl_handle_register, "QU", "Incoming XLAT23 register");
 	if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_xlat4",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_32 | ntb->xlat_reg->bar4_xlat,
 		    sysctl_handle_register, "IU", "Incoming XLAT4 register");
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_xlat5",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_32 | ntb->xlat_reg->bar5_xlat,
 		    sysctl_handle_register, "IU", "Incoming XLAT5 register");
 	} else {
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_xlat45",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_64 | ntb->xlat_reg->bar4_xlat,
 		    sysctl_handle_register, "QU", "Incoming XLAT45 register");
 	}
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_lmt23",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_64 | ntb->xlat_reg->bar2_limit,
 	    sysctl_handle_register, "QU", "Incoming LMT23 register");
 	if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_lmt4",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_32 | ntb->xlat_reg->bar4_limit,
 		    sysctl_handle_register, "IU", "Incoming LMT4 register");
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_lmt5",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_32 | ntb->xlat_reg->bar5_limit,
 		    sysctl_handle_register, "IU", "Incoming LMT5 register");
 	} else {
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_lmt45",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_64 | ntb->xlat_reg->bar4_limit,
 		    sysctl_handle_register, "QU", "Incoming LMT45 register");
 	}
@@ -2378,67 +2382,67 @@ intel_ntb_sysctl_init(struct ntb_softc *ntb)
 		return;
 
 	tmptree = SYSCTL_ADD_NODE(ctx, regpar, OID_AUTO, "xeon_stats",
-	    CTLFLAG_RD, NULL, "Xeon HW statistics");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Xeon HW statistics");
 	statpar = SYSCTL_CHILDREN(tmptree);
 	SYSCTL_ADD_PROC(ctx, statpar, OID_AUTO, "upstream_mem_miss",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_16 | XEON_USMEMMISS_OFFSET,
 	    sysctl_handle_register, "SU", "Upstream Memory Miss");
 
 	tmptree = SYSCTL_ADD_NODE(ctx, regpar, OID_AUTO, "xeon_hw_err",
-	    CTLFLAG_RD, NULL, "Xeon HW errors");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Xeon HW errors");
 	errpar = SYSCTL_CHILDREN(tmptree);
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "ppd",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_8 | NTB_PCI_REG | NTB_PPD_OFFSET,
 	    sysctl_handle_register, "CU", "PPD");
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "pbar23_sz",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_8 | NTB_PCI_REG | XEON_PBAR23SZ_OFFSET,
 	    sysctl_handle_register, "CU", "PBAR23 SZ (log2)");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "pbar4_sz",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_8 | NTB_PCI_REG | XEON_PBAR4SZ_OFFSET,
 	    sysctl_handle_register, "CU", "PBAR4 SZ (log2)");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "pbar5_sz",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_8 | NTB_PCI_REG | XEON_PBAR5SZ_OFFSET,
 	    sysctl_handle_register, "CU", "PBAR5 SZ (log2)");
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar23_sz",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_8 | NTB_PCI_REG | XEON_SBAR23SZ_OFFSET,
 	    sysctl_handle_register, "CU", "SBAR23 SZ (log2)");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar4_sz",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_8 | NTB_PCI_REG | XEON_SBAR4SZ_OFFSET,
 	    sysctl_handle_register, "CU", "SBAR4 SZ (log2)");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar5_sz",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_8 | NTB_PCI_REG | XEON_SBAR5SZ_OFFSET,
 	    sysctl_handle_register, "CU", "SBAR5 SZ (log2)");
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "devsts",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_16 | NTB_PCI_REG | XEON_DEVSTS_OFFSET,
 	    sysctl_handle_register, "SU", "DEVSTS");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "lnksts",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_16 | NTB_PCI_REG | XEON_LINK_STATUS_OFFSET,
 	    sysctl_handle_register, "SU", "LNKSTS");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "slnksts",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_16 | NTB_PCI_REG | XEON_SLINK_STATUS_OFFSET,
 	    sysctl_handle_register, "SU", "SLNKSTS");
 
 	SYSCTL_ADD_PROC(ctx, errpar, OID_AUTO, "uncerrsts",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_32 | NTB_PCI_REG | XEON_UNCERRSTS_OFFSET,
 	    sysctl_handle_register, "IU", "UNCERRSTS");
 	SYSCTL_ADD_PROC(ctx, errpar, OID_AUTO, "corerrsts",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_32 | NTB_PCI_REG | XEON_CORERRSTS_OFFSET,
 	    sysctl_handle_register, "IU", "CORERRSTS");
 
@@ -2446,75 +2450,75 @@ intel_ntb_sysctl_init(struct ntb_softc *ntb)
 		return;
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_xlat01l",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_32 | XEON_B2B_XLAT_OFFSETL,
 	    sysctl_handle_register, "IU", "Outgoing XLAT0L register");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_xlat01u",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_32 | XEON_B2B_XLAT_OFFSETU,
 	    sysctl_handle_register, "IU", "Outgoing XLAT0U register");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_xlat23",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_64 | ntb->bar_info[NTB_B2B_BAR_1].pbarxlat_off,
 	    sysctl_handle_register, "QU", "Outgoing XLAT23 register");
 	if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_xlat4",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_32 | ntb->bar_info[NTB_B2B_BAR_2].pbarxlat_off,
 		    sysctl_handle_register, "IU", "Outgoing XLAT4 register");
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_xlat5",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_32 | ntb->bar_info[NTB_B2B_BAR_3].pbarxlat_off,
 		    sysctl_handle_register, "IU", "Outgoing XLAT5 register");
 	} else {
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_xlat45",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_64 | ntb->bar_info[NTB_B2B_BAR_2].pbarxlat_off,
 		    sysctl_handle_register, "QU", "Outgoing XLAT45 register");
 	}
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_lmt23",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_64 | XEON_PBAR2LMT_OFFSET,
 	    sysctl_handle_register, "QU", "Outgoing LMT23 register");
 	if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_lmt4",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_32 | XEON_PBAR4LMT_OFFSET,
 		    sysctl_handle_register, "IU", "Outgoing LMT4 register");
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_lmt5",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_32 | XEON_PBAR5LMT_OFFSET,
 		    sysctl_handle_register, "IU", "Outgoing LMT5 register");
 	} else {
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_lmt45",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_64 | XEON_PBAR4LMT_OFFSET,
 		    sysctl_handle_register, "QU", "Outgoing LMT45 register");
 	}
 
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar01_base",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_64 | ntb->xlat_reg->bar0_base,
 	    sysctl_handle_register, "QU", "Secondary BAR01 base register");
 	SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar23_base",
-	    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+	    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 	    NTB_REG_64 | ntb->xlat_reg->bar2_base,
 	    sysctl_handle_register, "QU", "Secondary BAR23 base register");
 	if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar4_base",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_32 | ntb->xlat_reg->bar4_base,
 		    sysctl_handle_register, "IU",
 		    "Secondary BAR4 base register");
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar5_base",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_32 | ntb->xlat_reg->bar5_base,
 		    sysctl_handle_register, "IU",
 		    "Secondary BAR5 base register");
 	} else {
 		SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar45_base",
-		    CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
+		    CTLFLAG_RD | CTLTYPE_OPAQUE | CTLFLAG_NEEDGIANT, ntb,
 		    NTB_REG_64 | ntb->xlat_reg->bar4_base,
 		    sysctl_handle_register, "QU",
 		    "Secondary BAR45 base register");
diff --git a/sys/dev/ntb/ntb_transport.c b/sys/dev/ntb/ntb_transport.c
index a9cd4f202ed1..e39d3b6a0a34 100644
--- a/sys/dev/ntb/ntb_transport.c
+++ b/sys/dev/ntb/ntb_transport.c
@@ -67,7 +67,9 @@ __FBSDID("$FreeBSD$");
 
 #define NTB_TRANSPORT_VERSION	4
 
-static SYSCTL_NODE(_hw, OID_AUTO, ntb_transport, CTLFLAG_RW, 0, "ntb_transport");
+static SYSCTL_NODE(_hw, OID_AUTO, ntb_transport,
+    CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "ntb_transport");
 
 static unsigned g_ntb_transport_debug_level;
 SYSCTL_UINT(_hw_ntb_transport, OID_AUTO, debug_level, CTLFLAG_RWTUN,
diff --git a/sys/dev/ntb/test/ntb_tool.c b/sys/dev/ntb/test/ntb_tool.c
index c83df3962531..c147e9a20385 100644
--- a/sys/dev/ntb/test/ntb_tool.c
+++ b/sys/dev/ntb/test/ntb_tool.c
@@ -1379,8 +1379,8 @@ tool_setup_sysctl(struct tool_ctx *tc)
 	for (pidx = 0; pidx < tc->peer_cnt; pidx++) {
 		snprintf(buf, sizeof(buf), "peer%d", pidx);
 
-		peer = SYSCTL_ADD_NODE(clist, top, OID_AUTO, buf, CTLFLAG_RW, 0,
-		    buf);
+		peer = SYSCTL_ADD_NODE(clist, top, OID_AUTO, buf,
+		    CTLFLAG_RW | CTLFLAG_MPSAFE, 0, buf);
 		peer_top = SYSCTL_CHILDREN(peer);
 
 		SYSCTL_ADD_PROC(clist, peer_top, OID_AUTO, "port",
diff --git a/sys/dev/nvd/nvd.c b/sys/dev/nvd/nvd.c
index a5cfdf080798..8ac8c2bf9963 100644
--- a/sys/dev/nvd/nvd.c
+++ b/sys/dev/nvd/nvd.c
@@ -101,7 +101,8 @@ static struct mtx			nvd_lock;
 static TAILQ_HEAD(, nvd_controller)	ctrlr_head;
 static TAILQ_HEAD(disk_list, nvd_disk)	disk_head;
 
-static SYSCTL_NODE(_hw, OID_AUTO, nvd, CTLFLAG_RD, 0, "nvd driver parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, nvd, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "nvd driver parameters");
 /*
  * The NVMe specification does not define a maximum or optimal delete size, so
  *  technically max delete size is min(full size of the namespace, 2^32 - 1
diff --git a/sys/dev/nvme/nvme_sysctl.c b/sys/dev/nvme/nvme_sysctl.c
index b68a644206e7..3e0852b6af89 100644
--- a/sys/dev/nvme/nvme_sysctl.c
+++ b/sys/dev/nvme/nvme_sysctl.c
@@ -44,7 +44,8 @@ __FBSDID("$FreeBSD$");
 int nvme_use_nvd = NVME_USE_NVD;
 bool nvme_verbose_cmd_dump = false;
 
-SYSCTL_NODE(_hw, OID_AUTO, nvme, CTLFLAG_RD, 0, "NVMe sysctl tunables");
+SYSCTL_NODE(_hw, OID_AUTO, nvme, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "NVMe sysctl tunables");
 SYSCTL_INT(_hw_nvme, OID_AUTO, use_nvd, CTLFLAG_RDTUN,
     &nvme_use_nvd, 1, "1 = Create NVD devices, 0 = Create NDA devices");
 SYSCTL_BOOL(_hw_nvme, OID_AUTO, verbose_cmd_dump, CTLFLAG_RWTUN,
@@ -288,8 +289,8 @@ nvme_sysctl_initialize_queue(struct nvme_qpair *qpair,
 	    "Number of commands ending in failure after all retries");
 
 	SYSCTL_ADD_PROC(ctrlr_ctx, que_list, OID_AUTO,
-	    "dump_debug", CTLTYPE_UINT | CTLFLAG_RW, qpair, 0,
-	    nvme_sysctl_dump_debug, "IU", "Dump debug data");
+	    "dump_debug", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    qpair, 0, nvme_sysctl_dump_debug, "IU", "Dump debug data");
 }
 
 void
@@ -311,55 +312,57 @@ nvme_sysctl_initialize_ctrlr(struct nvme_controller *ctrlr)
 	    "Number of I/O queue pairs");
 
 	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
-	    "int_coal_time", CTLTYPE_UINT | CTLFLAG_RW, ctrlr, 0,
-	    nvme_sysctl_int_coal_time, "IU",
+	    "int_coal_time", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    ctrlr, 0, nvme_sysctl_int_coal_time, "IU",
 	    "Interrupt coalescing timeout (in microseconds)");
 
 	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
-	    "int_coal_threshold", CTLTYPE_UINT | CTLFLAG_RW, ctrlr, 0,
+	    "int_coal_threshold",
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, ctrlr, 0,
 	    nvme_sysctl_int_coal_threshold, "IU",
 	    "Interrupt coalescing threshold");
 
 	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
-	    "timeout_period", CTLTYPE_UINT | CTLFLAG_RW, ctrlr, 0,
-	    nvme_sysctl_timeout_period, "IU",
+	    "timeout_period", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    ctrlr, 0, nvme_sysctl_timeout_period, "IU",
 	    "Timeout period (in seconds)");
 
 	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
-	    "num_cmds", CTLTYPE_S64 | CTLFLAG_RD,
+	    "num_cmds", CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    ctrlr, 0, nvme_sysctl_num_cmds, "IU",
 	    "Number of commands submitted");
 
 	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
-	    "num_intr_handler_calls", CTLTYPE_S64 | CTLFLAG_RD,
-	    ctrlr, 0, nvme_sysctl_num_intr_handler_calls, "IU",
+	    "num_intr_handler_calls",
+	    CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT, ctrlr, 0,
+	    nvme_sysctl_num_intr_handler_calls, "IU",
 	    "Number of times interrupt handler was invoked (will "
 	    "typically be less than number of actual interrupts "
 	    "generated due to coalescing)");
 
 	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
-	    "num_retries", CTLTYPE_S64 | CTLFLAG_RD,
+	    "num_retries", CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    ctrlr, 0, nvme_sysctl_num_retries, "IU",
 	    "Number of commands retried");
 
 	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
-	    "num_failures", CTLTYPE_S64 | CTLFLAG_RD,
+	    "num_failures", CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 	    ctrlr, 0, nvme_sysctl_num_failures, "IU",
 	    "Number of commands ending in failure after all retries");
 
 	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
-	    "reset_stats", CTLTYPE_UINT | CTLFLAG_RW, ctrlr, 0,
-	    nvme_sysctl_reset_stats, "IU", "Reset statistics to zero");
+	    "reset_stats", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, ctrlr,
+	    0, nvme_sysctl_reset_stats, "IU", "Reset statistics to zero");
 
 	que_tree = SYSCTL_ADD_NODE(ctrlr_ctx, ctrlr_list, OID_AUTO, "adminq",
-	    CTLFLAG_RD, NULL, "Admin Queue");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Admin Queue");
 
 	nvme_sysctl_initialize_queue(&ctrlr->adminq, ctrlr_ctx, que_tree);
 
 	for (i = 0; i < ctrlr->num_io_queues; i++) {
 		snprintf(queue_name, QUEUE_NAME_LENGTH, "ioq%d", i);
 		que_tree = SYSCTL_ADD_NODE(ctrlr_ctx, ctrlr_list, OID_AUTO,
-		    queue_name, CTLFLAG_RD, NULL, "IO Queue");
+		    queue_name, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "IO Queue");
 		nvme_sysctl_initialize_queue(&ctrlr->ioq[i], ctrlr_ctx,
 		    que_tree);
 	}
diff --git a/sys/dev/oce/oce_sysctl.c b/sys/dev/oce/oce_sysctl.c
index 1e8ed6169437..95f22fa1aa58 100644
--- a/sys/dev/oce/oce_sysctl.c
+++ b/sys/dev/oce/oce_sysctl.c
@@ -128,16 +128,16 @@ oce_add_sysctls(POCE_SOFTC sc)
 				0,"PVID");
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "loop_back",
-		CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 0,
-		oce_sysctl_loopback, "I", "Loop Back Tests");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, (void *)sc, 0,
+	    oce_sysctl_loopback, "I", "Loop Back Tests");
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "fw_upgrade",
-		CTLTYPE_STRING | CTLFLAG_RW, (void *)sc, 0,
-		oce_sys_fwupgrade, "A", "Firmware ufi file");
+	    CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, (void *)sc, 0,
+	    oce_sys_fwupgrade, "A", "Firmware ufi file");
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "aic_enable",
-		CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 1,
-		oce_sys_aic_enable, "I", "aic flags");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, (void *)sc, 1,
+	    oce_sys_aic_enable, "I", "aic flags");
 
         /*
          *  Dumps Transceiver data
@@ -146,14 +146,14 @@ oce_add_sysctls(POCE_SOFTC sc)
          *  "sysctl -b dev.oce.0.sfp_vpd_dump_buffer > sfp.bin" for binary dump
          */
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "sfp_vpd_dump",
-			CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 0, oce_sysctl_sfp_vpd_dump,
-			"I", "Initiate a sfp_vpd_dump operation");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, (void *)sc, 0,
+	    oce_sysctl_sfp_vpd_dump, "I", "Initiate a sfp_vpd_dump operation");
 	SYSCTL_ADD_OPAQUE(ctx, child, OID_AUTO, "sfp_vpd_dump_buffer",
 			CTLFLAG_RD, sfp_vpd_dump_buffer,
 			TRANSCEIVER_DATA_SIZE, "IU", "Access sfp_vpd_dump buffer");
 
 	stats_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
-				CTLFLAG_RD, NULL, "Ethernet Statistics");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Ethernet Statistics");
 
 	if (IS_BE(sc) || IS_SH(sc))
 		oce_add_stats_sysctls_be3(sc, ctx, stats_node);
@@ -720,9 +720,8 @@ oce_add_stats_sysctls_be3(POCE_SOFTC sc,
 	stats = &sc->oce_stats_info;
 
 	rx_stats_node = SYSCTL_ADD_NODE(ctx,
-					SYSCTL_CHILDREN(stats_node), 
-					OID_AUTO,"rx", CTLFLAG_RD, 
-					NULL, "RX Ethernet Statistics");
+	    SYSCTL_CHILDREN(stats_node), OID_AUTO,"rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX Ethernet Statistics");
 	rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
 
 	
@@ -757,9 +756,8 @@ oce_add_stats_sysctls_be3(POCE_SOFTC sc,
 	for (i = 0; i < sc->nrqs; i++) {
 		sprintf(prefix, "queue%d",i);
 		queue_stats_node = SYSCTL_ADD_NODE(ctx, 
-						SYSCTL_CHILDREN(rx_stats_node),
-						OID_AUTO, prefix, CTLFLAG_RD,
-						NULL, "Queue name");
+		    SYSCTL_CHILDREN(rx_stats_node), OID_AUTO, prefix,
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue name");
 		queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
 		
 		SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_pkts",
@@ -790,9 +788,8 @@ oce_add_stats_sysctls_be3(POCE_SOFTC sc,
 	}
 	
 	rx_stats_node = SYSCTL_ADD_NODE(ctx,
-					SYSCTL_CHILDREN(rx_stats_node),
-					OID_AUTO, "err", CTLFLAG_RD,
-					NULL, "Receive Error Stats");
+	    SYSCTL_CHILDREN(rx_stats_node), OID_AUTO, "err",
+	        CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Receive Error Stats");
 	rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
 	
 	SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "crc_errs",
@@ -853,9 +850,9 @@ oce_add_stats_sysctls_be3(POCE_SOFTC sc,
 			"Input FIFO Overflow Drop");
 
 	tx_stats_node = SYSCTL_ADD_NODE(ctx,
-					SYSCTL_CHILDREN(stats_node), OID_AUTO,
-					"tx",CTLFLAG_RD, NULL,
-					"TX Ethernet Statistics");
+	    SYSCTL_CHILDREN(stats_node), OID_AUTO,
+	        "tx", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+		"TX Ethernet Statistics");
 	tx_stat_list = SYSCTL_CHILDREN(tx_stats_node);
 
 	SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_pkts",
@@ -893,9 +890,8 @@ oce_add_stats_sysctls_be3(POCE_SOFTC sc,
 	for (i = 0; i < sc->nwqs; i++) {
 		sprintf(prefix, "queue%d",i);
 		queue_stats_node = SYSCTL_ADD_NODE(ctx, 
-						SYSCTL_CHILDREN(tx_stats_node),
-						OID_AUTO, prefix, CTLFLAG_RD,
-						NULL, "Queue name");
+		    SYSCTL_CHILDREN(tx_stats_node), OID_AUTO, prefix,
+		        CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue name");
 		queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
 
 		SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_pkts",
@@ -942,9 +938,9 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
 	stats = &sc->oce_stats_info;
 
 	rx_stats_node = SYSCTL_ADD_NODE(ctx,
-					SYSCTL_CHILDREN(stats_node),
-					OID_AUTO, "rx", CTLFLAG_RD,
-					NULL, "RX Ethernet Statistics");
+	    SYSCTL_CHILDREN(stats_node), OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+	    "RX Ethernet Statistics");
 	rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
 
 	
@@ -976,9 +972,8 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
 	for (i = 0; i < sc->nrqs; i++) {
 		sprintf(prefix, "queue%d",i);
 		queue_stats_node = SYSCTL_ADD_NODE(ctx, 
-						SYSCTL_CHILDREN(rx_stats_node),
-						OID_AUTO, prefix, CTLFLAG_RD,
-						NULL, "Queue name");
+		    SYSCTL_CHILDREN(rx_stats_node), OID_AUTO, prefix,
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue name");
 		queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
 		
 		SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_pkts",
@@ -1005,9 +1000,8 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
 	}
 
 	rx_stats_node = SYSCTL_ADD_NODE(ctx,
-					SYSCTL_CHILDREN(rx_stats_node),
-					OID_AUTO, "err", CTLFLAG_RD,
-					NULL, "Receive Error Stats");
+	    SYSCTL_CHILDREN(rx_stats_node), OID_AUTO, "err",
+	        CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Receive Error Stats");
 	rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
 	
 	SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "crc_errs",
@@ -1059,9 +1053,8 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
 			"Input FIFO Overflow Drop");
 
 	tx_stats_node = SYSCTL_ADD_NODE(ctx,
-					SYSCTL_CHILDREN(stats_node),
-					OID_AUTO, "tx", CTLFLAG_RD,
-					NULL, "TX Ethernet Statistics");
+	    SYSCTL_CHILDREN(stats_node), OID_AUTO, "tx",
+	        CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX Ethernet Statistics");
 	tx_stat_list = SYSCTL_CHILDREN(tx_stats_node);
 
 	SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_pkts",
@@ -1096,9 +1089,8 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
 	for (i = 0; i < sc->nwqs; i++) {
 		sprintf(prefix, "queue%d",i);
 		queue_stats_node = SYSCTL_ADD_NODE(ctx, 
-						SYSCTL_CHILDREN(tx_stats_node),
-						OID_AUTO, prefix, CTLFLAG_RD,
-						NULL, "Queue name");
+		    SYSCTL_CHILDREN(tx_stats_node), OID_AUTO, prefix,
+		        CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue name");
 		queue_stats_list = SYSCTL_CHILDREN(queue_stats_node);
 
 		SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_pkts",
diff --git a/sys/dev/ocs_fc/ocs_ioctl.c b/sys/dev/ocs_fc/ocs_ioctl.c
index 70e1a99c1d3b..8b348a31362d 100644
--- a/sys/dev/ocs_fc/ocs_ioctl.c
+++ b/sys/dev/ocs_fc/ocs_ioctl.c
@@ -1132,38 +1132,38 @@ ocs_sysctl_init(ocs_t *ocs)
 			  0, "SLI Interface");
 
         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "fw_upgrade",
-                CTLTYPE_STRING | CTLFLAG_RW, (void *)ocs, 0,
-                ocs_sys_fwupgrade, "A", "Firmware grp file");
+            CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, (void *)ocs, 0,
+	    ocs_sys_fwupgrade, "A", "Firmware grp file");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"wwnn", CTLTYPE_STRING | CTLFLAG_RW,
-			ocs, 0, ocs_sysctl_wwnn, "A",
-			"World Wide Node Name, wwnn should be in the format 0x<XXXXXXXXXXXXXXXX>");
+	    "wwnn", CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    ocs, 0, ocs_sysctl_wwnn, "A",
+	    "World Wide Node Name, wwnn should be in the format 0x<XXXXXXXXXXXXXXXX>");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"wwpn", CTLTYPE_STRING | CTLFLAG_RW,
-			ocs, 0, ocs_sysctl_wwpn, "A",
-			"World Wide Port Name, wwpn should be in the format 0x<XXXXXXXXXXXXXXXX>");
+	    "wwpn", CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    ocs, 0, ocs_sysctl_wwpn, "A",
+	    "World Wide Port Name, wwpn should be in the format 0x<XXXXXXXXXXXXXXXX>");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"current_topology", CTLTYPE_UINT | CTLFLAG_RD,
-			ocs, 0, ocs_sysctl_current_topology, "IU",
-			"Current Topology, 1-NPort; 2-Loop; 3-None");
+	    "current_topology", CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	    ocs, 0, ocs_sysctl_current_topology, "IU",
+	    "Current Topology, 1-NPort; 2-Loop; 3-None");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"current_speed", CTLTYPE_UINT | CTLFLAG_RD,
-			ocs, 0, ocs_sysctl_current_speed, "IU",
-			"Current Speed");
+	    "current_speed", CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	    ocs, 0, ocs_sysctl_current_speed, "IU",
+	    "Current Speed");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"configured_topology", CTLTYPE_UINT | CTLFLAG_RW,
-			ocs, 0, ocs_sysctl_config_topology, "IU",
-			"Configured Topology, 0-Auto; 1-NPort; 2-Loop");
+	    "configured_topology", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    ocs, 0, ocs_sysctl_config_topology, "IU",
+	    "Configured Topology, 0-Auto; 1-NPort; 2-Loop");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"configured_speed", CTLTYPE_UINT | CTLFLAG_RW,
-			ocs, 0, ocs_sysctl_config_speed, "IU",
-			"Configured Speed, 0-Auto, 2000, 4000, 8000, 16000, 32000");
+	    "configured_speed", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    ocs, 0, ocs_sysctl_config_speed, "IU",
+	    "Configured Speed, 0-Auto, 2000, 4000, 8000, 16000, 32000");
 
 	SYSCTL_ADD_STRING(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
 			"businfo", CTLFLAG_RD,
@@ -1171,14 +1171,12 @@ ocs_sysctl_init(ocs_t *ocs)
 			0, "Bus Info");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"fcid", CTLTYPE_STRING | CTLFLAG_RD,
-			ocs, 0, ocs_sysctl_fcid, "A",
-			"Port FC ID");
+	    "fcid", CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	    ocs, 0, ocs_sysctl_fcid, "A", "Port FC ID");
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-			"port_state", CTLTYPE_STRING | CTLFLAG_RW,
-			ocs, 0, ocs_sysctl_port_state, "A",
-			"configured port state");
+	    "port_state", CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    ocs, 0, ocs_sysctl_port_state, "A", "configured port state");
 
 	for (i	= 0; i < ocs->num_vports; i++) {
 		fcp = FCPORT(ocs, i+1);
@@ -1186,17 +1184,17 @@ ocs_sysctl_init(ocs_t *ocs)
 		memset(name, 0, sizeof(name));
 		snprintf(name, sizeof(name), "vport%d", i);
 		vtree = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree),
-				OID_AUTO, name, CTLFLAG_RW, 0, "Virtual port");
+		    OID_AUTO, name, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+		    "Virtual port");
 
 		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(vtree), OID_AUTO,
-			"wwnn", CTLTYPE_STRING | CTLFLAG_RW,
-			fcp, 0, ocs_sysctl_vport_wwnn, "A",
-			"World Wide Node Name");
+		    "wwnn", CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+		    fcp, 0, ocs_sysctl_vport_wwnn, "A",
+		    "World Wide Node Name");
 
 		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(vtree), OID_AUTO,
-			"wwpn", CTLTYPE_STRING | CTLFLAG_RW,
-			fcp, 0, ocs_sysctl_vport_wwpn, "A",
-			"World Wide Port Name");
+		    "wwpn", CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+		    fcp, 0, ocs_sysctl_vport_wwpn, "A", "World Wide Port Name");
 
 	}
 
diff --git a/sys/dev/ow/ow.c b/sys/dev/ow/ow.c
index c598be3a4a68..eda33ea986d4 100644
--- a/sys/dev/ow/ow.c
+++ b/sys/dev/ow/ow.c
@@ -160,10 +160,11 @@ static struct ow_timing timing_overdrive = {
 	.t_lowr = 1,		/* 1 <= t < 2 */
 };
 
-SYSCTL_NODE(_hw, OID_AUTO, ow, CTLFLAG_RD, 0, "1-Wire protocol");
-SYSCTL_NODE(_hw_ow, OID_AUTO, regular, CTLFLAG_RD, 0,
+SYSCTL_NODE(_hw, OID_AUTO, ow, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "1-Wire protocol");
+SYSCTL_NODE(_hw_ow, OID_AUTO, regular, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "Regular mode timings");
-SYSCTL_NODE(_hw_ow, OID_AUTO, overdrive, CTLFLAG_RD, 0,
+SYSCTL_NODE(_hw_ow, OID_AUTO, overdrive, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "Overdrive mode timings");
 
 #define	_OW_TIMING_SYSCTL(mode, param)		\
@@ -183,7 +184,7 @@ SYSCTL_NODE(_hw_ow, OID_AUTO, overdrive, CTLFLAG_RD, 0,
 	    return (0); \
     } \
 SYSCTL_PROC(_hw_ow_ ## mode, OID_AUTO, param, \
-    CTLTYPE_INT | CTLFLAG_RWTUN, 0, sizeof(int), \
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int), \
     sysctl_ow_timing_ ## mode ## _ ## param, "I", \
     "1-Wire timing parameter in microseconds (-1 resets to default)")
 
diff --git a/sys/dev/ow/ow_temp.c b/sys/dev/ow/ow_temp.c
index cd0a61838064..b284aabe89a4 100644
--- a/sys/dev/ow/ow_temp.c
+++ b/sys/dev/ow/ow_temp.c
@@ -198,7 +198,8 @@ ow_temp_attach(device_t dev)
 	sc->type = ow_get_family(dev);
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-	    OID_AUTO, "temperature", CTLFLAG_RD | CTLTYPE_INT,
+	    OID_AUTO, "temperature",
+	    CTLFLAG_RD | CTLTYPE_INT | CTLFLAG_NEEDGIANT,
 	    &sc->temp, 0, sysctl_handle_int,
 	    "IK3", "Current Temperature");
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
diff --git a/sys/dev/pccard/pccard.c b/sys/dev/pccard/pccard.c
index 095179eecb90..34823115153e 100644
--- a/sys/dev/pccard/pccard.c
+++ b/sys/dev/pccard/pccard.c
@@ -63,7 +63,8 @@ __FBSDID("$FreeBSD$");
 #define PCCARDDEBUG
 
 /* sysctl vars */
-static SYSCTL_NODE(_hw, OID_AUTO, pccard, CTLFLAG_RD, 0, "PCCARD parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, pccard, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "PCCARD parameters");
 
 int	pccard_debug = 0;
 SYSCTL_INT(_hw_pccard, OID_AUTO, debug, CTLFLAG_RWTUN,
diff --git a/sys/dev/pccbb/pccbb.c b/sys/dev/pccbb/pccbb.c
index 041959904f90..bae8363831fa 100644
--- a/sys/dev/pccbb/pccbb.c
+++ b/sys/dev/pccbb/pccbb.c
@@ -127,7 +127,8 @@ __FBSDID("$FreeBSD$");
 devclass_t cbb_devclass;
 
 /* sysctl vars */
-static SYSCTL_NODE(_hw, OID_AUTO, cbb, CTLFLAG_RD, 0, "CBB parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, cbb, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "CBB parameters");
 
 /* There's no way to say TUNEABLE_LONG to get the right types */
 u_long cbb_start_mem = CBB_START_MEM;
diff --git a/sys/dev/pccbb/pccbb_isa.c b/sys/dev/pccbb/pccbb_isa.c
index ecc8e709981d..919365ad146d 100644
--- a/sys/dev/pccbb/pccbb_isa.c
+++ b/sys/dev/pccbb/pccbb_isa.c
@@ -72,7 +72,8 @@ __FBSDID("$FreeBSD$");
  *****************************************************************************/
 
 /* sysctl vars */
-static SYSCTL_NODE(_hw, OID_AUTO, pcic, CTLFLAG_RD, 0, "PCIC parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, pcic, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "PCIC parameters");
 
 static int isa_intr_mask = EXCA_INT_MASK_ALLOWED;
 SYSCTL_INT(_hw_pcic, OID_AUTO, intr_mask, CTLFLAG_RDTUN, &isa_intr_mask, 0,
diff --git a/sys/dev/puc/puc.c b/sys/dev/puc/puc.c
index f45493145be9..dd6e9b688705 100644
--- a/sys/dev/puc/puc.c
+++ b/sys/dev/puc/puc.c
@@ -73,7 +73,8 @@ const char puc_driver_name[] = "puc";
 
 static MALLOC_DEFINE(M_PUC, "PUC", "PUC driver");
 
-SYSCTL_NODE(_hw, OID_AUTO, puc, CTLFLAG_RD, 0, "puc(9) driver configuration");
+SYSCTL_NODE(_hw, OID_AUTO, puc, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "puc(9) driver configuration");
 
 struct puc_bar *
 puc_get_bar(struct puc_softc *sc, int rid)
diff --git a/sys/dev/qlnx/qlnxe/qlnx_os.c b/sys/dev/qlnx/qlnxe/qlnx_os.c
index c28fe699d431..9e9621432d23 100644
--- a/sys/dev/qlnx/qlnxe/qlnx_os.c
+++ b/sys/dev/qlnx/qlnxe/qlnx_os.c
@@ -276,7 +276,8 @@ char qlnx_name_str[NAME_SIZE];
 
 
 
-SYSCTL_NODE(_hw, OID_AUTO, qlnxe, CTLFLAG_RD, 0, "qlnxe driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, qlnxe, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "qlnxe driver parameters");
 
 /* Number of Queues: 0 (Auto) or 1 to 32 (fixed queue number) */
 static int qlnxe_queue_count = QLNX_DEFAULT_RSS;
@@ -1549,7 +1550,7 @@ qlnx_add_sp_stats_sysctls(qlnx_host_t *ha)
 	children = SYSCTL_CHILDREN(device_get_sysctl_tree(ha->pci_dev));
 
 	ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "spstat",
-			CTLFLAG_RD, NULL, "spstat");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "spstat");
         children = SYSCTL_CHILDREN(ctx_oid);
 
 	SYSCTL_ADD_QUAD(ctx, children,
@@ -1574,7 +1575,7 @@ qlnx_add_fp_stats_sysctls(qlnx_host_t *ha)
 	children = SYSCTL_CHILDREN(device_get_sysctl_tree(ha->pci_dev));
 
 	ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "fpstat",
-			CTLFLAG_RD, NULL, "fpstat");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "fpstat");
 	children = SYSCTL_CHILDREN(ctx_oid);
 
 	for (i = 0; i < ha->num_rss; i++) {
@@ -1583,7 +1584,7 @@ qlnx_add_fp_stats_sysctls(qlnx_host_t *ha)
 		snprintf(name_str, sizeof(name_str), "%d", i);
 
 		ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, name_str,
-			CTLFLAG_RD, NULL, name_str);
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, name_str);
 		node_children = SYSCTL_CHILDREN(ctx_oid);
 
 		/* Tx Related */
@@ -1849,7 +1850,7 @@ qlnx_add_hw_stats_sysctls(qlnx_host_t *ha)
 	children = SYSCTL_CHILDREN(device_get_sysctl_tree(ha->pci_dev));
 
 	ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "hwstat",
-			CTLFLAG_RD, NULL, "hwstat");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "hwstat");
         children = SYSCTL_CHILDREN(ctx_oid);
 
 	SYSCTL_ADD_QUAD(ctx, children,
@@ -2310,23 +2311,21 @@ qlnx_add_sysctls(qlnx_host_t *ha)
 		"tx_coalesce_usecs");
 
 	SYSCTL_ADD_PROC(ctx, children,
-		OID_AUTO, "trigger_dump", (CTLTYPE_INT | CTLFLAG_RW),
-		(void *)ha, 0,
-		qlnx_trigger_dump_sysctl, "I", "trigger_dump");
+	    OID_AUTO, "trigger_dump",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    (void *)ha, 0, qlnx_trigger_dump_sysctl, "I", "trigger_dump");
 
 	SYSCTL_ADD_PROC(ctx, children,
-		OID_AUTO, "set_rx_coalesce_usecs",
-		(CTLTYPE_INT | CTLFLAG_RW),
-		(void *)ha, 0,
-		qlnx_set_rx_coalesce, "I",
-		"rx interrupt coalesce period microseconds");
+	    OID_AUTO, "set_rx_coalesce_usecs",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    (void *)ha, 0, qlnx_set_rx_coalesce, "I",
+	    "rx interrupt coalesce period microseconds");
 
 	SYSCTL_ADD_PROC(ctx, children,
-		OID_AUTO, "set_tx_coalesce_usecs",
-		(CTLTYPE_INT | CTLFLAG_RW),
-		(void *)ha, 0,
-		qlnx_set_tx_coalesce, "I",
-		"tx interrupt coalesce period microseconds");
+	    OID_AUTO, "set_tx_coalesce_usecs",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    (void *)ha, 0, qlnx_set_tx_coalesce, "I",
+	    "tx interrupt coalesce period microseconds");
 
 	ha->rx_pkt_threshold = 128;
         SYSCTL_ADD_UINT(ctx, children,
diff --git a/sys/dev/qlnx/qlnxr/qlnxr_os.c b/sys/dev/qlnx/qlnxr/qlnxr_os.c
index a9e426e1ab18..d22c94fc52ab 100644
--- a/sys/dev/qlnx/qlnxr/qlnxr_os.c
+++ b/sys/dev/qlnx/qlnxr/qlnxr_os.c
@@ -34,7 +34,8 @@ __FBSDID("$FreeBSD$");
 
 #include "qlnxr_def.h"
 
-SYSCTL_NODE(_dev, OID_AUTO, qnxr, CTLFLAG_RW, 0, "Qlogic RDMA module");
+SYSCTL_NODE(_dev, OID_AUTO, qnxr, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "Qlogic RDMA module");
 
 uint32_t delayed_ack = 0;
 SYSCTL_UINT(_dev_qnxr, OID_AUTO, delayed_ack, CTLFLAG_RW, &delayed_ack, 1,
diff --git a/sys/dev/qlxgb/qla_os.c b/sys/dev/qlxgb/qla_os.c
index 798c415b42f1..0b5daa988917 100644
--- a/sys/dev/qlxgb/qla_os.c
+++ b/sys/dev/qlxgb/qla_os.c
@@ -151,10 +151,9 @@ qla_add_sysctls(qla_host_t *ha)
         device_t dev = ha->pci_dev;
 
         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-                SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-                OID_AUTO, "stats", CTLTYPE_INT | CTLFLAG_RD,
-                (void *)ha, 0,
-                qla_sysctl_get_stats, "I", "Statistics");
+            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
+            OID_AUTO, "stats", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	    (void *)ha, 0, qla_sysctl_get_stats, "I", "Statistics");
 
 	SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
 		SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
diff --git a/sys/dev/qlxgbe/ql_hw.c b/sys/dev/qlxgbe/ql_hw.c
index 1937a2bb6315..7c8e7da82192 100644
--- a/sys/dev/qlxgbe/ql_hw.c
+++ b/sys/dev/qlxgbe/ql_hw.c
@@ -263,7 +263,7 @@ qlnx_add_hw_mac_stats_sysctls(qla_host_t *ha)
         children = SYSCTL_CHILDREN(device_get_sysctl_tree(ha->pci_dev));
 
         ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats_hw_mac",
-                        CTLFLAG_RD, NULL, "stats_hw_mac");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "stats_hw_mac");
         children = SYSCTL_CHILDREN(ctx_oid);
 
         SYSCTL_ADD_QUAD(ctx, children,
@@ -480,7 +480,7 @@ qlnx_add_hw_rcv_stats_sysctls(qla_host_t *ha)
         children = SYSCTL_CHILDREN(device_get_sysctl_tree(ha->pci_dev));
 
         ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats_hw_rcv",
-                        CTLFLAG_RD, NULL, "stats_hw_rcv");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "stats_hw_rcv");
         children = SYSCTL_CHILDREN(ctx_oid);
 
         SYSCTL_ADD_QUAD(ctx, children,
@@ -600,7 +600,7 @@ qlnx_add_hw_xmt_stats_sysctls(qla_host_t *ha)
         children = SYSCTL_CHILDREN(device_get_sysctl_tree(ha->pci_dev));
 
         ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats_hw_xmt",
-                        CTLFLAG_RD, NULL, "stats_hw_xmt");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "stats_hw_xmt");
         children = SYSCTL_CHILDREN(ctx_oid);
 
         for (i = 0; i < ha->hw.num_tx_rings; i++) {
@@ -609,7 +609,7 @@ qlnx_add_hw_xmt_stats_sysctls(qla_host_t *ha)
                 snprintf(name_str, sizeof(name_str), "%d", i);
 
                 ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, name_str,
-                        CTLFLAG_RD, NULL, name_str);
+                    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, name_str);
                 node_children = SYSCTL_CHILDREN(ctx_oid);
 
                 /* Tx Related */
@@ -779,7 +779,7 @@ qlnx_add_drvr_sds_stats(qla_host_t *ha)
         children = SYSCTL_CHILDREN(device_get_sysctl_tree(ha->pci_dev));
 
         ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats_drvr_sds",
-                        CTLFLAG_RD, NULL, "stats_drvr_sds");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "stats_drvr_sds");
         children = SYSCTL_CHILDREN(ctx_oid);
 
         for (i = 0; i < ha->hw.num_sds_rings; i++) {
@@ -788,7 +788,7 @@ qlnx_add_drvr_sds_stats(qla_host_t *ha)
                 snprintf(name_str, sizeof(name_str), "%d", i);
 
                 ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, name_str,
-                        CTLFLAG_RD, NULL, name_str);
+		    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, name_str);
                 node_children = SYSCTL_CHILDREN(ctx_oid);
 
                 SYSCTL_ADD_QUAD(ctx, node_children,
@@ -818,7 +818,7 @@ qlnx_add_drvr_rds_stats(qla_host_t *ha)
         children = SYSCTL_CHILDREN(device_get_sysctl_tree(ha->pci_dev));
 
         ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats_drvr_rds",
-                        CTLFLAG_RD, NULL, "stats_drvr_rds");
+            CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "stats_drvr_rds");
         children = SYSCTL_CHILDREN(ctx_oid);
 
         for (i = 0; i < ha->hw.num_rds_rings; i++) {
@@ -827,7 +827,7 @@ qlnx_add_drvr_rds_stats(qla_host_t *ha)
                 snprintf(name_str, sizeof(name_str), "%d", i);
 
                 ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, name_str,
-                        CTLFLAG_RD, NULL, name_str);
+                    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, name_str);
                 node_children = SYSCTL_CHILDREN(ctx_oid);
 
                 SYSCTL_ADD_QUAD(ctx, node_children,
@@ -863,7 +863,7 @@ qlnx_add_drvr_tx_stats(qla_host_t *ha)
         children = SYSCTL_CHILDREN(device_get_sysctl_tree(ha->pci_dev));
 
         ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats_drvr_xmt",
-                        CTLFLAG_RD, NULL, "stats_drvr_xmt");
+            CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "stats_drvr_xmt");
         children = SYSCTL_CHILDREN(ctx_oid);
 
         for (i = 0; i < ha->hw.num_tx_rings; i++) {
@@ -872,7 +872,7 @@ qlnx_add_drvr_tx_stats(qla_host_t *ha)
                 snprintf(name_str, sizeof(name_str), "%d", i);
 
                 ctx_oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, name_str,
-                        CTLFLAG_RD, NULL, name_str);
+                    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, name_str);
                 node_children = SYSCTL_CHILDREN(ctx_oid);
 
                 SYSCTL_ADD_QUAD(ctx, node_children,
@@ -979,35 +979,32 @@ ql_hw_add_sysctls(qla_host_t *ha)
                 "\tto take effect \n");
 
         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-                SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-                OID_AUTO, "port_cfg", CTLTYPE_INT | CTLFLAG_RW,
-                (void *)ha, 0,
-                qla_sysctl_port_cfg, "I",
-                        "Set Port Configuration if values below "
-                        "otherwise Get Port Configuration\n"
-                        "\tBits 0-3 ; 1 = DCBX Enable; 0 = DCBX Disable\n"
-                        "\tBits 4-7 : 0 = no pause; 1 = std ; 2 = ppm \n"
-                        "\tBits 8-11: std pause cfg; 0 = xmt and rcv;"
-                        " 1 = xmt only; 2 = rcv only;\n"
-                );
+            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
+	    "port_cfg", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    (void *)ha, 0, qla_sysctl_port_cfg, "I",
+	    "Set Port Configuration if values below "
+	    "otherwise Get Port Configuration\n"
+	    "\tBits 0-3 ; 1 = DCBX Enable; 0 = DCBX Disable\n"
+	    "\tBits 4-7 : 0 = no pause; 1 = std ; 2 = ppm \n"
+	    "\tBits 8-11: std pause cfg; 0 = xmt and rcv;"
+	    " 1 = xmt only; 2 = rcv only;\n");
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-		SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-		OID_AUTO, "set_cam_search_mode", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)ha, 0,
-		qla_sysctl_set_cam_search_mode, "I",
-			"Set CAM Search Mode"
-			"\t 1 = search mode internal\n"
-			"\t 2 = search mode auto\n");
+	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
+	    "set_cam_search_mode", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    (void *)ha, 0, qla_sysctl_set_cam_search_mode, "I",
+	    "Set CAM Search Mode"
+	    "\t 1 = search mode internal\n"
+	    "\t 2 = search mode auto\n");
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-		SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-		OID_AUTO, "get_cam_search_mode", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)ha, 0,
+		SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
+		"get_cam_search_mode",
+		CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, (void *)ha, 0,
 		qla_sysctl_get_cam_search_mode, "I",
-			"Get CAM Search Mode"
-			"\t 1 = search mode internal\n"
-			"\t 2 = search mode auto\n");
+		"Get CAM Search Mode"
+		"\t 1 = search mode internal\n"
+		"\t 2 = search mode auto\n");
 
         ha->hw.enable_9kb = 1;
 
@@ -1097,10 +1094,9 @@ ql_hw_add_sysctls(qla_host_t *ha)
 		"\t\t\t 16: tx_buf[next_prod_index].mbuf != NULL\n" );
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-                SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-                OID_AUTO, "peg_stop", CTLTYPE_INT | CTLFLAG_RW,
-                (void *)ha, 0,
-                qla_sysctl_stop_pegs, "I", "Peg Stop");
+            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
+	    "peg_stop", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    (void *)ha, 0, qla_sysctl_stop_pegs, "I", "Peg Stop");
 
 #endif /* #ifdef QL_DBG */
 
diff --git a/sys/dev/qlxgbe/ql_os.c b/sys/dev/qlxgbe/ql_os.c
index ad6bab9f5ce3..eefc172dcd29 100644
--- a/sys/dev/qlxgbe/ql_os.c
+++ b/sys/dev/qlxgbe/ql_os.c
@@ -176,10 +176,9 @@ qla_add_sysctls(qla_host_t *ha)
                 ha->fw_ver_str, 0, "firmware version");
 
         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-                SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-                OID_AUTO, "link_status", CTLTYPE_INT | CTLFLAG_RW,
-                (void *)ha, 0,
-                qla_sysctl_get_link_status, "I", "Link Status");
+            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
+	    "link_status", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 
+	    (void *)ha, 0, qla_sysctl_get_link_status, "I", "Link Status");
 
 	ha->dbg_level = 0;
         SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev),
diff --git a/sys/dev/qlxge/qls_hw.c b/sys/dev/qlxge/qls_hw.c
index b29d62c5b0e4..db0e67ccc86e 100644
--- a/sys/dev/qlxge/qls_hw.c
+++ b/sys/dev/qlxge/qls_hw.c
@@ -160,16 +160,16 @@ qls_hw_add_sysctls(qla_host_t *ha)
 		ha->num_tx_rings, "Number of Transmit Rings");
 
         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-                SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-                OID_AUTO, "mpi_dump", CTLTYPE_INT | CTLFLAG_RW,
-                (void *)ha, 0,
-                qls_syctl_mpi_dump, "I", "MPI Dump");
+            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
+            OID_AUTO, "mpi_dump",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, (void *)ha, 0,
+	    qls_syctl_mpi_dump, "I", "MPI Dump");
 
         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-                SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-                OID_AUTO, "link_status", CTLTYPE_INT | CTLFLAG_RW,
-                (void *)ha, 0,
-                qls_syctl_link_status, "I", "Link Status");
+            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
+            OID_AUTO, "link_status",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, (void *)ha, 0,
+	    qls_syctl_link_status, "I", "Link Status");
 }
 
 /*
diff --git a/sys/dev/qlxge/qls_os.c b/sys/dev/qlxge/qls_os.c
index 5f2c04550369..3471bf8bf59e 100644
--- a/sys/dev/qlxge/qls_os.c
+++ b/sys/dev/qlxge/qls_os.c
@@ -280,10 +280,10 @@ qls_add_sysctls(qla_host_t *ha)
                 &qls_dbg_level, qls_dbg_level, "Debug Level");
 
         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-                SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-                OID_AUTO, "drvr_stats", CTLTYPE_INT | CTLFLAG_RW,
-                (void *)ha, 0,
-                qls_sysctl_get_drvr_stats, "I", "Driver Maintained Statistics");
+            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
+            OID_AUTO, "drvr_stats",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, (void *)ha, 0,
+	    qls_sysctl_get_drvr_stats, "I", "Driver Maintained Statistics");
 
         return;
 }
diff --git a/sys/dev/re/if_re.c b/sys/dev/re/if_re.c
index 66fe980dfc1d..a6e55baaacf2 100644
--- a/sys/dev/re/if_re.c
+++ b/sys/dev/re/if_re.c
@@ -3969,14 +3969,15 @@ re_add_sysctls(struct rl_softc *sc)
 	children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->rl_dev));
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "stats",
-	    CTLTYPE_INT | CTLFLAG_RW, sc, 0, re_sysctl_stats, "I",
-	    "Statistics Information");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
+	    re_sysctl_stats, "I", "Statistics Information");
 	if ((sc->rl_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0)
 		return;
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "int_rx_mod",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->rl_int_rx_mod, 0,
-	    sysctl_hw_re_int_mod, "I", "re RX interrupt moderation");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    &sc->rl_int_rx_mod, 0, sysctl_hw_re_int_mod, "I",
+	    "re RX interrupt moderation");
 	/* Pull in device tunables. */
 	sc->rl_int_rx_mod = RL_TIMER_DEFAULT;
 	error = resource_int_value(device_get_name(sc->rl_dev),
diff --git a/sys/dev/rndtest/rndtest.c b/sys/dev/rndtest/rndtest.c
index f33edbfa048d..ee48dc460c9e 100644
--- a/sys/dev/rndtest/rndtest.c
+++ b/sys/dev/rndtest/rndtest.c
@@ -72,8 +72,8 @@ static const struct rndtest_testfunc {
 
 #define	RNDTEST_NTESTS	nitems(rndtest_funcs)
 
-static SYSCTL_NODE(_kern, OID_AUTO, rndtest, CTLFLAG_RD, 0,
-	    "RNG test parameters");
+static SYSCTL_NODE(_kern, OID_AUTO, rndtest, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "RNG test parameters");
 static	int rndtest_retest = 120;		/* interval in seconds */
 SYSCTL_INT(_kern_rndtest, OID_AUTO, retest, CTLFLAG_RW, &rndtest_retest,
 	    0, "retest interval (seconds)");
diff --git a/sys/dev/rt/if_rt.c b/sys/dev/rt/if_rt.c
index cd47d051f36e..2bb81fe98c79 100644
--- a/sys/dev/rt/if_rt.c
+++ b/sys/dev/rt/if_rt.c
@@ -184,7 +184,8 @@ static int	rt_miibus_writereg(device_t, int, int, int);
 static int	rt_ifmedia_upd(struct ifnet *);
 static void	rt_ifmedia_sts(struct ifnet *, struct ifmediareq *);
 
-static SYSCTL_NODE(_hw, OID_AUTO, rt, CTLFLAG_RD, 0, "RT driver parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, rt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "RT driver parameters");
 #ifdef IF_RT_DEBUG
 static int rt_debug = 0;
 SYSCTL_INT(_hw_rt, OID_AUTO, debug, CTLFLAG_RWTUN, &rt_debug, 0,
@@ -2581,7 +2582,7 @@ rt_sysctl_attach(struct rt_softc *sc)
 
 	/* statistic counters */
 	stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-	    "stats", CTLFLAG_RD, 0, "statistic");
+	    "stats", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "statistic");
 
 	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "interrupts", CTLFLAG_RD, &sc->interrupts,
diff --git a/sys/dev/safe/safe.c b/sys/dev/safe/safe.c
index 0edaea85f5b6..7a577dfd0a8c 100644
--- a/sys/dev/safe/safe.c
+++ b/sys/dev/safe/safe.c
@@ -143,7 +143,7 @@ static	void safe_totalreset(struct safe_softc *);
 
 static	int safe_free_entry(struct safe_softc *, struct safe_ringentry *);
 
-static SYSCTL_NODE(_hw, OID_AUTO, safe, CTLFLAG_RD, 0,
+static SYSCTL_NODE(_hw, OID_AUTO, safe, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "SafeNet driver parameters");
 
 #ifdef SAFE_DEBUG
@@ -2162,6 +2162,8 @@ sysctl_hw_safe_dump(SYSCTL_HANDLER_ARGS)
 	}
 	return error;
 }
-SYSCTL_PROC(_hw_safe, OID_AUTO, dump, CTLTYPE_STRING | CTLFLAG_RW,
-	0, 0, sysctl_hw_safe_dump, "A", "Dump driver state");
+SYSCTL_PROC(_hw_safe, OID_AUTO, dump,
+    CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 0, 0,
+    sysctl_hw_safe_dump, "A",
+    "Dump driver state");
 #endif /* SAFE_DEBUG */
diff --git a/sys/dev/sdhci/sdhci.c b/sys/dev/sdhci/sdhci.c
index 10de32b5a64e..b07d2926a369 100644
--- a/sys/dev/sdhci/sdhci.c
+++ b/sys/dev/sdhci/sdhci.c
@@ -67,7 +67,8 @@ __FBSDID("$FreeBSD$");
 
 #include "opt_mmccam.h"
 
-SYSCTL_NODE(_hw, OID_AUTO, sdhci, CTLFLAG_RD, 0, "sdhci driver");
+SYSCTL_NODE(_hw, OID_AUTO, sdhci, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "sdhci driver");
 
 static int sdhci_debug = 0;
 SYSCTL_INT(_hw_sdhci, OID_AUTO, debug, CTLFLAG_RWTUN, &sdhci_debug, 0,
diff --git a/sys/dev/sfxge/sfxge.c b/sys/dev/sfxge/sfxge.c
index 7932e204ddf5..b9ee63569d99 100644
--- a/sys/dev/sfxge/sfxge.c
+++ b/sys/dev/sfxge/sfxge.c
@@ -86,8 +86,8 @@ __FBSDID("$FreeBSD$");
 MALLOC_DEFINE(M_SFXGE, "sfxge", "Solarflare 10GigE driver");
 
 
-SYSCTL_NODE(_hw, OID_AUTO, sfxge, CTLFLAG_RD, 0,
-	    "SFXGE driver parameters");
+SYSCTL_NODE(_hw, OID_AUTO, sfxge, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "SFXGE driver parameters");
 
 #define	SFXGE_PARAM_RX_RING	SFXGE_PARAM(rx_ring)
 static int sfxge_rx_ring_entries = SFXGE_NDESCS;
@@ -704,10 +704,9 @@ sfxge_create(struct sfxge_softc *sc)
 	TUNABLE_INT_FETCH(mcdi_log_param_name, &sc->mcdi_logging);
 #endif
 
-	sc->stats_node = SYSCTL_ADD_NODE(
-		device_get_sysctl_ctx(dev),
-		SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-		OID_AUTO, "stats", CTLFLAG_RD, NULL, "Statistics");
+	sc->stats_node = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
+	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Statistics");
 	if (sc->stats_node == NULL) {
 		error = ENOMEM;
 		goto fail;
@@ -970,10 +969,10 @@ sfxge_vpd_try_add(struct sfxge_softc *sc, struct sysctl_oid_list *list,
 	if (efx_vpd_get(sc->enp, sc->vpd_data, sc->vpd_size, &value) != 0)
 		return;
 
-	SYSCTL_ADD_PROC(
-		ctx, list, OID_AUTO, keyword, CTLTYPE_STRING|CTLFLAG_RD,
-		sc, tag << 16 | EFX_VPD_KEYWORD(keyword[0], keyword[1]),
-		sfxge_vpd_handler, "A", "");
+	SYSCTL_ADD_PROC(ctx, list, OID_AUTO, keyword,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+	    sc, tag << 16 | EFX_VPD_KEYWORD(keyword[0], keyword[1]),
+	    sfxge_vpd_handler, "A", "");
 }
 
 static int
@@ -1007,9 +1006,9 @@ sfxge_vpd_init(struct sfxge_softc *sc)
 		device_printf(sc->dev, "%s\n", value.evv_value);
 	}
 
-	vpd_node = SYSCTL_ADD_NODE(
-		ctx, SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)),
-		OID_AUTO, "vpd", CTLFLAG_RD, NULL, "Vital Product Data");
+	vpd_node = SYSCTL_ADD_NODE(ctx,
+	    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), OID_AUTO, "vpd",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Vital Product Data");
 	vpd_list = SYSCTL_CHILDREN(vpd_node);
 
 	/* Add sysctls for all expected and any vendor-defined keywords. */
diff --git a/sys/dev/sfxge/sfxge_ev.c b/sys/dev/sfxge/sfxge_ev.c
index ea452c9e13e6..bcc18fb31d64 100644
--- a/sys/dev/sfxge/sfxge_ev.c
+++ b/sys/dev/sfxge/sfxge_ev.c
@@ -494,18 +494,16 @@ sfxge_evq_stat_init(struct sfxge_evq *evq)
 
 	snprintf(name, sizeof(name), "%u", evq->index);
 	evq_stats_node = SYSCTL_ADD_NODE(ctx,
-					 SYSCTL_CHILDREN(sc->evqs_stats_node),
-					 OID_AUTO, name, CTLFLAG_RD, NULL, "");
+	    SYSCTL_CHILDREN(sc->evqs_stats_node), OID_AUTO, name,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
 	if (evq_stats_node == NULL)
 		return (ENOMEM);
 
 	for (id = 0; id < EV_NQSTATS; id++) {
-		SYSCTL_ADD_PROC(
-			ctx, SYSCTL_CHILDREN(evq_stats_node),
-			OID_AUTO, efx_ev_qstat_name(sc->enp, id),
-			CTLTYPE_U64|CTLFLAG_RD,
-			evq, id, sfxge_evq_stat_handler, "Q",
-			"");
+		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(evq_stats_node),
+		    OID_AUTO, efx_ev_qstat_name(sc->enp, id),
+		    CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_MPSAFE, evq, id,
+		    sfxge_evq_stat_handler, "Q", "");
 	}
 
 	return (0);
@@ -564,11 +562,9 @@ sfxge_ev_stat_init(struct sfxge_softc *sc)
 	for (id = 0; id < EV_NQSTATS; id++) {
 		snprintf(name, sizeof(name), "ev_%s",
 			 efx_ev_qstat_name(sc->enp, id));
-		SYSCTL_ADD_PROC(
-			ctx, stat_list,
-			OID_AUTO, name, CTLTYPE_U64|CTLFLAG_RD,
-			sc, id, sfxge_ev_stat_handler, "Q",
-			"");
+		SYSCTL_ADD_PROC(ctx, stat_list, OID_AUTO, name,
+		    CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
+		    sc, id, sfxge_ev_stat_handler, "Q", "");
 	}
 }
 
@@ -1004,14 +1000,15 @@ sfxge_ev_init(struct sfxge_softc *sc)
 	 */
 	sc->ev_moderation = SFXGE_MODERATION;
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
-			OID_AUTO, "int_mod", CTLTYPE_UINT|CTLFLAG_RW,
-			sc, 0, sfxge_int_mod_handler, "IU",
-			"sfxge interrupt moderation (us)");
+	    OID_AUTO, "int_mod", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE,
+	    sc, 0, sfxge_int_mod_handler, "IU",
+	    "sfxge interrupt moderation (us)");
 
 #if EFSYS_OPT_QSTATS
 	sc->evqs_stats_node = SYSCTL_ADD_NODE(
-		device_get_sysctl_ctx(sc->dev), SYSCTL_CHILDREN(sc->stats_node),
-		OID_AUTO, "evq", CTLFLAG_RD, NULL, "Event queues stats");
+	    device_get_sysctl_ctx(sc->dev), SYSCTL_CHILDREN(sc->stats_node),
+	    OID_AUTO, "evq", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+	    "Event queues stats");
 	if (sc->evqs_stats_node == NULL) {
 		rc = ENOMEM;
 		goto fail_evqs_stats_node;
diff --git a/sys/dev/sfxge/sfxge_port.c b/sys/dev/sfxge/sfxge_port.c
index 3407a176d863..2100d1d647cd 100644
--- a/sys/dev/sfxge/sfxge_port.c
+++ b/sys/dev/sfxge/sfxge_port.c
@@ -194,11 +194,9 @@ sfxge_mac_stat_init(struct sfxge_softc *sc)
 	/* Initialise the named stats */
 	for (id = 0; id < EFX_MAC_NSTATS; id++) {
 		name = efx_mac_stat_name(sc->enp, id);
-		SYSCTL_ADD_PROC(
-			ctx, stat_list,
-			OID_AUTO, name, CTLTYPE_U64|CTLFLAG_RD,
-			sc, id, sfxge_mac_stat_handler, "Q",
-			"");
+		SYSCTL_ADD_PROC(ctx, stat_list, OID_AUTO, name,
+		    CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
+		    sc, id, sfxge_mac_stat_handler, "Q", "");
 	}
 }
 
@@ -650,12 +648,10 @@ sfxge_phy_stat_init(struct sfxge_softc *sc)
 		if (!(stat_mask & ((uint64_t)1 << id)))
 			continue;
 		name = efx_phy_stat_name(sc->enp, id);
-		SYSCTL_ADD_PROC(
-			ctx, stat_list,
-			OID_AUTO, name, CTLTYPE_UINT|CTLFLAG_RD,
-			sc, id, sfxge_phy_stat_handler,
-			id == EFX_PHY_STAT_OUI ? "IX" : "IU",
-			"");
+		SYSCTL_ADD_PROC(ctx, stat_list, OID_AUTO, name,
+		    CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_MPSAFE,
+		    sc, id, sfxge_phy_stat_handler,
+		    id == EFX_PHY_STAT_OUI ? "IX" : "IU", "");
 	}
 }
 
@@ -787,10 +783,10 @@ sfxge_port_init(struct sfxge_softc *sc)
 	 * ifmedia, provide sysctls for it. */
 	port->wanted_fc = EFX_FCNTL_RESPOND | EFX_FCNTL_GENERATE;
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "wanted_fc", CTLTYPE_UINT|CTLFLAG_RW, sc, 0,
+	    "wanted_fc", CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
 	    sfxge_port_wanted_fc_handler, "IU", "wanted flow control mode");
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "link_fc", CTLTYPE_UINT|CTLFLAG_RD, sc, 0,
+	    "link_fc", CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_MPSAFE, sc, 0,
 	    sfxge_port_link_fc_handler, "IU", "link flow control mode");
 #endif
 
@@ -806,7 +802,8 @@ sfxge_port_init(struct sfxge_softc *sc)
 	sfxge_mac_stat_init(sc);
 
 	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
-	    "stats_update_period_ms", CTLTYPE_UINT|CTLFLAG_RW, sc, 0,
+	    "stats_update_period_ms",
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
 	    sfxge_port_stats_update_period_ms_handler, "IU",
 	    "interface statistics refresh period");
 
diff --git a/sys/dev/sfxge/sfxge_rx.c b/sys/dev/sfxge/sfxge_rx.c
index cb1caae80165..c1fd93728594 100644
--- a/sys/dev/sfxge/sfxge_rx.c
+++ b/sys/dev/sfxge/sfxge_rx.c
@@ -73,8 +73,8 @@ __FBSDID("$FreeBSD$");
 
 #ifdef SFXGE_LRO
 
-SYSCTL_NODE(_hw_sfxge, OID_AUTO, lro, CTLFLAG_RD, NULL,
-	    "Large receive offload (LRO) parameters");
+SYSCTL_NODE(_hw_sfxge, OID_AUTO, lro, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+    "Large receive offload (LRO) parameters");
 
 #define	SFXGE_LRO_PARAM(_param)	SFXGE_PARAM(lro._param)
 
@@ -1356,12 +1356,10 @@ sfxge_rx_stat_init(struct sfxge_softc *sc)
 	stat_list = SYSCTL_CHILDREN(sc->stats_node);
 
 	for (id = 0; id < nitems(sfxge_rx_stats); id++) {
-		SYSCTL_ADD_PROC(
-			ctx, stat_list,
-			OID_AUTO, sfxge_rx_stats[id].name,
-			CTLTYPE_UINT|CTLFLAG_RD,
-			sc, id, sfxge_rx_stat_handler, "IU",
-			"");
+		SYSCTL_ADD_PROC(ctx, stat_list, OID_AUTO,
+		    sfxge_rx_stats[id].name,
+		    CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+		    sc, id, sfxge_rx_stat_handler, "IU", "");
 	}
 }
 
diff --git a/sys/dev/sfxge/sfxge_tx.c b/sys/dev/sfxge/sfxge_tx.c
index 25841e10e381..bdf698881301 100644
--- a/sys/dev/sfxge/sfxge_tx.c
+++ b/sys/dev/sfxge/sfxge_tx.c
@@ -1760,8 +1760,7 @@ sfxge_txq_stat_init(struct sfxge_txq *txq, struct sysctl_oid *txq_node)
 	unsigned int id;
 
 	stat_node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(txq_node), OID_AUTO,
-				    "stats", CTLFLAG_RD, NULL,
-				    "Tx queue statistics");
+	    "stats", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Tx queue statistics");
 	if (stat_node == NULL)
 		return (ENOMEM);
 
@@ -1872,7 +1871,7 @@ sfxge_tx_qinit(struct sfxge_softc *sc, unsigned int txq_index,
 
 	snprintf(name, sizeof(name), "%u", txq_index);
 	txq_node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sc->txqs_node),
-				   OID_AUTO, name, CTLFLAG_RD, NULL, "");
+	    OID_AUTO, name, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
 	if (txq_node == NULL) {
 		rc = ENOMEM;
 		goto fail_txq_node;
@@ -1892,8 +1891,8 @@ sfxge_tx_qinit(struct sfxge_softc *sc, unsigned int txq_index,
 	SFXGE_TXQ_LOCK_INIT(txq, device_get_nameunit(sc->dev), txq_index);
 
 	dpl_node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(txq_node), OID_AUTO,
-				   "dpl", CTLFLAG_RD, NULL,
-				   "Deferred packet list statistics");
+	    "dpl", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
+	    "Deferred packet list statistics");
 	if (dpl_node == NULL) {
 		rc = ENOMEM;
 		goto fail_dpl_node;
@@ -1966,12 +1965,10 @@ sfxge_tx_stat_init(struct sfxge_softc *sc)
 	stat_list = SYSCTL_CHILDREN(sc->stats_node);
 
 	for (id = 0; id < nitems(sfxge_tx_stats); id++) {
-		SYSCTL_ADD_PROC(
-			ctx, stat_list,
-			OID_AUTO, sfxge_tx_stats[id].name,
-			CTLTYPE_ULONG|CTLFLAG_RD,
-			sc, id, sfxge_tx_stat_handler, "LU",
-			"");
+		SYSCTL_ADD_PROC(ctx, stat_list, OID_AUTO,
+		    sfxge_tx_stats[id].name,
+		    CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
+		    sc, id, sfxge_tx_stat_handler, "LU", "");
 	}
 }
 
@@ -2054,10 +2051,9 @@ sfxge_tx_init(struct sfxge_softc *sc)
 	    (!encp->enc_fw_assisted_tso_v2_enabled))
 		sc->tso_fw_assisted &= ~SFXGE_FATSOV2;
 
-	sc->txqs_node = SYSCTL_ADD_NODE(
-		device_get_sysctl_ctx(sc->dev),
-		SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)),
-		OID_AUTO, "txq", CTLFLAG_RD, NULL, "Tx queues");
+	sc->txqs_node = SYSCTL_ADD_NODE(device_get_sysctl_ctx(sc->dev),
+	    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), OID_AUTO,
+	    "txq", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Tx queues");
 	if (sc->txqs_node == NULL) {
 		rc = ENOMEM;
 		goto fail_txq_node;
diff --git a/sys/dev/sk/if_sk.c b/sys/dev/sk/if_sk.c
index 2e85d84c485a..037a9aaf388a 100644
--- a/sys/dev/sk/if_sk.c
+++ b/sys/dev/sk/if_sk.c
@@ -1596,7 +1596,8 @@ skc_attach(dev)
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 		SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-		OID_AUTO, "int_mod", CTLTYPE_INT|CTLFLAG_RW,
+		OID_AUTO, "int_mod",
+		CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 		&sc->sk_int_mod, 0, sysctl_hw_sk_int_mod, "I",
 		"SK interrupt moderation");
 
diff --git a/sys/dev/sound/clone.c b/sys/dev/sound/clone.c
index 125d80152c36..3ded510eae5c 100644
--- a/sys/dev/sound/clone.c
+++ b/sys/dev/sound/clone.c
@@ -158,8 +158,9 @@ sysctl_hw_snd_timestamp_precision(SYSCTL_HANDLER_ARGS)
 
 	return (err);
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, timestamp_precision, CTLTYPE_INT | CTLFLAG_RW,
-    0, sizeof(int), sysctl_hw_snd_timestamp_precision, "I",
+SYSCTL_PROC(_hw_snd, OID_AUTO, timestamp_precision,
+    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_timestamp_precision, "I",
     "timestamp precision (0=s 1=hz 2=us 3=ns)");
 #endif
 
diff --git a/sys/dev/sound/midi/midi.c b/sys/dev/sound/midi/midi.c
index a58f95dff7f7..e33c622540d3 100644
--- a/sys/dev/sound/midi/midi.c
+++ b/sys/dev/sound/midi/midi.c
@@ -243,8 +243,10 @@ static int      midi_unload(void);
 /*
  * Misc declr.
  */
-SYSCTL_NODE(_hw, OID_AUTO, midi, CTLFLAG_RD, 0, "Midi driver");
-static SYSCTL_NODE(_hw_midi, OID_AUTO, stat, CTLFLAG_RD, 0, "Status device");
+SYSCTL_NODE(_hw, OID_AUTO, midi, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Midi driver");
+static SYSCTL_NODE(_hw_midi, OID_AUTO, stat, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Status device");
 
 int             midi_debug;
 /* XXX: should this be moved into debug.midi? */
diff --git a/sys/dev/sound/midi/sequencer.c b/sys/dev/sound/midi/sequencer.c
index f5fba6c0c77d..b264861265d7 100644
--- a/sys/dev/sound/midi/sequencer.c
+++ b/sys/dev/sound/midi/sequencer.c
@@ -159,7 +159,8 @@ struct seq_softc {
  * we currently own.
  */
 
-SYSCTL_NODE(_hw_midi, OID_AUTO, seq, CTLFLAG_RD, 0, "Midi sequencer");
+SYSCTL_NODE(_hw_midi, OID_AUTO, seq, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Midi sequencer");
 
 int					seq_debug;
 /* XXX: should this be moved into debug.midi? */
diff --git a/sys/dev/sound/pci/atiixp.c b/sys/dev/sound/pci/atiixp.c
index f1aba8730510..5d3ba1180e19 100644
--- a/sys/dev/sound/pci/atiixp.c
+++ b/sys/dev/sound/pci/atiixp.c
@@ -1096,8 +1096,8 @@ atiixp_chip_post_init(void *arg)
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), OID_AUTO,
-	    "polling", CTLTYPE_INT | CTLFLAG_RW, sc->dev, sizeof(sc->dev),
-	    sysctl_atiixp_polling, "I", "Enable polling mode");
+	    "polling", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc->dev,
+	    sizeof(sc->dev), sysctl_atiixp_polling, "I", "Enable polling mode");
 
 	snprintf(status, SND_STATUSLEN, "at memory 0x%jx irq %jd %s",
 	    rman_get_start(sc->reg), rman_get_start(sc->irq),
diff --git a/sys/dev/sound/pci/emu10kx.c b/sys/dev/sound/pci/emu10kx.c
index 94159f583d39..7d2d77abf918 100644
--- a/sys/dev/sound/pci/emu10kx.c
+++ b/sys/dev/sound/pci/emu10kx.c
@@ -1577,10 +1577,9 @@ emu_addefxmixer(struct emu_sc_info *sc, const char *mix_name, const int mix_id,
 		 */
 		snprintf(sysctl_name, 32, "_%s", mix_name);
 		SYSCTL_ADD_PROC(sc->ctx,
-			SYSCTL_CHILDREN(sc->root),
-			OID_AUTO, sysctl_name,
-			CTLTYPE_INT | CTLFLAG_RW, sc, mix_id,
-			sysctl_emu_mixer_control, "I", "");
+		    SYSCTL_CHILDREN(sc->root), OID_AUTO, sysctl_name,
+		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, mix_id,
+		    sysctl_emu_mixer_control, "I", "");
 	}
 
 	return (volgpr);
@@ -1618,11 +1617,10 @@ static void
 emu_digitalswitch(struct emu_sc_info *sc)
 {
 	/* XXX temporary? */
-	SYSCTL_ADD_PROC(sc->ctx,
-		SYSCTL_CHILDREN(sc->root),
-		OID_AUTO, "_digital",
-		CTLTYPE_INT | CTLFLAG_RW, sc, 0,
-		sysctl_emu_digitalswitch_control, "I", "Enable digital output");
+	SYSCTL_ADD_PROC(sc->ctx, SYSCTL_CHILDREN(sc->root), OID_AUTO,
+	    "_digital", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    sc, 0, sysctl_emu_digitalswitch_control, "I",
+	    "Enable digital output");
 
 	return;
 }
diff --git a/sys/dev/sound/pci/es137x.c b/sys/dev/sound/pci/es137x.c
index e11240a9e07e..1d6961052095 100644
--- a/sys/dev/sound/pci/es137x.c
+++ b/sys/dev/sound/pci/es137x.c
@@ -1647,8 +1647,8 @@ es_init_sysctls(device_t dev)
 		   <861wujij2q.fsf@xps.des.no> */
 		SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 		    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-		    "spdif_enabled", CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
-		    sysctl_es137x_spdif_enable, "I",
+		    "spdif_enabled", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
+		    dev, sizeof(dev), sysctl_es137x_spdif_enable, "I",
 		    "Enable S/PDIF output on primary playback channel");
 	} else if (devid == ES1370_PCI_ID) {
 		/*
@@ -1663,7 +1663,8 @@ es_init_sysctls(device_t dev)
 		   <861wujij2q.fsf@xps.des.no> */
 			SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 			    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-			    OID_AUTO, "fixed_rate", CTLTYPE_INT | CTLFLAG_RW,
+			    OID_AUTO, "fixed_rate",
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
 			    dev, sizeof(dev), sysctl_es137x_fixed_rate, "I",
 			    "Enable fixed rate playback/recording");
 		}
@@ -1680,8 +1681,8 @@ es_init_sysctls(device_t dev)
 			SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 			    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 			    OID_AUTO, "single_pcm_mixer",
-			    CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
-			    sysctl_es137x_single_pcm_mixer, "I",
+			    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, dev,
+			    sizeof(dev), sysctl_es137x_single_pcm_mixer, "I",
 			    "Single PCM mixer controller for both DAC1/DAC2");
 		}
 	}
@@ -1693,14 +1694,13 @@ es_init_sysctls(device_t dev)
 	   multimedia@ in msg-id <861wujij2q.fsf@xps.des.no> */
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "latency_timer", CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
-	    sysctl_es137x_latency_timer, "I",
+	    "latency_timer", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
+	    dev, sizeof(dev), sysctl_es137x_latency_timer, "I",
 	    "PCI Latency Timer configuration");
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "polling", CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
-	    sysctl_es_polling, "I",
-	    "Enable polling mode");
+	    "polling", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, dev,
+	    sizeof(dev), sysctl_es_polling, "I", "Enable polling mode");
 }
 
 static int
diff --git a/sys/dev/sound/pci/hda/hdaa.c b/sys/dev/sound/pci/hda/hdaa.c
index 5a926a125de5..e093ed4f2cc4 100644
--- a/sys/dev/sound/pci/hda/hdaa.c
+++ b/sys/dev/sound/pci/hda/hdaa.c
@@ -6671,7 +6671,7 @@ hdaa_attach(device_t dev)
 	    devinfo, 0, hdaa_sysctl_gpo_config, "A", "GPO configuration");
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "reconfig", CTLTYPE_INT | CTLFLAG_RW,
+	    "reconfig", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 	    dev, 0, hdaa_sysctl_reconfig, "I", "Reprocess configuration");
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
diff --git a/sys/dev/sound/pci/hda/hdac.c b/sys/dev/sound/pci/hda/hdac.c
index 9dda7f058916..cf9a437aca8f 100644
--- a/sys/dev/sound/pci/hda/hdac.c
+++ b/sys/dev/sound/pci/hda/hdac.c
@@ -1565,12 +1565,12 @@ hdac_attach2(void *arg)
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), OID_AUTO,
-	    "pindump", CTLTYPE_INT | CTLFLAG_RW, sc->dev, sizeof(sc->dev),
-	    sysctl_hdac_pindump, "I", "Dump pin states/data");
+	    "pindump", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc->dev,
+	    sizeof(sc->dev), sysctl_hdac_pindump, "I", "Dump pin states/data");
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), OID_AUTO,
-	    "polling", CTLTYPE_INT | CTLFLAG_RW, sc->dev, sizeof(sc->dev),
-	    sysctl_hdac_polling, "I", "Enable polling mode");
+	    "polling", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc->dev,
+	    sizeof(sc->dev), sysctl_hdac_polling, "I", "Enable polling mode");
 }
 
 /****************************************************************************
diff --git a/sys/dev/sound/pci/maestro.c b/sys/dev/sound/pci/maestro.c
index 20f40e3c444e..a45f59ff2fad 100644
--- a/sys/dev/sound/pci/maestro.c
+++ b/sys/dev/sound/pci/maestro.c
@@ -190,7 +190,8 @@ static unsigned int powerstate_init   = PCI_POWERSTATE_D2;
 /* XXX: this should move to a device specific sysctl dev.pcm.X.debug.Y via
    device_get_sysctl_*() as discussed on multimedia@ in msg-id
    <861wujij2q.fsf@xps.des.no> */
-static SYSCTL_NODE(_debug, OID_AUTO, maestro, CTLFLAG_RD, 0, "");
+static SYSCTL_NODE(_debug, OID_AUTO, maestro, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "");
 SYSCTL_UINT(_debug_maestro, OID_AUTO, powerstate_active, CTLFLAG_RW,
 	    &powerstate_active, 0, "The Dx power state when active (0-1)");
 SYSCTL_UINT(_debug_maestro, OID_AUTO, powerstate_idle, CTLFLAG_RW,
diff --git a/sys/dev/sound/pci/via8233.c b/sys/dev/sound/pci/via8233.c
index 217d61e91e0a..e4f23ee9d84b 100644
--- a/sys/dev/sound/pci/via8233.c
+++ b/sys/dev/sound/pci/via8233.c
@@ -258,19 +258,18 @@ via_init_sysctls(device_t dev)
 	   as discussed on multimedia@ in msg-id <861wujij2q.fsf@xps.des.no> */
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "spdif_enabled",  CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
-	    sysctl_via8233_spdif_enable, "I",
+	    "spdif_enabled", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
+	    dev, sizeof(dev), sysctl_via8233_spdif_enable, "I",
 	    "Enable S/PDIF output on primary playback channel");
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "dxs_src", CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
-	    sysctl_via8233_dxs_src, "I",
+	    "dxs_src", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
+	    dev, sizeof(dev), sysctl_via8233_dxs_src, "I",
 	    "Enable VIA DXS Sample Rate Converter");
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "polling", CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
-	    sysctl_via_polling, "I",
-	    "Enable polling mode");
+	    "polling", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
+	    dev, sizeof(dev), sysctl_via_polling, "I", "Enable polling mode");
 }
 
 static __inline uint32_t
diff --git a/sys/dev/sound/pcm/ac97.c b/sys/dev/sound/pcm/ac97.c
index 70316c34b72b..960176329b3e 100644
--- a/sys/dev/sound/pcm/ac97.c
+++ b/sys/dev/sound/pcm/ac97.c
@@ -919,7 +919,8 @@ ac97_init_sysctl(struct ac97_info *codec)
 		return;
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(codec->dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(codec->dev)),
-            OID_AUTO, "eapd", CTLTYPE_INT | CTLFLAG_RW,
+            OID_AUTO, "eapd",
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
 	    codec, sizeof(codec), sysctl_hw_snd_ac97_eapd,
 	    "I", "AC97 External Amplifier");
 }
diff --git a/sys/dev/sound/pcm/channel.c b/sys/dev/sound/pcm/channel.c
index ecf89df4c9a2..38c578ba8282 100644
--- a/sys/dev/sound/pcm/channel.c
+++ b/sys/dev/sound/pcm/channel.c
@@ -68,9 +68,10 @@ sysctl_hw_snd_latency(SYSCTL_HANDLER_ARGS)
 
 	return err;
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, latency, CTLTYPE_INT | CTLFLAG_RWTUN,
-	0, sizeof(int), sysctl_hw_snd_latency, "I",
-	"buffering latency (0=low ... 10=high)");
+SYSCTL_PROC(_hw_snd, OID_AUTO, latency,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_latency, "I",
+    "buffering latency (0=low ... 10=high)");
 
 int chn_latency_profile = CHN_LATENCY_PROFILE_DEFAULT;
 
@@ -90,9 +91,10 @@ sysctl_hw_snd_latency_profile(SYSCTL_HANDLER_ARGS)
 
 	return err;
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, latency_profile, CTLTYPE_INT | CTLFLAG_RWTUN,
-	0, sizeof(int), sysctl_hw_snd_latency_profile, "I",
-	"buffering latency profile (0=aggressive 1=safe)");
+SYSCTL_PROC(_hw_snd, OID_AUTO, latency_profile,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_latency_profile, "I",
+    "buffering latency profile (0=aggressive 1=safe)");
 
 static int chn_timeout = CHN_TIMEOUT;
 
@@ -112,9 +114,10 @@ sysctl_hw_snd_timeout(SYSCTL_HANDLER_ARGS)
 
 	return err;
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, timeout, CTLTYPE_INT | CTLFLAG_RWTUN,
-	0, sizeof(int), sysctl_hw_snd_timeout, "I",
-	"interrupt timeout (1 - 10) seconds");
+SYSCTL_PROC(_hw_snd, OID_AUTO, timeout,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_timeout, "I",
+    "interrupt timeout (1 - 10) seconds");
 
 static int chn_vpc_autoreset = 1;
 SYSCTL_INT(_hw_snd, OID_AUTO, vpc_autoreset, CTLFLAG_RWTUN,
@@ -166,9 +169,10 @@ sysctl_hw_snd_vpc_0db(SYSCTL_HANDLER_ARGS)
 
 	return (0);
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, vpc_0db, CTLTYPE_INT | CTLFLAG_RWTUN,
-	0, sizeof(int), sysctl_hw_snd_vpc_0db, "I",
-	"0db relative level");
+SYSCTL_PROC(_hw_snd, OID_AUTO, vpc_0db,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_vpc_0db, "I",
+    "0db relative level");
 
 static int
 sysctl_hw_snd_vpc_reset(SYSCTL_HANDLER_ARGS)
@@ -185,9 +189,10 @@ sysctl_hw_snd_vpc_reset(SYSCTL_HANDLER_ARGS)
 
 	return (0);
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, vpc_reset, CTLTYPE_INT | CTLFLAG_RW,
-	0, sizeof(int), sysctl_hw_snd_vpc_reset, "I",
-	"reset volume on all channels");
+SYSCTL_PROC(_hw_snd, OID_AUTO, vpc_reset,
+    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_vpc_reset, "I",
+    "reset volume on all channels");
 
 static int chn_usefrags = 0;
 static int chn_syncdelay = -1;
diff --git a/sys/dev/sound/pcm/feeder_eq.c b/sys/dev/sound/pcm/feeder_eq.c
index 4c3cf0f14de3..fcce9e56075e 100644
--- a/sys/dev/sound/pcm/feeder_eq.c
+++ b/sys/dev/sound/pcm/feeder_eq.c
@@ -684,8 +684,8 @@ feeder_eq_initsys(device_t dev)
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "eq", CTLTYPE_INT | CTLFLAG_RWTUN, d, sizeof(d),
-	    sysctl_dev_pcm_eq, "I",
+	    "eq", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, d,
+	    sizeof(d), sysctl_dev_pcm_eq, "I",
 	    "Bass/Treble Equalizer (0=disable, 1=enable, 2=bypass)");
 
 	(void)snprintf(buf, sizeof(buf), "Bass/Treble Equalizer Preamp "
@@ -696,7 +696,7 @@ feeder_eq_initsys(device_t dev)
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "eq_preamp", CTLTYPE_STRING | CTLFLAG_RWTUN, d, sizeof(d),
-	    sysctl_dev_pcm_eq_preamp, "A", buf);
+	    "eq_preamp", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
+	    d, sizeof(d), sysctl_dev_pcm_eq_preamp, "A", buf);
 }
 #endif
diff --git a/sys/dev/sound/pcm/feeder_rate.c b/sys/dev/sound/pcm/feeder_rate.c
index 35622d84d26a..bca5528a558a 100644
--- a/sys/dev/sound/pcm/feeder_rate.c
+++ b/sys/dev/sound/pcm/feeder_rate.c
@@ -185,8 +185,9 @@ sysctl_hw_snd_feeder_rate_min(SYSCTL_HANDLER_ARGS)
 
 	return (0);
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_min, CTLTYPE_INT | CTLFLAG_RWTUN,
-    0, sizeof(int), sysctl_hw_snd_feeder_rate_min, "I",
+SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_min,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_feeder_rate_min, "I",
     "minimum allowable rate");
 
 static int
@@ -207,8 +208,9 @@ sysctl_hw_snd_feeder_rate_max(SYSCTL_HANDLER_ARGS)
 
 	return (0);
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_max, CTLTYPE_INT | CTLFLAG_RWTUN,
-    0, sizeof(int), sysctl_hw_snd_feeder_rate_max, "I",
+SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_max,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_feeder_rate_max, "I",
     "maximum allowable rate");
 
 static int
@@ -229,8 +231,9 @@ sysctl_hw_snd_feeder_rate_round(SYSCTL_HANDLER_ARGS)
 
 	return (0);
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_round, CTLTYPE_INT | CTLFLAG_RWTUN,
-    0, sizeof(int), sysctl_hw_snd_feeder_rate_round, "I",
+SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_round,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_feeder_rate_round, "I",
     "sample rate converter rounding threshold");
 
 static int
@@ -281,8 +284,9 @@ sysctl_hw_snd_feeder_rate_quality(SYSCTL_HANDLER_ARGS)
 
 	return (0);
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_quality, CTLTYPE_INT | CTLFLAG_RWTUN,
-    0, sizeof(int), sysctl_hw_snd_feeder_rate_quality, "I",
+SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_quality,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_feeder_rate_quality, "I",
     "sample rate converter quality ("__XSTRING(Z_QUALITY_MIN)"=low .. "
     __XSTRING(Z_QUALITY_MAX)"=high)");
 #endif	/* _KERNEL */
diff --git a/sys/dev/sound/pcm/mixer.c b/sys/dev/sound/pcm/mixer.c
index 016abcf24744..c58988758b62 100644
--- a/sys/dev/sound/pcm/mixer.c
+++ b/sys/dev/sound/pcm/mixer.c
@@ -888,9 +888,9 @@ mixer_hwvol_init(device_t dev)
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
             OID_AUTO, "hwvol_step", CTLFLAG_RWTUN, &m->hwvol_step, 0, "");
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-            OID_AUTO, "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RWTUN, m, 0,
-	    sysctl_hw_snd_hwvol_mixer, "A", "");
+	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
+	    "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
+	    m, 0, sysctl_hw_snd_hwvol_mixer, "A", "");
 	return 0;
 }
 
diff --git a/sys/dev/sound/pcm/sndstat.c b/sys/dev/sound/pcm/sndstat.c
index 0237c8e3311c..99b35e923d47 100644
--- a/sys/dev/sound/pcm/sndstat.c
+++ b/sys/dev/sound/pcm/sndstat.c
@@ -100,8 +100,10 @@ sysctl_hw_sndverbose(SYSCTL_HANDLER_ARGS)
 	}
 	return (error);
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, verbose, CTLTYPE_INT | CTLFLAG_RWTUN,
-            0, sizeof(int), sysctl_hw_sndverbose, "I", "verbosity level");
+SYSCTL_PROC(_hw_snd, OID_AUTO, verbose,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_sndverbose, "I",
+    "verbosity level");
 
 static int
 sndstat_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
diff --git a/sys/dev/sound/pcm/sound.c b/sys/dev/sound/pcm/sound.c
index 378cf085e4b8..bd3b4c684365 100644
--- a/sys/dev/sound/pcm/sound.c
+++ b/sys/dev/sound/pcm/sound.c
@@ -58,7 +58,8 @@ SYSCTL_INT(_hw_snd, OID_AUTO, default_auto, CTLFLAG_RWTUN,
 
 int snd_maxautovchans = 16;
 
-SYSCTL_NODE(_hw, OID_AUTO, snd, CTLFLAG_RD, 0, "Sound driver");
+SYSCTL_NODE(_hw, OID_AUTO, snd, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Sound driver");
 
 static void pcm_sysinit(device_t);
 
@@ -443,9 +444,9 @@ sysctl_hw_snd_default_unit(SYSCTL_HANDLER_ARGS)
 }
 /* XXX: do we need a way to let the user change the default unit? */
 SYSCTL_PROC(_hw_snd, OID_AUTO, default_unit,
-	    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_ANYBODY,
-	    0, sizeof(int), sysctl_hw_snd_default_unit, "I",
-	    "default sound device");
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_ANYBODY | CTLFLAG_NEEDGIANT, 0,
+    sizeof(int), sysctl_hw_snd_default_unit, "I",
+    "default sound device");
 
 static int
 sysctl_hw_snd_maxautovchans(SYSCTL_HANDLER_ARGS)
@@ -473,8 +474,10 @@ sysctl_hw_snd_maxautovchans(SYSCTL_HANDLER_ARGS)
 	}
 	return (error);
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, maxautovchans, CTLTYPE_INT | CTLFLAG_RWTUN,
-            0, sizeof(int), sysctl_hw_snd_maxautovchans, "I", "maximum virtual channel");
+SYSCTL_PROC(_hw_snd, OID_AUTO, maxautovchans,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_maxautovchans, "I",
+    "maximum virtual channel");
 
 struct pcm_channel *
 pcm_chn_create(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls, int dir, int num, void *devinfo)
@@ -1007,8 +1010,9 @@ sysctl_hw_snd_clone_gc(SYSCTL_HANDLER_ARGS)
 
 	return (err);
 }
-SYSCTL_PROC(_hw_snd, OID_AUTO, clone_gc, CTLTYPE_INT | CTLFLAG_RWTUN,
-    0, sizeof(int), sysctl_hw_snd_clone_gc, "I",
+SYSCTL_PROC(_hw_snd, OID_AUTO, clone_gc,
+    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int),
+    sysctl_hw_snd_clone_gc, "I",
     "global clone garbage collector");
 #endif
 
@@ -1024,25 +1028,25 @@ pcm_sysinit(device_t dev)
             OID_AUTO, "buffersize", CTLFLAG_RD, &d->bufsz, 0, "allocated buffer size");
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "bitperfect", CTLTYPE_INT | CTLFLAG_RWTUN, d, sizeof(d),
-	    sysctl_dev_pcm_bitperfect, "I",
+	    "bitperfect", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, d,
+	    sizeof(d), sysctl_dev_pcm_bitperfect, "I",
 	    "bit-perfect playback/recording (0=disable, 1=enable)");
 #ifdef SND_DEBUG
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "clone_flags", CTLTYPE_UINT | CTLFLAG_RWTUN, d, sizeof(d),
-	    sysctl_dev_pcm_clone_flags, "IU",
+	    "clone_flags", CTLTYPE_UINT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT,
+	    d, sizeof(d), sysctl_dev_pcm_clone_flags, "IU",
 	    "clone flags");
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "clone_deadline", CTLTYPE_INT | CTLFLAG_RWTUN, d, sizeof(d),
-	    sysctl_dev_pcm_clone_deadline, "I",
+	    "clone_deadline", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT,
+	    d, sizeof(d), sysctl_dev_pcm_clone_deadline, "I",
 	    "clone expiration deadline (ms)");
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "clone_gc", CTLTYPE_INT | CTLFLAG_RWTUN, d, sizeof(d),
-	    sysctl_dev_pcm_clone_gc, "I",
-	    "clone garbage collector");
+	    "clone_gc",
+	    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, d, sizeof(d),
+	    sysctl_dev_pcm_clone_gc, "I", "clone garbage collector");
 #endif
 	if (d->flags & SD_F_AUTOVCHAN)
 		vchan_initsys(dev);
@@ -1126,11 +1130,11 @@ pcm_register(device_t dev, void *devinfo, int numplay, int numrec)
 	sysctl_ctx_init(&d->play_sysctl_ctx);
 	d->play_sysctl_tree = SYSCTL_ADD_NODE(&d->play_sysctl_ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "play",
-	    CTLFLAG_RD, 0, "playback channels node");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "playback channels node");
 	sysctl_ctx_init(&d->rec_sysctl_ctx);
 	d->rec_sysctl_tree = SYSCTL_ADD_NODE(&d->rec_sysctl_ctx,
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "rec",
-	    CTLFLAG_RD, 0, "record channels node");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "record channels node");
 
 	if (numplay > 0 || numrec > 0)
 		d->flags |= SD_F_AUTOVCHAN;
diff --git a/sys/dev/sound/pcm/vchan.c b/sys/dev/sound/pcm/vchan.c
index d8e3509d0ebd..a731968931b6 100644
--- a/sys/dev/sound/pcm/vchan.c
+++ b/sys/dev/sound/pcm/vchan.c
@@ -948,45 +948,52 @@ vchan_initsys(device_t dev)
 	/* Play */
 	SYSCTL_ADD_PROC(&d->play_sysctl_ctx,
 	    SYSCTL_CHILDREN(d->play_sysctl_tree),
-	    OID_AUTO, "vchans", CTLTYPE_INT | CTLFLAG_RWTUN,
+	    OID_AUTO, "vchans", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
 	    VCHAN_SYSCTL_DATA(unit, PLAY), VCHAN_SYSCTL_DATA_SIZE,
 	    sysctl_dev_pcm_vchans, "I", "total allocated virtual channel");
 	SYSCTL_ADD_PROC(&d->play_sysctl_ctx,
 	    SYSCTL_CHILDREN(d->play_sysctl_tree),
-	    OID_AUTO, "vchanmode", CTLTYPE_STRING | CTLFLAG_RWTUN,
+	    OID_AUTO, "vchanmode",
+	    CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
 	    VCHAN_SYSCTL_DATA(unit, PLAY), VCHAN_SYSCTL_DATA_SIZE,
 	    sysctl_dev_pcm_vchanmode, "A",
 	    "vchan format/rate selection: 0=fixed, 1=passthrough, 2=adaptive");
 	SYSCTL_ADD_PROC(&d->play_sysctl_ctx,
 	    SYSCTL_CHILDREN(d->play_sysctl_tree),
-	    OID_AUTO, "vchanrate", CTLTYPE_INT | CTLFLAG_RWTUN,
+	    OID_AUTO, "vchanrate",
+	    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
 	    VCHAN_SYSCTL_DATA(unit, PLAY), VCHAN_SYSCTL_DATA_SIZE,
 	    sysctl_dev_pcm_vchanrate, "I", "virtual channel mixing speed/rate");
 	SYSCTL_ADD_PROC(&d->play_sysctl_ctx,
 	    SYSCTL_CHILDREN(d->play_sysctl_tree),
-	    OID_AUTO, "vchanformat", CTLTYPE_STRING | CTLFLAG_RWTUN,
+	    OID_AUTO, "vchanformat",
+	    CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
 	    VCHAN_SYSCTL_DATA(unit, PLAY), VCHAN_SYSCTL_DATA_SIZE,
 	    sysctl_dev_pcm_vchanformat, "A", "virtual channel mixing format");
 	/* Rec */
 	SYSCTL_ADD_PROC(&d->rec_sysctl_ctx,
 	    SYSCTL_CHILDREN(d->rec_sysctl_tree),
-	    OID_AUTO, "vchans", CTLTYPE_INT | CTLFLAG_RWTUN,
+	    OID_AUTO, "vchans",
+	    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
 	    VCHAN_SYSCTL_DATA(unit, REC), VCHAN_SYSCTL_DATA_SIZE,
 	    sysctl_dev_pcm_vchans, "I", "total allocated virtual channel");
 	SYSCTL_ADD_PROC(&d->rec_sysctl_ctx,
 	    SYSCTL_CHILDREN(d->rec_sysctl_tree),
-	    OID_AUTO, "vchanmode", CTLTYPE_STRING | CTLFLAG_RWTUN,
+	    OID_AUTO, "vchanmode",
+	    CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
 	    VCHAN_SYSCTL_DATA(unit, REC), VCHAN_SYSCTL_DATA_SIZE,
 	    sysctl_dev_pcm_vchanmode, "A",
 	    "vchan format/rate selection: 0=fixed, 1=passthrough, 2=adaptive");
 	SYSCTL_ADD_PROC(&d->rec_sysctl_ctx,
 	    SYSCTL_CHILDREN(d->rec_sysctl_tree),
-	    OID_AUTO, "vchanrate", CTLTYPE_INT | CTLFLAG_RWTUN,
+	    OID_AUTO, "vchanrate",
+	    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
 	    VCHAN_SYSCTL_DATA(unit, REC), VCHAN_SYSCTL_DATA_SIZE,
 	    sysctl_dev_pcm_vchanrate, "I", "virtual channel mixing speed/rate");
 	SYSCTL_ADD_PROC(&d->rec_sysctl_ctx,
 	    SYSCTL_CHILDREN(d->rec_sysctl_tree),
-	    OID_AUTO, "vchanformat", CTLTYPE_STRING | CTLFLAG_RWTUN,
+	    OID_AUTO, "vchanformat",
+	    CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
 	    VCHAN_SYSCTL_DATA(unit, REC), VCHAN_SYSCTL_DATA_SIZE,
 	    sysctl_dev_pcm_vchanformat, "A", "virtual channel mixing format");
 }
diff --git a/sys/dev/ste/if_ste.c b/sys/dev/ste/if_ste.c
index 0315208e6995..77ef3ef8e6fa 100644
--- a/sys/dev/ste/if_ste.c
+++ b/sys/dev/ste/if_ste.c
@@ -2053,13 +2053,13 @@ ste_sysctl_node(struct ste_softc *sc)
 	resource_int_value(device_get_name(sc->ste_dev),
 	    device_get_unit(sc->ste_dev), "int_rx_mod", &sc->ste_int_rx_mod);
 
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "STE statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "STE statistics");
 	parent = SYSCTL_CHILDREN(tree);
 
 	/* Rx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "Rx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Rx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	STE_SYSCTL_STAT_ADD64(ctx, child, "good_octets",
 	    &stats->rx_bytes, "Good octets");
@@ -2073,8 +2073,8 @@ ste_sysctl_node(struct ste_softc *sc)
 	    &stats->rx_lost_frames, "Lost frames");
 
 	/* Tx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "Tx MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Tx MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	STE_SYSCTL_STAT_ADD64(ctx, child, "good_octets",
 	    &stats->tx_bytes, "Good octets");
diff --git a/sys/dev/stge/if_stge.c b/sys/dev/stge/if_stge.c
index 6a8c6fd90de5..6d6462a98fdc 100644
--- a/sys/dev/stge/if_stge.c
+++ b/sys/dev/stge/if_stge.c
@@ -476,13 +476,15 @@ stge_attach(device_t dev)
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "rxint_nframe", CTLTYPE_INT|CTLFLAG_RW, &sc->sc_rxint_nframe, 0,
-	    sysctl_hw_stge_rxint_nframe, "I", "stge rx interrupt nframe");
+	    "rxint_nframe", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    &sc->sc_rxint_nframe, 0, sysctl_hw_stge_rxint_nframe, "I",
+	    "stge rx interrupt nframe");
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
-	    "rxint_dmawait", CTLTYPE_INT|CTLFLAG_RW, &sc->sc_rxint_dmawait, 0,
-	    sysctl_hw_stge_rxint_dmawait, "I", "stge rx interrupt dmawait");
+	    "rxint_dmawait", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    &sc->sc_rxint_dmawait, 0, sysctl_hw_stge_rxint_dmawait, "I",
+	    "stge rx interrupt dmawait");
 
 	/* Pull in device tunables. */
 	sc->sc_rxint_nframe = STGE_RXINT_NFRAME_DEFAULT;
diff --git a/sys/dev/syscons/syscons.c b/sys/dev/syscons/syscons.c
index d822820e13a0..70565675fe29 100644
--- a/sys/dev/syscons/syscons.c
+++ b/sys/dev/syscons/syscons.c
@@ -146,8 +146,11 @@ static int sc_no_suspend_vtswitch = 0;
 #endif
 static int sc_susp_scr;
 
-static SYSCTL_NODE(_hw, OID_AUTO, syscons, CTLFLAG_RD, 0, "syscons");
-static SYSCTL_NODE(_hw_syscons, OID_AUTO, saver, CTLFLAG_RD, 0, "saver");
+static SYSCTL_NODE(_hw, OID_AUTO, syscons, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "syscons");
+static SYSCTL_NODE(_hw_syscons, OID_AUTO, saver,
+    CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "saver");
 SYSCTL_INT(_hw_syscons_saver, OID_AUTO, keybonly, CTLFLAG_RW,
     &sc_saver_keyb_only, 0, "screen saver interrupted by input only");
 SYSCTL_INT(
diff --git a/sys/dev/tsec/if_tsec.c b/sys/dev/tsec/if_tsec.c
index 321df50111e0..28610aeba553 100644
--- a/sys/dev/tsec/if_tsec.c
+++ b/sys/dev/tsec/if_tsec.c
@@ -1680,22 +1680,22 @@ tsec_add_sysctls(struct tsec_softc *sc)
 	ctx = device_get_sysctl_ctx(sc->dev);
 	children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));
 	tree = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "int_coal",
-	    CTLFLAG_RD, 0, "TSEC Interrupts coalescing");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "TSEC Interrupts coalescing");
 	children = SYSCTL_CHILDREN(tree);
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rx_time",
-	    CTLTYPE_UINT | CTLFLAG_RW, sc, TSEC_IC_RX, tsec_sysctl_ic_time,
-	    "I", "IC RX time threshold (0-65535)");
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, TSEC_IC_RX,
+	    tsec_sysctl_ic_time, "I", "IC RX time threshold (0-65535)");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rx_count",
-	    CTLTYPE_UINT | CTLFLAG_RW, sc, TSEC_IC_RX, tsec_sysctl_ic_count,
-	    "I", "IC RX frame count threshold (0-255)");
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, TSEC_IC_RX,
+	    tsec_sysctl_ic_count, "I", "IC RX frame count threshold (0-255)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tx_time",
-	    CTLTYPE_UINT | CTLFLAG_RW, sc, TSEC_IC_TX, tsec_sysctl_ic_time,
-	    "I", "IC TX time threshold (0-65535)");
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, TSEC_IC_TX,
+	    tsec_sysctl_ic_time, "I", "IC TX time threshold (0-65535)");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tx_count",
-	    CTLTYPE_UINT | CTLFLAG_RW, sc, TSEC_IC_TX, tsec_sysctl_ic_count,
-	    "I", "IC TX frame count threshold (0-255)");
+	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, TSEC_IC_TX,
+	    tsec_sysctl_ic_count, "I", "IC TX frame count threshold (0-255)");
 }
 
 /*
diff --git a/sys/dev/twa/tw_osl_freebsd.c b/sys/dev/twa/tw_osl_freebsd.c
index 0b3e7933a90a..3e70962ebd0b 100644
--- a/sys/dev/twa/tw_osl_freebsd.c
+++ b/sys/dev/twa/tw_osl_freebsd.c
@@ -309,8 +309,8 @@ twa_attach(device_t dev)
 
 	sysctl_ctx_init(&sc->sysctl_ctxt);
 	sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctxt,
-		SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
-		device_get_nameunit(dev), CTLFLAG_RD, 0, "");
+	    SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO, device_get_nameunit(dev),
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
 	if (sc->sysctl_tree == NULL) {
 		tw_osli_printf(sc, "error = %d",
 			TW_CL_SEVERITY_ERROR_STRING,
diff --git a/sys/dev/twe/twe_freebsd.c b/sys/dev/twe/twe_freebsd.c
index 99c944ee077c..4886262012a8 100644
--- a/sys/dev/twe/twe_freebsd.c
+++ b/sys/dev/twe/twe_freebsd.c
@@ -202,7 +202,7 @@ twe_attach(device_t dev)
      */
     sysctl_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
 	SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
-	device_get_nameunit(dev), CTLFLAG_RD, 0, "");
+	device_get_nameunit(dev), CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
     if (sysctl_tree == NULL) {
 	twe_printf(sc, "cannot add sysctl tree node\n");
 	return (ENXIO);
diff --git a/sys/dev/tws/tws.c b/sys/dev/tws/tws.c
index 6cb814533ac6..fc581d251e60 100644
--- a/sys/dev/tws/tws.c
+++ b/sys/dev/tws/tws.c
@@ -216,9 +216,8 @@ tws_attach(device_t dev)
     /* sysctl context setup */
     sysctl_ctx_init(&sc->tws_clist);
     sc->tws_oidp = SYSCTL_ADD_NODE(&sc->tws_clist,
-                                   SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
-                                   device_get_nameunit(dev), 
-                                   CTLFLAG_RD, 0, "");
+        SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
+	device_get_nameunit(dev), CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
     if ( sc->tws_oidp == NULL ) {
         tws_log(sc, SYSCTL_TREE_NODE_ADD);
         goto attach_fail_1;
diff --git a/sys/dev/uart/uart_core.c b/sys/dev/uart/uart_core.c
index 3045d095cd5c..d664a823f701 100644
--- a/sys/dev/uart/uart_core.c
+++ b/sys/dev/uart/uart_core.c
@@ -209,8 +209,8 @@ uart_pps_init(struct uart_softc *sc)
 #endif
 	TUNABLE_INT_FETCH("hw.uart.pps_mode", &sc->sc_pps_mode);
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "pps_mode",
-	    CTLTYPE_INT | CTLFLAG_RWTUN, sc, 0, uart_pps_mode_sysctl, "I",
-	    "pulse mode: 0/1/2=disabled/CTS/DCD; "
+	    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, sc, 0, 
+	    uart_pps_mode_sysctl, "I", "pulse mode: 0/1/2=disabled/CTS/DCD; "
 	    "add 0x10 to invert, 0x20 for narrow pulse");
 
 	if (!uart_pps_mode_valid(sc->sc_pps_mode)) {
diff --git a/sys/dev/ubsec/ubsec.c b/sys/dev/ubsec/ubsec.c
index ad89986d1a1e..19f46458ac3b 100644
--- a/sys/dev/ubsec/ubsec.c
+++ b/sys/dev/ubsec/ubsec.c
@@ -173,7 +173,7 @@ static	int ubsec_ksigbits(struct crparam *);
 static	void ubsec_kshift_r(u_int, u_int8_t *, u_int, u_int8_t *, u_int);
 static	void ubsec_kshift_l(u_int, u_int8_t *, u_int, u_int8_t *, u_int);
 
-static SYSCTL_NODE(_hw, OID_AUTO, ubsec, CTLFLAG_RD, 0,
+static SYSCTL_NODE(_hw, OID_AUTO, ubsec, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "Broadcom driver parameters");
 
 #ifdef UBSEC_DEBUG
diff --git a/sys/dev/vge/if_vge.c b/sys/dev/vge/if_vge.c
index 962dc73b3039..14d09e187b2e 100644
--- a/sys/dev/vge/if_vge.c
+++ b/sys/dev/vge/if_vge.c
@@ -2532,13 +2532,13 @@ vge_sysctl_node(struct vge_softc *sc)
 	resource_int_value(device_get_name(sc->vge_dev),
 	    device_get_unit(sc->vge_dev), "tx_coal_pkt", &sc->vge_tx_coal_pkt);
 
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "VGE statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "VGE statistics");
 	parent = SYSCTL_CHILDREN(tree);
 
 	/* Rx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "RX MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	VGE_SYSCTL_STAT_ADD32(ctx, child, "frames",
 	    &stats->rx_frames, "frames");
@@ -2582,8 +2582,8 @@ vge_sysctl_node(struct vge_softc *sc)
 	    &stats->rx_lenerrs, "Frames with length mismatched");
 
 	/* Tx statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "TX MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	VGE_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
 	    &stats->tx_good_frames, "Good frames");
diff --git a/sys/dev/virtio/block/virtio_blk.c b/sys/dev/virtio/block/virtio_blk.c
index 94ad4196155f..b7c538254ce1 100644
--- a/sys/dev/virtio/block/virtio_blk.c
+++ b/sys/dev/virtio/block/virtio_blk.c
@@ -1392,8 +1392,9 @@ vtblk_setup_sysctl(struct vtblk_softc *sc)
 	child = SYSCTL_CHILDREN(tree);
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "writecache_mode",
-	    CTLTYPE_INT | CTLFLAG_RW, sc, 0, vtblk_write_cache_sysctl,
-	    "I", "Write cache mode (writethrough (0) or writeback (1))");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
+	    vtblk_write_cache_sysctl, "I",
+	    "Write cache mode (writethrough (0) or writeback (1))");
 }
 
 static int
diff --git a/sys/dev/virtio/network/if_vtnet.c b/sys/dev/virtio/network/if_vtnet.c
index b388e43d92a6..4839e49b0f25 100644
--- a/sys/dev/virtio/network/if_vtnet.c
+++ b/sys/dev/virtio/network/if_vtnet.c
@@ -234,7 +234,8 @@ static int	vtnet_tunable_int(struct vtnet_softc *, const char *, int);
 DEBUGNET_DEFINE(vtnet);
 
 /* Tunables. */
-static SYSCTL_NODE(_hw, OID_AUTO, vtnet, CTLFLAG_RD, 0, "VNET driver parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, vtnet, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "VNET driver parameters");
 static int vtnet_csum_disable = 0;
 TUNABLE_INT("hw.vtnet.csum_disable", &vtnet_csum_disable);
 SYSCTL_INT(_hw_vtnet, OID_AUTO, csum_disable, CTLFLAG_RDTUN,
@@ -3751,7 +3752,7 @@ vtnet_setup_rxq_sysctl(struct sysctl_ctx_list *ctx,
 
 	snprintf(namebuf, sizeof(namebuf), "rxq%d", rxq->vtnrx_id);
 	node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
-	    CTLFLAG_RD, NULL, "Receive Queue");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Receive Queue");
 	list = SYSCTL_CHILDREN(node);
 
 	stats = &rxq->vtnrx_stats;
@@ -3784,7 +3785,7 @@ vtnet_setup_txq_sysctl(struct sysctl_ctx_list *ctx,
 
 	snprintf(namebuf, sizeof(namebuf), "txq%d", txq->vtntx_id);
 	node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
-	    CTLFLAG_RD, NULL, "Transmit Queue");
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Transmit Queue");
 	list = SYSCTL_CHILDREN(node);
 
 	stats = &txq->vtntx_stats;
diff --git a/sys/dev/vmware/pvscsi/pvscsi.c b/sys/dev/vmware/pvscsi/pvscsi.c
index cb77016bc563..1bf7ce459873 100644
--- a/sys/dev/vmware/pvscsi/pvscsi.c
+++ b/sys/dev/vmware/pvscsi/pvscsi.c
@@ -130,7 +130,7 @@ static int pvscsi_get_tunable(struct pvscsi_softc *sc, char *name, int value);
 
 #ifdef PVSCSI_DEBUG_LOGGING
 static int pvscsi_log_level = 0;
-static SYSCTL_NODE(_hw, OID_AUTO, pvscsi, CTLFLAG_RD, 0,
+static SYSCTL_NODE(_hw, OID_AUTO, pvscsi, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "PVSCSI driver parameters");
 SYSCTL_INT(_hw_pvscsi, OID_AUTO, log_level, CTLFLAG_RWTUN, &pvscsi_log_level,
     0, "PVSCSI debug log level");
diff --git a/sys/dev/vmware/vmxnet3/if_vmx.c b/sys/dev/vmware/vmxnet3/if_vmx.c
index d0b0436ea25c..ceb679075686 100644
--- a/sys/dev/vmware/vmxnet3/if_vmx.c
+++ b/sys/dev/vmware/vmxnet3/if_vmx.c
@@ -2168,16 +2168,16 @@ vmxnet3_setup_txq_sysctl(struct vmxnet3_txqueue *txq,
 	txstats = &txq->vxtxq_ts->stats;
 
 	snprintf(namebuf, sizeof(namebuf), "txq%d", txq->vxtxq_id);
-	node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, CTLFLAG_RD,
-	    NULL, "Transmit Queue");
+	node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Transmit Queue");
 	txq->vxtxq_sysctl = list = SYSCTL_CHILDREN(node);
 
 	/*
 	 * Add statistics reported by the host. These are updated by the
 	 * iflib txq timer on txq 0.
 	 */
-	txsnode = SYSCTL_ADD_NODE(ctx, list, OID_AUTO, "hstats", CTLFLAG_RD,
-	    NULL, "Host Statistics");
+	txsnode = SYSCTL_ADD_NODE(ctx, list, OID_AUTO, "hstats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Host Statistics");
 	txslist = SYSCTL_CHILDREN(txsnode);
 	SYSCTL_ADD_UQUAD(ctx, txslist, OID_AUTO, "tso_packets", CTLFLAG_RD,
 	    &txstats->TSO_packets, "TSO packets");
@@ -2209,16 +2209,16 @@ vmxnet3_setup_rxq_sysctl(struct vmxnet3_rxqueue *rxq,
 	rxstats = &rxq->vxrxq_rs->stats;
 
 	snprintf(namebuf, sizeof(namebuf), "rxq%d", rxq->vxrxq_id);
-	node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, CTLFLAG_RD,
-	    NULL, "Receive Queue");
+	node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Receive Queue");
 	rxq->vxrxq_sysctl = list = SYSCTL_CHILDREN(node);
 
 	/*
 	 * Add statistics reported by the host. These are updated by the
 	 * iflib txq timer on txq 0.
 	 */
-	rxsnode = SYSCTL_ADD_NODE(ctx, list, OID_AUTO, "hstats", CTLFLAG_RD,
-	    NULL, "Host Statistics");
+	rxsnode = SYSCTL_ADD_NODE(ctx, list, OID_AUTO, "hstats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Host Statistics");
 	rxslist = SYSCTL_CHILDREN(rxsnode);
 	SYSCTL_ADD_UQUAD(ctx, rxslist, OID_AUTO, "lro_packets", CTLFLAG_RD,
 	    &rxstats->LRO_packets, "LRO packets");
@@ -2257,7 +2257,7 @@ vmxnet3_setup_debug_sysctl(struct vmxnet3_softc *sc,
 		struct vmxnet3_txqueue *txq = &sc->vmx_txq[i];
 
 		node = SYSCTL_ADD_NODE(ctx, txq->vxtxq_sysctl, OID_AUTO,
-		    "debug", CTLFLAG_RD, NULL, "");
+		    "debug", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
 		list = SYSCTL_CHILDREN(node);
 
 		SYSCTL_ADD_UINT(ctx, list, OID_AUTO, "cmd_next", CTLFLAG_RD,
@@ -2278,7 +2278,7 @@ vmxnet3_setup_debug_sysctl(struct vmxnet3_softc *sc,
 		struct vmxnet3_rxqueue *rxq = &sc->vmx_rxq[i];
 
 		node = SYSCTL_ADD_NODE(ctx, rxq->vxrxq_sysctl, OID_AUTO,
-		    "debug", CTLFLAG_RD, NULL, "");
+		    "debug", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
 		list = SYSCTL_CHILDREN(node);
 
 		SYSCTL_ADD_UINT(ctx, list, OID_AUTO, "cmd0_ndesc", CTLFLAG_RD,
diff --git a/sys/dev/vr/if_vr.c b/sys/dev/vr/if_vr.c
index cf942c5cd197..8720f9438bb1 100644
--- a/sys/dev/vr/if_vr.c
+++ b/sys/dev/vr/if_vr.c
@@ -626,8 +626,8 @@ vr_attach(device_t dev)
 	callout_init_mtx(&sc->vr_stat_callout, &sc->vr_mtx, 0);
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-	    OID_AUTO, "stats", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
-	    vr_sysctl_stats, "I", "Statistics");
+	    OID_AUTO, "stats", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    sc, 0, vr_sysctl_stats, "I", "Statistics");
 
 	error = 0;
 
diff --git a/sys/dev/vt/vt_core.c b/sys/dev/vt/vt_core.c
index 76ae1e2be281..e11026da13f1 100644
--- a/sys/dev/vt/vt_core.c
+++ b/sys/dev/vt/vt_core.c
@@ -120,7 +120,8 @@ const struct terminal_class vt_termclass = {
 #define	VT_UNIT(vw)	((vw)->vw_device->vd_unit * VT_MAXWINDOWS + \
 			(vw)->vw_number)
 
-static SYSCTL_NODE(_kern, OID_AUTO, vt, CTLFLAG_RD, 0, "vt(9) parameters");
+static SYSCTL_NODE(_kern, OID_AUTO, vt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "vt(9) parameters");
 static VT_SYSCTL_INT(enable_altgr, 1, "Enable AltGr key (Do not assume R.Alt as Alt)");
 static VT_SYSCTL_INT(enable_bell, 1, "Enable bell");
 static VT_SYSCTL_INT(debug, 0, "vt(9) debug level");
diff --git a/sys/dev/vte/if_vte.c b/sys/dev/vte/if_vte.c
index 0d238eda06dd..b6bf909037e1 100644
--- a/sys/dev/vte/if_vte.c
+++ b/sys/dev/vte/if_vte.c
@@ -564,11 +564,13 @@ vte_sysctl_node(struct vte_softc *sc)
 	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->vte_dev));
 
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_rx_mod",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->vte_int_rx_mod, 0,
-	    sysctl_hw_vte_int_mod, "I", "vte RX interrupt moderation");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    &sc->vte_int_rx_mod, 0, sysctl_hw_vte_int_mod, "I",
+	    "vte RX interrupt moderation");
 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_tx_mod",
-	    CTLTYPE_INT | CTLFLAG_RW, &sc->vte_int_tx_mod, 0,
-	    sysctl_hw_vte_int_mod, "I", "vte TX interrupt moderation");
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
+	    &sc->vte_int_tx_mod, 0, sysctl_hw_vte_int_mod, "I",
+	    "vte TX interrupt moderation");
 	/* Pull in device tunables. */
 	sc->vte_int_rx_mod = VTE_IM_RX_BUNDLE_DEFAULT;
 	error = resource_int_value(device_get_name(sc->vte_dev),
@@ -596,13 +598,13 @@ vte_sysctl_node(struct vte_softc *sc)
 		}
 	}
 
-	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
-	    NULL, "VTE statistics");
+	tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "VTE statistics");
 	parent = SYSCTL_CHILDREN(tree);
 
 	/* RX statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
-	    NULL, "RX MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	VTE_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
 	    &stats->rx_frames, "Good frames");
@@ -625,8 +627,8 @@ vte_sysctl_node(struct vte_softc *sc)
 	    &stats->rx_pause_frames, "Pause control frames");
 
 	/* TX statistics. */
-	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
-	    NULL, "TX MAC statistics");
+	tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx",
+	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX MAC statistics");
 	child = SYSCTL_CHILDREN(tree);
 	VTE_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
 	    &stats->tx_frames, "Good frames");
diff --git a/sys/dev/watchdog/watchdog.c b/sys/dev/watchdog/watchdog.c
index c5756d6ecc77..4522fc03d183 100644
--- a/sys/dev/watchdog/watchdog.c
+++ b/sys/dev/watchdog/watchdog.c
@@ -70,7 +70,8 @@ static volatile u_int wd_last_u;    /* last timeout value set by kern_do_pat */
 static u_int wd_last_u_sysctl;    /* last timeout value set by kern_do_pat */
 static u_int wd_last_u_sysctl_secs;    /* wd_last_u in seconds */
 
-SYSCTL_NODE(_hw, OID_AUTO, watchdog, CTLFLAG_RD, 0, "Main watchdog device");
+SYSCTL_NODE(_hw, OID_AUTO, watchdog, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Main watchdog device");
 SYSCTL_UINT(_hw_watchdog, OID_AUTO, wd_last_u, CTLFLAG_RD,
     &wd_last_u_sysctl, 0, "Watchdog last update time");
 SYSCTL_UINT(_hw_watchdog, OID_AUTO, wd_last_u_secs, CTLFLAG_RD,
diff --git a/sys/dev/wbwd/wbwd.c b/sys/dev/wbwd/wbwd.c
index d8324e462917..057b682b6eb7 100644
--- a/sys/dev/wbwd/wbwd.c
+++ b/sys/dev/wbwd/wbwd.c
@@ -628,14 +628,15 @@ wb_attach(device_t dev)
 	    "debug_verbose", CTLFLAG_RW, &sc->debug_verbose, 0,
             "Enables extra debugging information");
         SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "debug",
-	    CTLTYPE_STRING|CTLFLAG_RD, sc, 0, sysctl_wb_debug, "A",
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
+	    sysctl_wb_debug, "A",
             "Selected register information from last change by driver");
         SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "debug_current",
-	    CTLTYPE_STRING|CTLFLAG_RD|CTLFLAG_SKIP, sc, 0,
-	     sysctl_wb_debug_current, "A",
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_SKIP | CTLFLAG_NEEDGIANT,
+	    sc, 0, sysctl_wb_debug_current, "A",
 	     "Selected register information (may interfere)");
 	SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "force_timeout",
-	    CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_SKIP, sc, 0,
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SKIP | CTLFLAG_NEEDGIANT, sc, 0,
 	    sysctl_wb_force_test_nmi, "I", "Enable to force watchdog to fire.");
 
 	/* Register watchdog. */
diff --git a/sys/dev/wi/if_wi.c b/sys/dev/wi/if_wi.c
index 2b73cb08ac4b..0731508ddd3a 100644
--- a/sys/dev/wi/if_wi.c
+++ b/sys/dev/wi/if_wi.c
@@ -171,8 +171,8 @@ wi_write_val(struct wi_softc *sc, int rid, u_int16_t val)
 	return wi_write_rid(sc, rid, &val, sizeof(val));
 }
 
-static SYSCTL_NODE(_hw, OID_AUTO, wi, CTLFLAG_RD, 0,
-	    "Wireless driver parameters");
+static SYSCTL_NODE(_hw, OID_AUTO, wi, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
+    "Wireless driver parameters");
 
 static	struct timeval lasttxerror;	/* time of last tx error msg */
 static	int curtxeps;			/* current tx error msgs/sec */