Fix multiple incorrect SYSCTL arguments in the kernel:

- Wrong integer type was specified.

- Wrong or missing "access" specifier. The "access" specifier
sometimes included the SYSCTL type, which it should not, except for
procedural SYSCTL nodes.

- Logical OR where binary OR was expected.

- Properly assert the "access" argument passed to all SYSCTL macros,
using the CTASSERT macro. This applies to both static- and dynamically
created SYSCTLs.

- Properly assert the the data type for both static and dynamic
SYSCTLs. In the case of static SYSCTLs we only assert that the data
pointed to by the SYSCTL data pointer has the correct size, hence
there is no easy way to assert types in the C language outside a
C-function.

- Rewrote some code which doesn't pass a constant "access" specifier
when creating dynamic SYSCTL nodes, which is now a requirement.

- Updated "EXAMPLES" section in SYSCTL manual page.

MFC after:	3 days
Sponsored by:	Mellanox Technologies

28 files changed, 271 insertions, 261 deletions

diff --git a/sys/dev/acpi_support/acpi_asus.c b/sys/dev/acpi_support/acpi_asus.c
index d1ae81015982..86cd8b7bf69b 100644
--- a/sys/dev/acpi_support/acpi_asus.c
+++ b/sys/dev/acpi_support/acpi_asus.c
@@ -465,43 +465,39 @@ static struct {
 	char	*name;
 	char	*description;
 	int	method;
-	int	flags;
+	int	flag_anybody;
 } acpi_asus_sysctls[] = {
 	{
 		.name		= "lcd_backlight",
 		.method		= ACPI_ASUS_METHOD_LCD,
 		.description	= "state of the lcd backlight",
-		.flags 		= CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY
+		.flag_anybody	= 1
 	},
 	{
 		.name		= "lcd_brightness",
 		.method		= ACPI_ASUS_METHOD_BRN,
 		.description	= "brightness of the lcd panel",
-		.flags 		= CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY
+		.flag_anybody	= 1
 	},
 	{
 		.name		= "video_output",
 		.method		= ACPI_ASUS_METHOD_DISP,
 		.description	= "display output state",
-		.flags 		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "camera",
 		.method		= ACPI_ASUS_METHOD_CAMERA,
 		.description	= "internal camera state",  
-		.flags 		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "cardreader",
 		.method		= ACPI_ASUS_METHOD_CARDRD,
 		.description	= "internal card reader state",
-		.flags 		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wlan",
 		.method		= ACPI_ASUS_METHOD_WLAN,
 		.description	= "wireless lan state",
-		.flags		= CTLTYPE_INT | CTLFLAG_RW
 	},
 
 	{ .name = NULL }
@@ -741,12 +737,21 @@ acpi_asus_attach(device_t dev)
 		if (!acpi_asus_sysctl_init(sc, acpi_asus_sysctls[i].method))
 			continue;
 
-		SYSCTL_ADD_PROC(&sc->sysctl_ctx,
-		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
-		    acpi_asus_sysctls[i].name,
-		    acpi_asus_sysctls[i].flags,
-		    sc, i, acpi_asus_sysctl, "I",
-		    acpi_asus_sysctls[i].description);
+		if (acpi_asus_sysctls[i].flag_anybody != 0) {
+			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",
+			    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,
+			    sc, i, acpi_asus_sysctl, "I",
+			    acpi_asus_sysctls[i].description);
+		}
 	}
 
 	/* Attach leds */
diff --git a/sys/dev/acpi_support/acpi_asus_wmi.c b/sys/dev/acpi_support/acpi_asus_wmi.c
index 54a2893cd0a0..d77cc7640488 100644
--- a/sys/dev/acpi_support/acpi_asus_wmi.c
+++ b/sys/dev/acpi_support/acpi_asus_wmi.c
@@ -119,163 +119,139 @@ static struct {
 	char	*name;
 	int	dev_id;
 	char	*description;
-	int	access;
+	int	flag_rdonly;
 } acpi_asus_wmi_sysctls[] = {
 	{
 		.name		= "hw_switch",
 		.dev_id		= ASUS_WMI_DEVID_HW_SWITCH,
 		.description	= "hw_switch",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wireless_led",
 		.dev_id		= ASUS_WMI_DEVID_WIRELESS_LED,
 		.description	= "Wireless LED control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "cwap",
 		.dev_id		= ASUS_WMI_DEVID_CWAP,
 		.description	= "Alt+F2 function",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wlan",
 		.dev_id		= ASUS_WMI_DEVID_WLAN,
 		.description	= "WLAN power control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "bluetooth",
 		.dev_id		= ASUS_WMI_DEVID_BLUETOOTH,
 		.description	= "Bluetooth power control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "gps",
 		.dev_id		= ASUS_WMI_DEVID_GPS,
 		.description	= "GPS power control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wimax",
 		.dev_id		= ASUS_WMI_DEVID_WIMAX,
 		.description	= "WiMAX power control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wwan3g",
 		.dev_id		= ASUS_WMI_DEVID_WWAN3G,
 		.description	= "WWAN-3G power control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "uwb",
 		.dev_id		= ASUS_WMI_DEVID_UWB,
 		.description	= "UWB power control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "led1",
 		.dev_id		= ASUS_WMI_DEVID_LED1,
 		.description	= "LED1 control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "led2",
 		.dev_id		= ASUS_WMI_DEVID_LED2,
 		.description	= "LED2 control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "led3",
 		.dev_id		= ASUS_WMI_DEVID_LED3,
 		.description	= "LED3 control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "led4",
 		.dev_id		= ASUS_WMI_DEVID_LED4,
 		.description	= "LED4 control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "led5",
 		.dev_id		= ASUS_WMI_DEVID_LED5,
 		.description	= "LED5 control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "led6",
 		.dev_id		= ASUS_WMI_DEVID_LED6,
 		.description	= "LED6 control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "backlight",
 		.dev_id		= ASUS_WMI_DEVID_BACKLIGHT,
 		.description	= "LCD backlight on/off control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "brightness",
 		.dev_id		= ASUS_WMI_DEVID_BRIGHTNESS,
 		.description	= "LCD backlight brightness control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "kbd_backlight",
 		.dev_id		= ASUS_WMI_DEVID_KBD_BACKLIGHT,
 		.description	= "Keyboard backlight brightness control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "light_sensor",
 		.dev_id		= ASUS_WMI_DEVID_LIGHT_SENSOR,
 		.description	= "Ambient light sensor",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "camera",
 		.dev_id		= ASUS_WMI_DEVID_CAMERA,
 		.description	= "Camera power control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "cardreader",
 		.dev_id		= ASUS_WMI_DEVID_CARDREADER,
 		.description	= "Cardreader power control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "touchpad",
 		.dev_id		= ASUS_WMI_DEVID_TOUCHPAD,
 		.description	= "Touchpad control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "touchpad_led",
 		.dev_id		= ASUS_WMI_DEVID_TOUCHPAD_LED,
 		.description	= "Touchpad LED control",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "themperature",
 		.dev_id		= ASUS_WMI_DEVID_THERMAL_CTRL,
 		.description	= "Temperature (C)",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "fan_speed",
 		.dev_id		= ASUS_WMI_DEVID_FAN_CTRL,
 		.description	= "Fan speed (0-3)",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "processor_state",
 		.dev_id		= ASUS_WMI_DEVID_PROCESSOR_STATE,
-		.description	= "Processor state",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
+		.flag_rdonly	= 1
 	},
 	{ NULL, 0, NULL, 0 }
 };
@@ -449,12 +425,21 @@ next:
 			break;
 		}
 
-		SYSCTL_ADD_PROC(sc->sysctl_ctx,
-		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
-		    acpi_asus_wmi_sysctls[i].name,
-		    acpi_asus_wmi_sysctls[i].access,
-		    sc, i, acpi_asus_wmi_sysctl, "I",
-		    acpi_asus_wmi_sysctls[i].description);
+		if (acpi_asus_wmi_sysctls[i].flag_rdonly != 0) {
+			SYSCTL_ADD_PROC(sc->sysctl_ctx,
+			    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
+			    acpi_asus_wmi_sysctls[i].name,
+			    CTLTYPE_INT | CTLFLAG_RD,
+			    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,
+			    sc, i, acpi_asus_wmi_sysctl, "I",
+			    acpi_asus_wmi_sysctls[i].description);
+		}
 	}
 	ACPI_SERIAL_END(asus_wmi);
 
diff --git a/sys/dev/acpi_support/acpi_hp.c b/sys/dev/acpi_support/acpi_hp.c
index deb01a42b273..282803814dc5 100644
--- a/sys/dev/acpi_support/acpi_hp.c
+++ b/sys/dev/acpi_support/acpi_hp.c
@@ -152,135 +152,123 @@ static struct {
 	char	*name;
 	int	method;
 	char	*description;
-	int	access;
+	int	flag_rdonly;
 } acpi_hp_sysctls[] = {
 	{
 		.name		= "wlan_enabled",
 		.method		= ACPI_HP_METHOD_WLAN_ENABLED,
 		.description	= "Enable/Disable WLAN (WiFi)",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wlan_radio",
 		.method		= ACPI_HP_METHOD_WLAN_RADIO,
 		.description	= "WLAN radio status",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "wlan_on_air",
 		.method		= ACPI_HP_METHOD_WLAN_ON_AIR,
 		.description	= "WLAN radio ready to use (enabled and radio)",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "wlan_enable_if_radio_on",
 		.method		= ACPI_HP_METHOD_WLAN_ENABLE_IF_RADIO_ON,
 		.description	= "Enable WLAN if radio is turned on",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wlan_disable_if_radio_off",
 		.method		= ACPI_HP_METHOD_WLAN_DISABLE_IF_RADIO_OFF,
 		.description	= "Disable WLAN if radio is turned off",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "bt_enabled",
 		.method		= ACPI_HP_METHOD_BLUETOOTH_ENABLED,
 		.description	= "Enable/Disable Bluetooth",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "bt_radio",
 		.method		= ACPI_HP_METHOD_BLUETOOTH_RADIO,
 		.description	= "Bluetooth radio status",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "bt_on_air",
 		.method		= ACPI_HP_METHOD_BLUETOOTH_ON_AIR,
 		.description	= "Bluetooth radio ready to use"
 				    " (enabled and radio)",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "bt_enable_if_radio_on",
 		.method		= ACPI_HP_METHOD_BLUETOOTH_ENABLE_IF_RADIO_ON,
 		.description	= "Enable bluetooth if radio is turned on",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "bt_disable_if_radio_off",
 		.method		= ACPI_HP_METHOD_BLUETOOTH_DISABLE_IF_RADIO_OFF,
 		.description	= "Disable bluetooth if radio is turned off",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wwan_enabled",
 		.method		= ACPI_HP_METHOD_WWAN_ENABLED,
 		.description	= "Enable/Disable WWAN (UMTS)",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wwan_radio",
 		.method		= ACPI_HP_METHOD_WWAN_RADIO,
 		.description	= "WWAN radio status",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "wwan_on_air",
 		.method		= ACPI_HP_METHOD_WWAN_ON_AIR,
 		.description	= "WWAN radio ready to use (enabled and radio)",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "wwan_enable_if_radio_on",
 		.method		= ACPI_HP_METHOD_WWAN_ENABLE_IF_RADIO_ON,
 		.description	= "Enable WWAN if radio is turned on",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wwan_disable_if_radio_off",
 		.method		= ACPI_HP_METHOD_WWAN_DISABLE_IF_RADIO_OFF,
 		.description	= "Disable WWAN if radio is turned off",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "als_enabled",
 		.method		= ACPI_HP_METHOD_ALS,
 		.description	= "Enable/Disable ALS (Ambient light sensor)",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "display",
 		.method		= ACPI_HP_METHOD_DISPLAY,
 		.description	= "Display status",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "hdd_temperature",
 		.method		= ACPI_HP_METHOD_HDDTEMP,
 		.description	= "HDD temperature",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "is_docked",
 		.method		= ACPI_HP_METHOD_DOCK,
 		.description	= "Docking station status",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "cmi_detail",
 		.method		= ACPI_HP_METHOD_CMI_DETAIL,
 		.description	= "Details shown in CMI output "
 				    "(cat /dev/hpcmi)",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "verbose",
 		.method		= ACPI_HP_METHOD_VERBOSE,
 		.description	= "Verbosity level",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 
 	{ NULL, 0, NULL, 0 }
@@ -560,11 +548,19 @@ acpi_hp_attach(device_t dev)
 			sc->was_wwan_on_air = arg;
 		}
 
-		SYSCTL_ADD_PROC(sc->sysctl_ctx,
-		SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
-			acpi_hp_sysctls[i].name, acpi_hp_sysctls[i].access,
-			sc, i, acpi_hp_sysctl, "I",
-			acpi_hp_sysctls[i].description);
+		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,
+			    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,
+			    sc, i, acpi_hp_sysctl, "I",
+			    acpi_hp_sysctls[i].description);
+		}
 	}
 	ACPI_SERIAL_END(hp);
 
diff --git a/sys/dev/acpi_support/acpi_ibm.c b/sys/dev/acpi_support/acpi_ibm.c
index 416011297e09..3f53c59f545a 100644
--- a/sys/dev/acpi_support/acpi_ibm.c
+++ b/sys/dev/acpi_support/acpi_ibm.c
@@ -192,79 +192,70 @@ static struct {
 	char	*name;
 	int	method;
 	char	*description;
-	int	access;
+	int	flag_rdonly;
 } acpi_ibm_sysctls[] = {
 	{
 		.name		= "events",
 		.method		= ACPI_IBM_METHOD_EVENTS,
 		.description	= "ACPI events enable",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "eventmask",
 		.method		= ACPI_IBM_METHOD_EVENTMASK,
 		.description	= "ACPI eventmask",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "hotkey",
 		.method		= ACPI_IBM_METHOD_HOTKEY,
 		.description	= "Key Status",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "lcd_brightness",
 		.method		= ACPI_IBM_METHOD_BRIGHTNESS,
 		.description	= "LCD Brightness",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "volume",
 		.method		= ACPI_IBM_METHOD_VOLUME,
 		.description	= "Volume",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "mute",
 		.method		= ACPI_IBM_METHOD_MUTE,
 		.description	= "Mute",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "thinklight",
 		.method		= ACPI_IBM_METHOD_THINKLIGHT,
 		.description	= "Thinklight enable",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "bluetooth",
 		.method		= ACPI_IBM_METHOD_BLUETOOTH,
 		.description	= "Bluetooth enable",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "wlan",
 		.method		= ACPI_IBM_METHOD_WLAN,
 		.description	= "WLAN enable",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "fan_speed",
 		.method		= ACPI_IBM_METHOD_FANSPEED,
 		.description	= "Fan speed",
-		.access		= CTLTYPE_INT | CTLFLAG_RD
+		.flag_rdonly	= 1
 	},
 	{
 		.name		= "fan_level",
 		.method		= ACPI_IBM_METHOD_FANLEVEL,
 		.description	= "Fan level",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 	{
 		.name		= "fan",
 		.method		= ACPI_IBM_METHOD_FANSTATUS,
 		.description	= "Fan enable",
-		.access		= CTLTYPE_INT | CTLFLAG_RW
 	},
 
 	{ NULL, 0, NULL, 0 }
@@ -415,11 +406,19 @@ acpi_ibm_attach(device_t dev)
 		if (!acpi_ibm_sysctl_init(sc, acpi_ibm_sysctls[i].method))
 			continue;
 
-		SYSCTL_ADD_PROC(sc->sysctl_ctx,
-		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
-		    acpi_ibm_sysctls[i].name, acpi_ibm_sysctls[i].access,
-		    sc, i, acpi_ibm_sysctl, "I",
-		    acpi_ibm_sysctls[i].description);
+		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,
+			    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,
+			    sc, i, acpi_ibm_sysctl, "I",
+			    acpi_ibm_sysctls[i].description);
+		}
 	}
 
 	/* Hook up thermal node */
@@ -483,15 +482,10 @@ acpi_ibm_resume(device_t dev)
 	for (int i = 0; acpi_ibm_sysctls[i].name != NULL; i++) {
 		int val;
 
-		if ((acpi_ibm_sysctls[i].access & CTLFLAG_RD) == 0) {
-			continue;
-		}
-
 		val = acpi_ibm_sysctl_get(sc, i);
 
-		if ((acpi_ibm_sysctls[i].access & CTLFLAG_WR) == 0) {
+		if (acpi_ibm_sysctls[i].flag_rdonly != 0)
 			continue;
-		}
 
 		acpi_ibm_sysctl_set(sc, i, val);
 	}
diff --git a/sys/dev/acpi_support/acpi_rapidstart.c b/sys/dev/acpi_support/acpi_rapidstart.c
index 2da93ec17127..f28414cef371 100644
--- a/sys/dev/acpi_support/acpi_rapidstart.c
+++ b/sys/dev/acpi_support/acpi_rapidstart.c
@@ -84,12 +84,21 @@ acpi_rapidstart_attach(device_t dev)
 	sc->sysctl_ctx = device_get_sysctl_ctx(dev);
 	sc->sysctl_tree = device_get_sysctl_tree(dev);
 	for (i = 0 ; acpi_rapidstart_oids[i].nodename != NULL; i++){
-		SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-		    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-		    i, acpi_rapidstart_oids[i].nodename , CTLTYPE_INT |
-		    ((acpi_rapidstart_oids[i].setmethod)? CTLFLAG_RW: CTLFLAG_RD),
-		    dev, i, sysctl_acpi_rapidstart_gen_handler, "I",
-		    acpi_rapidstart_oids[i].comment);
+		if (acpi_rapidstart_oids[i].setmethod != NULL) {
+			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,
+			    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,
+			    dev, i, sysctl_acpi_rapidstart_gen_handler, "I",
+			    acpi_rapidstart_oids[i].comment);
+		}
 	}
 	return (0);
 }
diff --git a/sys/dev/acpi_support/acpi_sony.c b/sys/dev/acpi_support/acpi_sony.c
index 95e7b4f1ca28..fc5c6519e4b5 100644
--- a/sys/dev/acpi_support/acpi_sony.c
+++ b/sys/dev/acpi_support/acpi_sony.c
@@ -132,13 +132,22 @@ acpi_sony_attach(device_t dev)
 	sc = device_get_softc(dev);
 	acpi_GetInteger(acpi_get_handle(dev), ACPI_SONY_GET_PID, &sc->pid);
 	device_printf(dev, "PID %x\n", sc->pid);
-	for (i = 0 ; acpi_sony_oids[i].nodename != NULL; i++){
-		SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
-		    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-		    i, acpi_sony_oids[i].nodename , CTLTYPE_INT |
-		    ((acpi_sony_oids[i].setmethod)? CTLFLAG_RW: CTLFLAG_RD),
-		    dev, i, sysctl_acpi_sony_gen_handler, "I",
-		    acpi_sony_oids[i].comment);
+	for (i = 0 ; acpi_sony_oids[i].nodename != NULL; i++) {
+		if (acpi_sony_oids[i].setmethod != NULL) {
+			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,
+			    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,
+			    dev, i, sysctl_acpi_sony_gen_handler, "I",
+			    acpi_sony_oids[i].comment);
+		}
 	}
 	return (0);
 }
diff --git a/sys/dev/bxe/bxe.c b/sys/dev/bxe/bxe.c
index ac20d781f608..a27b3e7a56bd 100644
--- a/sys/dev/bxe/bxe.c
+++ b/sys/dev/bxe/bxe.c
@@ -16216,7 +16216,7 @@ bxe_add_sysctls(struct bxe_softc *sc)
                       "version");
 
     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "bc_version",
-                      CTLFLAG_RD, &sc->devinfo.bc_ver_str, 0,
+                      CTLFLAG_RD, sc->devinfo.bc_ver_str, 0,
                       "bootcode version");
 
     snprintf(sc->fw_ver_str, sizeof(sc->fw_ver_str), "%d.%d.%d.%d",
@@ -16225,7 +16225,7 @@ bxe_add_sysctls(struct bxe_softc *sc)
              BCM_5710_FW_REVISION_VERSION,
              BCM_5710_FW_ENGINEERING_VERSION);
     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "fw_version",
-                      CTLFLAG_RD, &sc->fw_ver_str, 0,
+                      CTLFLAG_RD, sc->fw_ver_str, 0,
                       "firmware version");
 
     snprintf(sc->mf_mode_str, sizeof(sc->mf_mode_str), "%s",
@@ -16235,7 +16235,7 @@ bxe_add_sysctls(struct bxe_softc *sc)
          (sc->devinfo.mf_info.mf_mode == MULTI_FUNCTION_AFEX) ? "MF-AFEX" :
                                                                 "Unknown"));
     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "mf_mode",
-                      CTLFLAG_RD, &sc->mf_mode_str, 0,
+                      CTLFLAG_RD, sc->mf_mode_str, 0,
                       "multifunction mode");
 
     SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "mf_vnics",
@@ -16243,7 +16243,7 @@ bxe_add_sysctls(struct bxe_softc *sc)
                     "multifunction vnics per port");
 
     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "mac_addr",
-                      CTLFLAG_RD, &sc->mac_addr_str, 0,
+                      CTLFLAG_RD, sc->mac_addr_str, 0,
                       "mac address");
 
     snprintf(sc->pci_link_str, sizeof(sc->pci_link_str), "%s x%d",
@@ -16253,12 +16253,12 @@ bxe_add_sysctls(struct bxe_softc *sc)
                                               "???GT/s"),
         sc->devinfo.pcie_link_width);
     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "pci_link",
-                      CTLFLAG_RD, &sc->pci_link_str, 0,
+                      CTLFLAG_RD, sc->pci_link_str, 0,
                       "pci link status");
 
     sc->debug = bxe_debug;
-    SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "debug",
-                    CTLFLAG_RW, &sc->debug, 0,
+    SYSCTL_ADD_ULONG(ctx, children, OID_AUTO, "debug",
+                    CTLFLAG_RW, &sc->debug,
                     "debug logging mode");
 
     sc->rx_budget = bxe_rx_budget;
diff --git a/sys/dev/cxgb/cxgb_sge.c b/sys/dev/cxgb/cxgb_sge.c
index 88ee7ccd4920..a7f39a510109 100644
--- a/sys/dev/cxgb/cxgb_sge.c
+++ b/sys/dev/cxgb/cxgb_sge.c
@@ -3365,7 +3365,7 @@ t3_add_attach_sysctls(adapter_t *sc)
 	/* random information */
 	SYSCTL_ADD_STRING(ctx, children, OID_AUTO, 
 	    "firmware_version",
-	    CTLFLAG_RD, &sc->fw_version,
+	    CTLFLAG_RD, sc->fw_version,
 	    0, "firmware version");
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
 	    "hw_revision",
@@ -3373,7 +3373,7 @@ t3_add_attach_sysctls(adapter_t *sc)
 	    0, "chip model");
 	SYSCTL_ADD_STRING(ctx, children, OID_AUTO, 
 	    "port_types",
-	    CTLFLAG_RD, &sc->port_types,
+	    CTLFLAG_RD, sc->port_types,
 	    0, "type of ports");
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
 	    "enable_debug",
@@ -3502,7 +3502,7 @@ t3_add_configured_sysctls(adapter_t *sc)
 			SYSCTL_ADD_UINT(ctx, rspqpoidlist, OID_AUTO, "starved",
 			    CTLFLAG_RD, &qs->rspq.starved,
 			    0, "#times starved");
-			SYSCTL_ADD_ULONG(ctx, rspqpoidlist, OID_AUTO, "phys_addr",
+			SYSCTL_ADD_UAUTO(ctx, rspqpoidlist, OID_AUTO, "phys_addr",
 			    CTLFLAG_RD, &qs->rspq.phys_addr,
 			    "physical_address_of the queue");
 			SYSCTL_ADD_UINT(ctx, rspqpoidlist, OID_AUTO, "dump_start",
@@ -3538,7 +3538,7 @@ t3_add_configured_sysctls(adapter_t *sc)
 			SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "in_use",
 			    CTLFLAG_RD, &txq->in_use,
 			    0, "#tunneled packet slots in use");
-			SYSCTL_ADD_ULONG(ctx, txqpoidlist, OID_AUTO, "frees",
+			SYSCTL_ADD_UQUAD(ctx, txqpoidlist, OID_AUTO, "frees",
 			    CTLFLAG_RD, &txq->txq_frees,
 			    "#tunneled packets freed");
 			SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "skipped",
@@ -3553,7 +3553,7 @@ t3_add_configured_sysctls(adapter_t *sc)
 			SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "stopped_flags",
 			    CTLFLAG_RD, &qs->txq_stopped,
 			    0, "tx queues stopped");
-			SYSCTL_ADD_ULONG(ctx, txqpoidlist, OID_AUTO, "phys_addr",
+			SYSCTL_ADD_UAUTO(ctx, txqpoidlist, OID_AUTO, "phys_addr",
 			    CTLFLAG_RD, &txq->phys_addr,
 			    "physical_address_of the queue");
 			SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "qgen",
diff --git a/sys/dev/cxgbe/t4_main.c b/sys/dev/cxgbe/t4_main.c
index 77c99b238fae..475845b27a98 100644
--- a/sys/dev/cxgbe/t4_main.c
+++ b/sys/dev/cxgbe/t4_main.c
@@ -4534,10 +4534,10 @@ t4_sysctls(struct adapter *sc)
 	    NULL, chip_rev(sc), "chip hardware revision");
 
 	SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "firmware_version",
-	    CTLFLAG_RD, &sc->fw_version, 0, "firmware version");
+	    CTLFLAG_RD, sc->fw_version, 0, "firmware version");
 
 	SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "cf",
-	    CTLFLAG_RD, &sc->cfg_file, 0, "configuration file");
+	    CTLFLAG_RD, sc->cfg_file, 0, "configuration file");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "cfcsum", CTLFLAG_RD, NULL,
 	    sc->cfcsum, "config file checksum");
diff --git a/sys/dev/e1000/if_em.c b/sys/dev/e1000/if_em.c
index 070bb5b2f3ea..252571b611c2 100644
--- a/sys/dev/e1000/if_em.c
+++ b/sys/dev/e1000/if_em.c
@@ -5644,7 +5644,7 @@ em_set_sysctl_value(struct adapter *adapter, const char *name,
 	*limit = value;
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
-	    OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description);
+	    OID_AUTO, name, CTLFLAG_RW, limit, value, description);
 }
 
 
diff --git a/sys/dev/e1000/if_igb.c b/sys/dev/e1000/if_igb.c
index 0e6d16138a64..4796a915f2e0 100644
--- a/sys/dev/e1000/if_igb.c
+++ b/sys/dev/e1000/if_igb.c
@@ -5823,8 +5823,8 @@ igb_add_hw_stats(struct adapter *adapter)
 	char namebuf[QUEUE_NAME_LEN];
 
 	/* Driver Statistics */
-	SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "link_irq", 
-			CTLFLAG_RD, &adapter->link_irq, 0,
+	SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "link_irq", 
+			CTLFLAG_RD, &adapter->link_irq,
 			"Link MSIX IRQ Handled");
 	SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "dropped", 
 			CTLFLAG_RD, &adapter->dropped_pkts,
@@ -5873,17 +5873,17 @@ igb_add_hw_stats(struct adapter *adapter)
 		queue_list = SYSCTL_CHILDREN(queue_node);
 
 		SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "interrupt_rate", 
-				CTLFLAG_RD, &adapter->queues[i],
+				CTLTYPE_UINT | CTLFLAG_RD, &adapter->queues[i],
 				sizeof(&adapter->queues[i]),
 				igb_sysctl_interrupt_rate_handler,
 				"IU", "Interrupt Rate");
 
 		SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_head", 
-				CTLFLAG_RD, adapter, E1000_TDH(txr->me),
+				CTLTYPE_UINT | CTLFLAG_RD, adapter, E1000_TDH(txr->me),
 				igb_sysctl_reg_handler, "IU",
  				"Transmit Descriptor Head");
 		SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_tail", 
-				CTLFLAG_RD, adapter, E1000_TDT(txr->me),
+				CTLTYPE_UINT | CTLFLAG_RD, adapter, E1000_TDT(txr->me),
 				igb_sysctl_reg_handler, "IU",
  				"Transmit Descriptor Tail");
 		SYSCTL_ADD_QUAD(ctx, queue_list, OID_AUTO, "no_desc_avail", 
@@ -5894,11 +5894,11 @@ igb_add_hw_stats(struct adapter *adapter)
 				"Queue Packets Transmitted");
 
 		SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_head", 
-				CTLFLAG_RD, adapter, E1000_RDH(rxr->me),
+				CTLTYPE_UINT | CTLFLAG_RD, adapter, E1000_RDH(rxr->me),
 				igb_sysctl_reg_handler, "IU",
 				"Receive Descriptor Head");
 		SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_tail", 
-				CTLFLAG_RD, adapter, E1000_RDT(rxr->me),
+				CTLTYPE_UINT | CTLFLAG_RD, adapter, E1000_RDT(rxr->me),
 				igb_sysctl_reg_handler, "IU",
 				"Receive Descriptor Tail");
 		SYSCTL_ADD_QUAD(ctx, queue_list, OID_AUTO, "rx_packets",
@@ -6272,7 +6272,7 @@ igb_set_sysctl_value(struct adapter *adapter, const char *name,
 	*limit = value;
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
-	    OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description);
+	    OID_AUTO, name, CTLFLAG_RW, limit, value, description);
 }
 
 /*
diff --git a/sys/dev/e1000/if_lem.c b/sys/dev/e1000/if_lem.c
index d29c7f1e8d66..894a74a9db81 100644
--- a/sys/dev/e1000/if_lem.c
+++ b/sys/dev/e1000/if_lem.c
@@ -4861,7 +4861,7 @@ lem_set_flow_cntrl(struct adapter *adapter, const char *name,
 	*limit = value;
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
-	    OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description);
+	    OID_AUTO, name, CTLFLAG_RW, limit, value, description);
 }
 
 static void
@@ -4871,5 +4871,5 @@ lem_add_rx_process_limit(struct adapter *adapter, const char *name,
 	*limit = value;
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
-	    OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description);
+	    OID_AUTO, name, CTLFLAG_RW, limit, value, description);
 }
diff --git a/sys/dev/hatm/if_hatm.c b/sys/dev/hatm/if_hatm.c
index 0be8a3d17b83..0677a149aace 100644
--- a/sys/dev/hatm/if_hatm.c
+++ b/sys/dev/hatm/if_hatm.c
@@ -1312,9 +1312,17 @@ kenv_getuint(struct hatm_softc *sc, const char *var,
 
 	*ptr = def;
 
-	if (SYSCTL_ADD_UINT(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
-	    OID_AUTO, var, rw ? CTLFLAG_RW : CTLFLAG_RD, ptr, 0, "") == NULL)
-		return (ENOMEM);
+	if (rw != 0) {
+		if (SYSCTL_ADD_UINT(&sc->sysctl_ctx,
+		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, var,
+		    CTLFLAG_RW, ptr, 0, "") == NULL)
+			return (ENOMEM);
+	} else {
+		if (SYSCTL_ADD_UINT(&sc->sysctl_ctx,
+		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, var,
+		    CTLFLAG_RD, ptr, 0, "") == NULL)
+			return (ENOMEM);
+	}
 
 	snprintf(full, sizeof(full), "hw.%s.%s",
 	    device_get_nameunit(sc->dev), var);
diff --git a/sys/dev/ixgbe/ixgbe.c b/sys/dev/ixgbe/ixgbe.c
index b711b4796618..78fdb36b72ba 100644
--- a/sys/dev/ixgbe/ixgbe.c
+++ b/sys/dev/ixgbe/ixgbe.c
@@ -460,7 +460,7 @@ ixgbe_attach(device_t dev)
 
         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
 			SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-			OID_AUTO, "enable_aim", CTLTYPE_INT|CTLFLAG_RW,
+			OID_AUTO, "enable_aim", CTLFLAG_RW,
 			&ixgbe_enable_aim, 1, "Interrupt Moderation");
 
 	/*
diff --git a/sys/dev/ixgbe/ixv.c b/sys/dev/ixgbe/ixv.c
index 296138ed2469..1d77e8b5a27a 100644
--- a/sys/dev/ixgbe/ixv.c
+++ b/sys/dev/ixgbe/ixv.c
@@ -322,7 +322,7 @@ ixv_attach(device_t dev)
                 
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
 			SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-			OID_AUTO, "enable_aim", CTLTYPE_INT|CTLFLAG_RW,
+			OID_AUTO, "enable_aim", CTLFLAG_RW,
 			&ixv_enable_aim, 1, "Interrupt Moderation");
 
 	/* Set up the timer callout */
@@ -4001,6 +4001,6 @@ ixv_add_rx_process_limit(struct adapter *adapter, const char *name,
         *limit = value;
         SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
             SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
-            OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description);
+            OID_AUTO, name, CTLFLAG_RW, limit, value, description);
 }
 
diff --git a/sys/dev/ixl/if_ixl.c b/sys/dev/ixl/if_ixl.c
index 8d1100c55f45..a1c14781c7e6 100755
--- a/sys/dev/ixl/if_ixl.c
+++ b/sys/dev/ixl/if_ixl.c
@@ -400,22 +400,22 @@ ixl_attach(device_t dev)
 
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-	    OID_AUTO, "rx_itr", CTLTYPE_INT | CTLFLAG_RW,
+	    OID_AUTO, "rx_itr", CTLFLAG_RW,
 	    &ixl_rx_itr, IXL_ITR_8K, "RX ITR");
 
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-	    OID_AUTO, "dynamic_rx_itr", CTLTYPE_INT | CTLFLAG_RW,
+	    OID_AUTO, "dynamic_rx_itr", CTLFLAG_RW,
 	    &ixl_dynamic_rx_itr, 0, "Dynamic RX ITR");
 
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-	    OID_AUTO, "tx_itr", CTLTYPE_INT | CTLFLAG_RW,
+	    OID_AUTO, "tx_itr", CTLFLAG_RW,
 	    &ixl_tx_itr, IXL_ITR_4K, "TX ITR");
 
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-	    OID_AUTO, "dynamic_tx_itr", CTLTYPE_INT | CTLFLAG_RW,
+	    OID_AUTO, "dynamic_tx_itr", CTLFLAG_RW,
 	    &ixl_dynamic_tx_itr, 0, "Dynamic TX ITR");
 
 #ifdef IXL_DEBUG
diff --git a/sys/dev/mpr/mpr.c b/sys/dev/mpr/mpr.c
index 3656eec36864..d3fb9a0682b8 100644
--- a/sys/dev/mpr/mpr.c
+++ b/sys/dev/mpr/mpr.c
@@ -1447,7 +1447,7 @@ mpr_setup_sysctl(struct mpr_softc *sc)
 	    "Disable the use of MSI interrupts");
 
 	SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
-	    OID_AUTO, "firmware_version", CTLFLAG_RW, &sc->fw_version,
+	    OID_AUTO, "firmware_version", CTLFLAG_RW, sc->fw_version,
 	    strlen(sc->fw_version), "firmware version");
 
 	SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
diff --git a/sys/dev/mps/mps.c b/sys/dev/mps/mps.c
index 403a4d2f8493..20c7f75308d2 100644
--- a/sys/dev/mps/mps.c
+++ b/sys/dev/mps/mps.c
@@ -1424,7 +1424,7 @@ mps_setup_sysctl(struct mps_softc *sc)
 	    "Disable the use of MSI interrupts");
 
 	SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
-	    OID_AUTO, "firmware_version", CTLFLAG_RW, &sc->fw_version,
+	    OID_AUTO, "firmware_version", CTLFLAG_RW, sc->fw_version,
 	    strlen(sc->fw_version), "firmware version");
 
 	SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
diff --git a/sys/dev/mrsas/mrsas.c b/sys/dev/mrsas/mrsas.c
index 24738ebb7f2e..9c1caa0290d1 100644
--- a/sys/dev/mrsas/mrsas.c
+++ b/sys/dev/mrsas/mrsas.c
@@ -412,7 +412,7 @@ mrsas_setup_sysctl(struct mrsas_softc *sc)
 
 	SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 	    OID_AUTO, "fw_outstanding", CTLFLAG_RD,
-	    &sc->fw_outstanding, 0, "FW outstanding commands");
+	    &sc->fw_outstanding.val_rdonly, 0, "FW outstanding commands");
 
 	SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 	    OID_AUTO, "io_cmds_highwater", CTLFLAG_RD,
diff --git a/sys/dev/mrsas/mrsas.h b/sys/dev/mrsas/mrsas.h
index 16dc95dfc5a6..37b6e952835c 100644
--- a/sys/dev/mrsas/mrsas.h
+++ b/sys/dev/mrsas/mrsas.h
@@ -511,8 +511,9 @@ typedef union _MPI2_REPLY_DESCRIPTORS_UNION {
 }	MPI2_REPLY_DESCRIPTORS_UNION, MPI2_POINTER PTR_MPI2_REPLY_DESCRIPTORS_UNION,
 Mpi2ReplyDescriptorsUnion_t, MPI2_POINTER pMpi2ReplyDescriptorsUnion_t;
 
-typedef struct {
+typedef union {
 	volatile unsigned int val;
+	unsigned int val_rdonly;
 } mrsas_atomic_t;
 
 #define	mrsas_atomic_read(v)	atomic_load_acq_int(&(v)->val)
@@ -2523,7 +2524,7 @@ struct mrsas_softc {
 	void   *ctlr_info_mem;
 	bus_addr_t ctlr_info_phys_addr;
 	u_int32_t max_sectors_per_req;
-	u_int8_t disableOnlineCtrlReset;
+	u_int32_t disableOnlineCtrlReset;
 	mrsas_atomic_t fw_outstanding;
 	u_int32_t mrsas_debug;
 	u_int32_t mrsas_io_timeout;
diff --git a/sys/dev/mxge/if_mxge.c b/sys/dev/mxge/if_mxge.c
index 8de14857c517..e97ae5c7130e 100644
--- a/sys/dev/mxge/if_mxge.c
+++ b/sys/dev/mxge/if_mxge.c
@@ -1468,15 +1468,15 @@ mxge_add_sysctls(mxge_softc_t *sc)
 	/* random information */
 	SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
 		       "firmware_version",
-		       CTLFLAG_RD, &sc->fw_version,
+		       CTLFLAG_RD, sc->fw_version,
 		       0, "firmware version");
 	SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
 		       "serial_number",
-		       CTLFLAG_RD, &sc->serial_number_string,
+		       CTLFLAG_RD, sc->serial_number_string,
 		       0, "serial number");
 	SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
 		       "product_code",
-		       CTLFLAG_RD, &sc->product_code_string,
+		       CTLFLAG_RD, sc->product_code_string,
 		       0, "product_code");
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
 		       "pcie_link_width",
diff --git a/sys/dev/oce/oce_sysctl.c b/sys/dev/oce/oce_sysctl.c
index 0cafbbd84edf..3df7d0ddbb03 100644
--- a/sys/dev/oce/oce_sysctl.c
+++ b/sys/dev/oce/oce_sysctl.c
@@ -84,21 +84,21 @@ oce_add_sysctls(POCE_SOFTC sc)
 
 	SYSCTL_ADD_STRING(ctx, child,
 			OID_AUTO, "component_revision",
-			CTLTYPE_INT | CTLFLAG_RD,
-			&component_revision,
+			CTLFLAG_RD,
+			component_revision,
 			sizeof(component_revision),
 			"EMULEX One-Connect device driver revision");
 
 	SYSCTL_ADD_STRING(ctx, child,
 			OID_AUTO, "firmware_version",
-			CTLTYPE_INT | CTLFLAG_RD,
-			&sc->fw_version,
+			CTLFLAG_RD,
+			sc->fw_version,
 			sizeof(sc->fw_version),
 			"EMULEX One-Connect Firmware Version");
 
 	SYSCTL_ADD_INT(ctx, child,
 			OID_AUTO, "max_rsp_handled",
-			CTLTYPE_INT | CTLFLAG_RW,
+			CTLFLAG_RW,
 			&oce_max_rsp_handled,
 			sizeof(oce_max_rsp_handled),
 			"Maximum receive frames handled per interupt");
@@ -957,11 +957,11 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
 	SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_rxcp_errs",
 			CTLFLAG_RD, &stats->rx.t_rxcp_errs, 0,
 			"Total Receive completion errors");
-	SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "pause_frames",
-			CTLFLAG_RD, &stats->u0.xe201.rx_pause_frames, 0,
+	SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "pause_frames",
+			CTLFLAG_RD, &stats->u0.xe201.rx_pause_frames,
 			"Pause Frames");
-	SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "control_frames",
-			CTLFLAG_RD, &stats->u0.xe201.rx_control_frames, 0,
+	SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "control_frames",
+			CTLFLAG_RD, &stats->u0.xe201.rx_control_frames,
 			"Control Frames");
 	
 	for (i = 0; i < sc->nrqs; i++) {
@@ -1001,11 +1001,11 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
 					NULL, "Receive Error Stats");
 	rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
 	
-	SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "crc_errs",
-			CTLFLAG_RD, &stats->u0.xe201.rx_crc_errors, 0,
+	SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "crc_errs",
+			CTLFLAG_RD, &stats->u0.xe201.rx_crc_errors,
 			"CRC Errors");
-	SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "alignment_errors",
-			CTLFLAG_RD, &stats->u0.xe201.rx_alignment_errors, 0,
+	SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "alignment_errors",
+			CTLFLAG_RD, &stats->u0.xe201.rx_alignment_errors,
 			"RX Alignmnet Errors");
 	SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "in_range_errors",
 			CTLFLAG_RD, &stats->u0.xe201.rx_in_range_errors, 0,
@@ -1013,8 +1013,8 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
 	SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "out_range_errors",
 			CTLFLAG_RD, &stats->u0.xe201.rx_out_of_range_errors, 0,
 			"Out Range Errors");
-	SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "frame_too_long",
-			CTLFLAG_RD, &stats->u0.xe201.rx_frames_too_long, 0,
+	SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "frame_too_long",
+			CTLFLAG_RD, &stats->u0.xe201.rx_frames_too_long,
 			"Frame Too Long");
 	SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "address_match_errors",
 			CTLFLAG_RD, &stats->u0.xe201.rx_address_match_errors, 0,
@@ -1077,11 +1077,11 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
 			"total_ipv6_ext_hdr_tx_drop",
 			CTLFLAG_RD, &stats->tx.t_ipv6_ext_hdr_tx_drop, 0,
 			"Total Transmit IPV6 Drops");
-	SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "pauseframes",
-			CTLFLAG_RD, &stats->u0.xe201.tx_pause_frames, 0,
+	SYSCTL_ADD_UQUAD(ctx, tx_stat_list, OID_AUTO, "pauseframes",
+			CTLFLAG_RD, &stats->u0.xe201.tx_pause_frames,
 			"Pause Frames");
-	SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "controlframes",
-			CTLFLAG_RD, &stats->u0.xe201.tx_control_frames, 0,
+	SYSCTL_ADD_UQUAD(ctx, tx_stat_list, OID_AUTO, "controlframes",
+			CTLFLAG_RD, &stats->u0.xe201.tx_control_frames,
 			"Tx Control Frames");
 
 	for (i = 0; i < sc->nwqs; i++) {
diff --git a/sys/dev/qlxgb/qla_os.c b/sys/dev/qlxgb/qla_os.c
index 7da4d1d55214..54619cb214f2 100644
--- a/sys/dev/qlxgb/qla_os.c
+++ b/sys/dev/qlxgb/qla_os.c
@@ -157,7 +157,7 @@ qla_add_sysctls(qla_host_t *ha)
 	SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
 		SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 		OID_AUTO, "fw_version", CTLFLAG_RD,
-		&ha->fw_ver_str, 0, "firmware version");
+		ha->fw_ver_str, 0, "firmware version");
 
 	dbg_level = 0;
         SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev),
diff --git a/sys/dev/qlxgbe/ql_os.c b/sys/dev/qlxgbe/ql_os.c
index 461309cb5fe1..1684c070fcd8 100644
--- a/sys/dev/qlxgbe/ql_os.c
+++ b/sys/dev/qlxgbe/ql_os.c
@@ -160,7 +160,7 @@ qla_add_sysctls(qla_host_t *ha)
         SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
                 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
                 OID_AUTO, "fw_version", CTLFLAG_RD,
-                &ha->fw_ver_str, 0, "firmware version");
+                ha->fw_ver_str, 0, "firmware version");
 
         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
                 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
diff --git a/sys/dev/rt/if_rt.c b/sys/dev/rt/if_rt.c
index f89f6dc512a1..b10b581ecd9e 100644
--- a/sys/dev/rt/if_rt.c
+++ b/sys/dev/rt/if_rt.c
@@ -2339,45 +2339,45 @@ rt_sysctl_attach(struct rt_softc *sc)
 	stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
 	    "stats", CTLFLAG_RD, 0, "statistic");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "interrupts", CTLFLAG_RD, &sc->interrupts, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "interrupts", CTLFLAG_RD, &sc->interrupts,
 	    "all interrupts");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "tx_coherent_interrupts", CTLFLAG_RD, &sc->tx_coherent_interrupts,
-	    0, "Tx coherent interrupts");
+	    "Tx coherent interrupts");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "rx_coherent_interrupts", CTLFLAG_RD, &sc->rx_coherent_interrupts,
-	    0, "Rx coherent interrupts");
+	    "Rx coherent interrupts");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "rx_interrupts", CTLFLAG_RD, &sc->rx_interrupts, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "rx_interrupts", CTLFLAG_RD, &sc->rx_interrupts,
 	    "Rx interrupts");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "rx_delay_interrupts", CTLFLAG_RD, &sc->rx_delay_interrupts, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "rx_delay_interrupts", CTLFLAG_RD, &sc->rx_delay_interrupts,
 	    "Rx delay interrupts");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "TXQ3_interrupts", CTLFLAG_RD, &sc->tx_interrupts[3], 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "TXQ3_interrupts", CTLFLAG_RD, &sc->tx_interrupts[3],
 	    "Tx AC3 interrupts");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "TXQ2_interrupts", CTLFLAG_RD, &sc->tx_interrupts[2], 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "TXQ2_interrupts", CTLFLAG_RD, &sc->tx_interrupts[2],
 	    "Tx AC2 interrupts");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "TXQ1_interrupts", CTLFLAG_RD, &sc->tx_interrupts[1], 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "TXQ1_interrupts", CTLFLAG_RD, &sc->tx_interrupts[1],
 	    "Tx AC1 interrupts");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "TXQ0_interrupts", CTLFLAG_RD, &sc->tx_interrupts[0], 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "TXQ0_interrupts", CTLFLAG_RD, &sc->tx_interrupts[0],
 	    "Tx AC0 interrupts");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "tx_delay_interrupts", CTLFLAG_RD, &sc->tx_delay_interrupts,
-	    0, "Tx delay interrupts");
+	    "Tx delay interrupts");
 
 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "TXQ3_desc_queued", CTLFLAG_RD, &sc->tx_ring[3].desc_queued,
@@ -2411,93 +2411,96 @@ rt_sysctl_attach(struct rt_softc *sc)
 	    "TXQ0_data_queued", CTLFLAG_RD, &sc->tx_ring[0].data_queued,
 	    0, "Tx AC0 data queued");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "TXQ3_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[3],
-	    0, "Tx AC3 data queue full");
+	    "Tx AC3 data queue full");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "TXQ2_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[2],
-	    0, "Tx AC2 data queue full");
+	    "Tx AC2 data queue full");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "TXQ1_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[1],
-	    0, "Tx AC1 data queue full");
+	    "Tx AC1 data queue full");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "TXQ0_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[0],
-	    0, "Tx AC0 data queue full");
+	    "Tx AC0 data queue full");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "tx_watchdog_timeouts", CTLFLAG_RD, &sc->tx_watchdog_timeouts,
-	    0, "Tx watchdog timeouts");
+	    "Tx watchdog timeouts");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "tx_defrag_packets", CTLFLAG_RD, &sc->tx_defrag_packets, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "tx_defrag_packets", CTLFLAG_RD, &sc->tx_defrag_packets,
 	    "Tx defragmented packets");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "no_tx_desc_avail", CTLFLAG_RD, &sc->no_tx_desc_avail, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "no_tx_desc_avail", CTLFLAG_RD, &sc->no_tx_desc_avail,
 	    "no Tx descriptors available");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "rx_mbuf_alloc_errors", CTLFLAG_RD, &sc->rx_mbuf_alloc_errors,
-	    0, "Rx mbuf allocation errors");
+	    "Rx mbuf allocation errors");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "rx_mbuf_dmamap_errors", CTLFLAG_RD, &sc->rx_mbuf_dmamap_errors,
-	    0, "Rx mbuf DMA mapping errors");
+	    "Rx mbuf DMA mapping errors");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "tx_queue_0_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[0],
-	    0, "Tx queue 0 not empty");
+	    "Tx queue 0 not empty");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
 	    "tx_queue_1_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[1],
-	    0, "Tx queue 1 not empty");
+	    "Tx queue 1 not empty");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "rx_packets", CTLFLAG_RD, &sc->rx_packets, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "rx_packets", CTLFLAG_RD, &sc->rx_packets,
 	    "Rx packets");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "rx_crc_errors", CTLFLAG_RD, &sc->rx_crc_err, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "rx_crc_errors", CTLFLAG_RD, &sc->rx_crc_err,
 	    "Rx CRC errors");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "rx_phy_errors", CTLFLAG_RD, &sc->rx_phy_err, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "rx_phy_errors", CTLFLAG_RD, &sc->rx_phy_err,
 	    "Rx PHY errors");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "rx_dup_packets", CTLFLAG_RD, &sc->rx_dup_packets, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "rx_dup_packets", CTLFLAG_RD, &sc->rx_dup_packets,
 	    "Rx duplicate packets");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "rx_fifo_overflows", CTLFLAG_RD, &sc->rx_fifo_overflows, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "rx_fifo_overflows", CTLFLAG_RD, &sc->rx_fifo_overflows,
 	    "Rx FIFO overflows");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "rx_bytes", CTLFLAG_RD, &sc->rx_bytes, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "rx_bytes", CTLFLAG_RD, &sc->rx_bytes,
 	    "Rx bytes");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "rx_long_err", CTLFLAG_RD, &sc->rx_long_err, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "rx_long_err", CTLFLAG_RD, &sc->rx_long_err,
 	    "Rx too long frame errors");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "rx_short_err", CTLFLAG_RD, &sc->rx_short_err, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "rx_short_err", CTLFLAG_RD, &sc->rx_short_err,
 	    "Rx too short frame errors");
 
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "tx_bytes", CTLFLAG_RD, &sc->tx_bytes, 0,
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "tx_bytes", CTLFLAG_RD, &sc->tx_bytes,
 	    "Tx bytes");
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "tx_packets", CTLFLAG_RD, &sc->tx_packets, 0,
+
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "tx_packets", CTLFLAG_RD, &sc->tx_packets,
 	    "Tx packets");
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "tx_skip", CTLFLAG_RD, &sc->tx_skip, 0,
+
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "tx_skip", CTLFLAG_RD, &sc->tx_skip,
 	    "Tx skip count for GDMA ports");
-	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
-	    "tx_collision", CTLFLAG_RD, &sc->tx_collision, 0,
+
+	SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
+	    "tx_collision", CTLFLAG_RD, &sc->tx_collision,
 	    "Tx collision count for GDMA ports");
 }
 
diff --git a/sys/dev/sound/pci/hda/hdaa.c b/sys/dev/sound/pci/hda/hdaa.c
index 5a88d59fb74b..0d2ae4735b1d 100644
--- a/sys/dev/sound/pci/hda/hdaa.c
+++ b/sys/dev/sound/pci/hda/hdaa.c
@@ -7092,7 +7092,7 @@ hdaa_pcm_attach(device_t dev)
 		    "rec.autosrc", &pdevinfo->autorecsrc);
 		SYSCTL_ADD_INT(&d->rec_sysctl_ctx,
 		    SYSCTL_CHILDREN(d->rec_sysctl_tree), OID_AUTO,
-		    "autosrc", CTLTYPE_INT | CTLFLAG_RW,
+		    "autosrc", CTLFLAG_RW,
 		    &pdevinfo->autorecsrc, 0,
 		    "Automatic recording source selection");
 	}
diff --git a/sys/dev/vxge/vxge.c b/sys/dev/vxge/vxge.c
index e23e701567aa..b89ba6cca51e 100644
--- a/sys/dev/vxge/vxge.c
+++ b/sys/dev/vxge/vxge.c
@@ -3357,100 +3357,100 @@ vxge_device_hw_info_print(vxge_dev_t *vdev)
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "Driver version", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_DRV_VERSION],
+	    vdev->config.nic_attr[VXGE_PRINT_DRV_VERSION],
 	    0, "Driver version");
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "Serial number", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_SERIAL_NO],
+	    vdev->config.nic_attr[VXGE_PRINT_SERIAL_NO],
 	    0, "Serial number");
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "Part number", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_PART_NO],
+	    vdev->config.nic_attr[VXGE_PRINT_PART_NO],
 	    0, "Part number");
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "Firmware version", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_FW_VERSION],
+	    vdev->config.nic_attr[VXGE_PRINT_FW_VERSION],
 	    0, "Firmware version");
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "Firmware date", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_FW_DATE],
+	    vdev->config.nic_attr[VXGE_PRINT_FW_DATE],
 	    0, "Firmware date");
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "Link width", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_PCIE_INFO],
+	    vdev->config.nic_attr[VXGE_PRINT_PCIE_INFO],
 	    0, "Link width");
 
 	if (vdev->is_privilaged) {
 		SYSCTL_ADD_STRING(ctx, children,
 		    OID_AUTO, "Function mode", CTLFLAG_RD,
-		    &vdev->config.nic_attr[VXGE_PRINT_FUNC_MODE],
+		    vdev->config.nic_attr[VXGE_PRINT_FUNC_MODE],
 		    0, "Function mode");
 	}
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "Interrupt type", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_INTR_MODE],
+	    vdev->config.nic_attr[VXGE_PRINT_INTR_MODE],
 	    0, "Interrupt type");
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "VPath(s) opened", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_VPATH_COUNT],
+	    vdev->config.nic_attr[VXGE_PRINT_VPATH_COUNT],
 	    0, "VPath(s) opened");
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "Adapter Type", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_ADAPTER_TYPE],
+	    vdev->config.nic_attr[VXGE_PRINT_ADAPTER_TYPE],
 	    0, "Adapter Type");
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "pmd port 0", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_PMD_PORTS_0],
+	    vdev->config.nic_attr[VXGE_PRINT_PMD_PORTS_0],
 	    0, "pmd port");
 
 	if (hw_info->ports > 1) {
 
 		SYSCTL_ADD_STRING(ctx, children,
 		    OID_AUTO, "pmd port 1", CTLFLAG_RD,
-		    &vdev->config.nic_attr[VXGE_PRINT_PMD_PORTS_1],
+		    vdev->config.nic_attr[VXGE_PRINT_PMD_PORTS_1],
 		    0, "pmd port");
 
 		if (vdev->is_privilaged) {
 			SYSCTL_ADD_STRING(ctx, children,
 			    OID_AUTO, "Port Mode", CTLFLAG_RD,
-			    &vdev->config.nic_attr[VXGE_PRINT_PORT_MODE],
+			    vdev->config.nic_attr[VXGE_PRINT_PORT_MODE],
 			    0, "Port Mode");
 
 			if (vdev->port_mode != VXGE_HAL_DP_NP_MODE_SINGLE_PORT)
 				SYSCTL_ADD_STRING(ctx, children,
 				    OID_AUTO, "Port Failure", CTLFLAG_RD,
-				    &vdev->config.nic_attr[VXGE_PRINT_PORT_FAILURE],
+				    vdev->config.nic_attr[VXGE_PRINT_PORT_FAILURE],
 				    0, "Port Failure");
 
 			SYSCTL_ADD_STRING(ctx, children,
 			    OID_AUTO, "L2 Switch", CTLFLAG_RD,
-			    &vdev->config.nic_attr[VXGE_PRINT_L2SWITCH_MODE],
+			    vdev->config.nic_attr[VXGE_PRINT_L2SWITCH_MODE],
 			    0, "L2 Switch");
 		}
 	}
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "LRO mode", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_LRO_MODE],
+	    vdev->config.nic_attr[VXGE_PRINT_LRO_MODE],
 	    0, "LRO mode");
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "RTH mode", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_RTH_MODE],
+	    vdev->config.nic_attr[VXGE_PRINT_RTH_MODE],
 	    0, "RTH mode");
 
 	SYSCTL_ADD_STRING(ctx, children,
 	    OID_AUTO, "TSO mode", CTLFLAG_RD,
-	    &vdev->config.nic_attr[VXGE_PRINT_TSO_MODE],
+	    vdev->config.nic_attr[VXGE_PRINT_TSO_MODE],
 	    0, "TSO mode");
 }
 
diff --git a/sys/dev/xen/netfront/netfront.c b/sys/dev/xen/netfront/netfront.c
index a652c75f0174..c3c8d920911c 100644
--- a/sys/dev/xen/netfront/netfront.c
+++ b/sys/dev/xen/netfront/netfront.c
@@ -470,7 +470,7 @@ netfront_attach(device_t dev)
 #if __FreeBSD_version >= 700000
 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
-	    OID_AUTO, "enable_lro", CTLTYPE_INT|CTLFLAG_RW,
+	    OID_AUTO, "enable_lro", CTLFLAG_RW,
 	    &xn_enable_lro, 0, "Large Receive Offload");
 #endif