D23110.1789661378.diff
No OneTemporary
Actions

Size

459 KB

Referenced Files

None

Subscribers

None

D23110.1789661378.diff
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	Index: share/man/man9/sysctl.9
	===================================================================
	--- share/man/man9/sysctl.9
	+++ share/man/man9/sysctl.9
	@@ -25,7 +25,7 @@
	.\"
	.\" $FreeBSD$
	.\"
	-.Dd June 11, 2019
	+.Dd January 16, 2020
	.Dt SYSCTL 9
	.Os
	.Sh NAME
	@@ -881,6 +881,14 @@
	This should only be used for
	.Fn SYSCTL_PROC
	entries.
	+.It Dv CTLFLAG_NEEDGIANT
	+This
	+.Xr sysctl 9
	+handler is not MP safe and require locking Giant to operate safely.
	+Creating new nodes of this type is strongly discouraged.
	+This should only be used for
	+.Fn SYSCTL_PROC
	+entries.
	.El
	.Pp
	Additionally, any of the following optional flags may also be specified:
	Index: sys/amd64/amd64/efirt_machdep.c
	===================================================================
	--- sys/amd64/amd64/efirt_machdep.c
	+++ sys/amd64/amd64/efirt_machdep.c
	@@ -325,5 +325,7 @@
	return (error);
	}

	-SYSCTL_PROC(_debug, OID_AUTO, efi_time, CTLTYPE_INT \| CTLFLAG_RW, NULL, 0,
	- efi_time_sysctl_handler, "I", "");
	+SYSCTL_PROC(_debug, OID_AUTO, efi_time,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, NULL, 0,
	+ efi_time_sysctl_handler, "I",
	+ "");
	Index: sys/amd64/amd64/machdep.c
	===================================================================
	--- sys/amd64/amd64/machdep.c
	+++ sys/amd64/amd64/machdep.c
	@@ -1960,8 +1960,10 @@
	}
	return (error);
	}
	-SYSCTL_PROC(_machdep, OID_AUTO, smap, CTLTYPE_OPAQUE\|CTLFLAG_RD, NULL, 0,
	- smap_sysctl_handler, "S,bios_smap_xattr", "Raw BIOS SMAP data");
	+SYSCTL_PROC(_machdep, OID_AUTO, smap,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, NULL, 0,
	+ smap_sysctl_handler, "S,bios_smap_xattr",
	+ "Raw BIOS SMAP data");

	static int
	efi_map_sysctl_handler(SYSCTL_HANDLER_ARGS)
	@@ -1980,8 +1982,10 @@
	efisize = ((uint32_t )efihdr - 1);
	return (SYSCTL_OUT(req, efihdr, efisize));
	}
	-SYSCTL_PROC(_machdep, OID_AUTO, efi_map, CTLTYPE_OPAQUE\|CTLFLAG_RD, NULL, 0,
	- efi_map_sysctl_handler, "S,efi_map_header", "Raw EFI Memory Map");
	+SYSCTL_PROC(_machdep, OID_AUTO, efi_map,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, NULL, 0,
	+ efi_map_sysctl_handler, "S,efi_map_header",
	+ "Raw EFI Memory Map");

	void
	spinlock_enter(void)
	Index: sys/amd64/amd64/prof_machdep.c
	===================================================================
	--- sys/amd64/amd64/prof_machdep.c
	+++ sys/amd64/amd64/prof_machdep.c
	@@ -262,8 +262,10 @@
	return (error);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, cputime_clock, CTLTYPE_INT \| CTLFLAG_RW,
	- 0, sizeof(u_int), sysctl_machdep_cputime_clock, "I", "");
	+SYSCTL_PROC(_machdep, OID_AUTO, cputime_clock,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof(u_int), sysctl_machdep_cputime_clock, "I",
	+ "");

	/*
	* The start and stop routines need not be here since we turn off profiling
	Index: sys/amd64/vmm/amd/amdvi_hw.c
	===================================================================
	--- sys/amd64/vmm/amd/amdvi_hw.c
	+++ sys/amd64/vmm/amd/amdvi_hw.c
	@@ -947,16 +947,16 @@
	SYSCTL_ADD_U16(ctx, child, OID_AUTO, "end_dev_rid", CTLFLAG_RD,
	&softc->end_dev_rid, 0, "End of device under this IOMMU");
	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "command_head",
	- CTLTYPE_UINT \| CTLFLAG_RD, softc, 0,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, softc, 0,
	amdvi_handle_sysctl, "IU", "Command head");
	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "command_tail",
	- CTLTYPE_UINT \| CTLFLAG_RD, softc, 1,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, softc, 1,
	amdvi_handle_sysctl, "IU", "Command tail");
	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "event_head",
	- CTLTYPE_UINT \| CTLFLAG_RD, softc, 2,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, softc, 2,
	amdvi_handle_sysctl, "IU", "Command head");
	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "event_tail",
	- CTLTYPE_UINT \| CTLFLAG_RD, softc, 3,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, softc, 3,
	amdvi_handle_sysctl, "IU", "Command tail");
	}

	Index: sys/amd64/vmm/vmm_dev.c
	===================================================================
	--- sys/amd64/vmm/vmm_dev.c
	+++ sys/amd64/vmm/vmm_dev.c
	@@ -962,8 +962,9 @@
	return (error);
	}
	SYSCTL_PROC(_hw_vmm, OID_AUTO, destroy,
	- CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_PRISON,
	- NULL, 0, sysctl_vmm_destroy, "A", NULL);
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_PRISON \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_vmm_destroy, "A",
	+ NULL);

	static struct cdevsw vmmdevsw = {
	.d_name = "vmmdev",
	@@ -1045,8 +1046,9 @@
	return (error);
	}
	SYSCTL_PROC(_hw_vmm, OID_AUTO, create,
	- CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_PRISON,
	- NULL, 0, sysctl_vmm_create, "A", NULL);
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_PRISON \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_vmm_create, "A",
	+ NULL);

	void
	vmmdev_init(void)
	Index: sys/arm/allwinner/aw_sid.c
	===================================================================
	--- sys/arm/allwinner/aw_sid.c
	+++ sys/arm/allwinner/aw_sid.c
	@@ -278,7 +278,7 @@
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	OID_AUTO, sc->sid_conf->efuses[i].name,
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev, sc->sid_conf->efuses[i].id, aw_sid_sysctl,
	"A", sc->sid_conf->efuses[i].desc);
	}
	Index: sys/arm/allwinner/aw_thermal.c
	===================================================================
	--- sys/arm/allwinner/aw_thermal.c
	+++ sys/arm/allwinner/aw_thermal.c
	@@ -676,7 +676,7 @@
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	OID_AUTO, sc->conf->sensors[i].name,
	- CTLTYPE_INT \| CTLFLAG_RD,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, i, aw_thermal_sysctl, "IK0",
	sc->conf->sensors[i].desc);

	Index: sys/arm/allwinner/aw_ts.c
	===================================================================
	--- sys/arm/allwinner/aw_ts.c
	+++ sys/arm/allwinner/aw_ts.c
	@@ -204,7 +204,8 @@
	/* Add sysctl */
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "temperature", CTLTYPE_INT \| CTLFLAG_RD,
	+ OID_AUTO, "temperature",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&sc->temp_data, 0, sysctl_handle_int,
	"IK3", "CPU Temperature");

	Index: sys/arm/allwinner/axp209.c
	===================================================================
	--- sys/arm/allwinner/axp209.c
	+++ sys/arm/allwinner/axp209.c
	@@ -1268,7 +1268,7 @@
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	OID_AUTO, sc->sensors[i].name,
	- CTLTYPE_INT \| CTLFLAG_RD,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev, sc->sensors[i].id, axp2xx_sysctl,
	sc->sensors[i].format,
	sc->sensors[i].desc);
	Index: sys/arm/allwinner/axp81x.c
	===================================================================
	--- sys/arm/allwinner/axp81x.c
	+++ sys/arm/allwinner/axp81x.c
	@@ -1502,7 +1502,7 @@
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	OID_AUTO, sc->sensors[i].name,
	- CTLTYPE_INT \| CTLFLAG_RD,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev, sc->sensors[i].id, axp8xx_sysctl,
	sc->sensors[i].format,
	sc->sensors[i].desc);
	@@ -1510,7 +1510,7 @@
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	OID_AUTO, "batchargecurrentstep",
	- CTLTYPE_INT \| CTLFLAG_RW,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	dev, 0, axp8xx_sysctl_chargecurrent,
	"I", "Battery Charging Current Step, "
	"0: 200mA, 1: 400mA, 2: 600mA, 3: 800mA, "
	Index: sys/arm/allwinner/if_emac.c
	===================================================================
	--- sys/arm/allwinner/if_emac.c
	+++ sys/arm/allwinner/if_emac.c
	@@ -923,7 +923,8 @@
	/* Create device sysctl node. */
	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->emac_rx_process_limit, 0, sysctl_hw_emac_proc_limit, "I",
	"max number of Rx events to process");

	Index: sys/arm/altera/socfpga/socfpga_rstmgr.c
	===================================================================
	--- sys/arm/altera/socfpga/socfpga_rstmgr.c
	+++ sys/arm/altera/socfpga/socfpga_rstmgr.c
	@@ -190,13 +190,16 @@
	children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));

	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fpga2hps",
	- CTLTYPE_UINT \| CTLFLAG_RW, sc, RSTMGR_SYSCTL_FPGA2HPS,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, RSTMGR_SYSCTL_FPGA2HPS,
	rstmgr_sysctl, "I", "Enable fpga2hps bridge");
	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "lwhps2fpga",
	- CTLTYPE_UINT \| CTLFLAG_RW, sc, RSTMGR_SYSCTL_LWHPS2FPGA,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, RSTMGR_SYSCTL_LWHPS2FPGA,
	rstmgr_sysctl, "I", "Enable lwhps2fpga bridge");
	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "hps2fpga",
	- CTLTYPE_UINT \| CTLFLAG_RW, sc, RSTMGR_SYSCTL_HPS2FPGA,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, RSTMGR_SYSCTL_HPS2FPGA,
	rstmgr_sysctl, "I", "Enable hps2fpga bridge");

	return (0);
	Index: sys/arm/arm/pmap-v6.c
	===================================================================
	--- sys/arm/arm/pmap-v6.c
	+++ sys/arm/arm/pmap-v6.c
	@@ -2108,8 +2108,10 @@

	return (sysctl_handle_long(oidp, &ksize, 0, req));
	}
	-SYSCTL_PROC(_vm, OID_AUTO, kvm_size, CTLTYPE_LONG\|CTLFLAG_RD,
	- 0, 0, kvm_size, "IU", "Size of KVM");
	+SYSCTL_PROC(_vm, OID_AUTO, kvm_size,
	+ CTLTYPE_LONG \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, kvm_size, "IU",
	+ "Size of KVM");

	static int
	kvm_free(SYSCTL_HANDLER_ARGS)
	@@ -2118,8 +2120,10 @@

	return (sysctl_handle_long(oidp, &kfree, 0, req));
	}
	-SYSCTL_PROC(_vm, OID_AUTO, kvm_free, CTLTYPE_LONG\|CTLFLAG_RD,
	- 0, 0, kvm_free, "IU", "Amount of KVM free");
	+SYSCTL_PROC(_vm, OID_AUTO, kvm_free,
	+ CTLTYPE_LONG \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, kvm_free, "IU",
	+ "Amount of KVM free");

	/***********************************************
	*
	Index: sys/arm/broadcom/bcm2835/bcm2835_audio.c
	===================================================================
	--- sys/arm/broadcom/bcm2835/bcm2835_audio.c
	+++ sys/arm/broadcom/bcm2835/bcm2835_audio.c
	@@ -810,7 +810,7 @@
	tree_node = device_get_sysctl_tree(sc->dev);
	tree = SYSCTL_CHILDREN(tree_node);
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "dest",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, sizeof(*sc),
	sysctl_bcm2835_audio_dest, "IU", "audio destination, "
	"0 - auto, 1 - headphones, 2 - HDMI");
	SYSCTL_ADD_UQUAD(ctx, tree, OID_AUTO, "callbacks",
	Index: sys/arm/broadcom/bcm2835/bcm2835_bsc.c
	===================================================================
	--- sys/arm/broadcom/bcm2835/bcm2835_bsc.c
	+++ sys/arm/broadcom/bcm2835/bcm2835_bsc.c
	@@ -248,16 +248,20 @@
	tree_node = device_get_sysctl_tree(sc->sc_dev);
	tree = SYSCTL_CHILDREN(tree_node);
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "frequency",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT,
	+ sc, sizeof(*sc),
	bcm_bsc_clock_proc, "IU", "I2C BUS clock frequency");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "clock_stretch",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT,
	+ sc, sizeof(*sc),
	bcm_bsc_clkt_proc, "IU", "I2C BUS clock stretch timeout");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "fall_edge_delay",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT,
	+ sc, sizeof(*sc),
	bcm_bsc_fall_proc, "IU", "I2C BUS falling edge delay");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "rise_edge_delay",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT,
	+ sc, sizeof(*sc),
	bcm_bsc_rise_proc, "IU", "I2C BUS rising edge delay");
	SYSCTL_ADD_INT(ctx, tree, OID_AUTO, "debug",
	CTLFLAG_RWTUN, &sc->sc_debug, 0,
	Index: sys/arm/broadcom/bcm2835/bcm2835_cpufreq.c
	===================================================================
	--- sys/arm/broadcom/bcm2835/bcm2835_cpufreq.c
	+++ sys/arm/broadcom/bcm2835/bcm2835_cpufreq.c
	@@ -1245,7 +1245,8 @@
	ctx = device_get_sysctl_ctx(cpu);
	SYSCTL_ADD_PROC(ctx,
	SYSCTL_CHILDREN(device_get_sysctl_tree(cpu)), OID_AUTO,
	- "temperature", CTLTYPE_INT \| CTLFLAG_RD, sc, 0,
	+ "temperature",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, 0,
	sysctl_bcm2835_devcpu_temperature, "IK",
	"Current SoC temperature");
	}
	@@ -1316,53 +1317,63 @@

	/* Frequency (Hz) */
	SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
	- OID_AUTO, "arm_freq", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ OID_AUTO, "arm_freq",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	sysctl_bcm2835_cpufreq_arm_freq, "IU",
	"ARM frequency (Hz)");
	SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
	- OID_AUTO, "core_freq", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ OID_AUTO, "core_freq",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	sysctl_bcm2835_cpufreq_core_freq, "IU",
	"Core frequency (Hz)");
	SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
	- OID_AUTO, "sdram_freq", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ OID_AUTO, "sdram_freq",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	sysctl_bcm2835_cpufreq_sdram_freq, "IU",
	"SDRAM frequency (Hz)");

	/* Turbo state */
	SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
	- OID_AUTO, "turbo", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ OID_AUTO, "turbo",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	sysctl_bcm2835_cpufreq_turbo, "IU",
	"Disables dynamic clocking");

	/* Voltage (offset from 1.2V in units of 0.025V) */
	SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
	- OID_AUTO, "voltage_core", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ OID_AUTO, "voltage_core",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	sysctl_bcm2835_cpufreq_voltage_core, "I",
	"ARM/GPU core voltage"
	"(offset from 1.2V in units of 0.025V)");
	SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
	- OID_AUTO, "voltage_sdram", CTLTYPE_INT \| CTLFLAG_WR, sc,
	+ OID_AUTO, "voltage_sdram",
	+ CTLTYPE_INT \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT, sc,
	0, sysctl_bcm2835_cpufreq_voltage_sdram, "I",
	"SDRAM voltage (offset from 1.2V in units of 0.025V)");

	/* Voltage individual SDRAM */
	SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
	- OID_AUTO, "voltage_sdram_c", CTLTYPE_INT \| CTLFLAG_RW, sc,
	+ OID_AUTO, "voltage_sdram_c",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc,
	0, sysctl_bcm2835_cpufreq_voltage_sdram_c, "I",
	"SDRAM controller voltage"
	"(offset from 1.2V in units of 0.025V)");
	SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
	- OID_AUTO, "voltage_sdram_i", CTLTYPE_INT \| CTLFLAG_RW, sc,
	+ OID_AUTO, "voltage_sdram_i",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc,
	0, sysctl_bcm2835_cpufreq_voltage_sdram_i, "I",
	"SDRAM I/O voltage (offset from 1.2V in units of 0.025V)");
	SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
	- OID_AUTO, "voltage_sdram_p", CTLTYPE_INT \| CTLFLAG_RW, sc,
	+ OID_AUTO, "voltage_sdram_p",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc,
	0, sysctl_bcm2835_cpufreq_voltage_sdram_p, "I",
	"SDRAM phy voltage (offset from 1.2V in units of 0.025V)");

	/* Temperature */
	SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
	- OID_AUTO, "temperature", CTLTYPE_INT \| CTLFLAG_RD, sc, 0,
	+ OID_AUTO, "temperature",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, 0,
	sysctl_bcm2835_cpufreq_temperature, "I",
	"SoC temperature (thousandths of a degree C)");
	}
	Index: sys/arm/broadcom/bcm2835/bcm2835_fbd.c
	===================================================================
	--- sys/arm/broadcom/bcm2835/bcm2835_fbd.c
	+++ sys/arm/broadcom/bcm2835/bcm2835_fbd.c
	@@ -199,7 +199,7 @@
	tree_node = device_get_sysctl_tree(sc->dev);
	tree = SYSCTL_CHILDREN(tree_node);
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "resync",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, sizeof(*sc),
	bcm_fb_resync_sysctl, "IU", "Set to resync framebuffer with VC");
	}

	Index: sys/arm/broadcom/bcm2835/bcm2835_gpio.c
	===================================================================
	--- sys/arm/broadcom/bcm2835/bcm2835_gpio.c
	+++ sys/arm/broadcom/bcm2835/bcm2835_gpio.c
	@@ -609,7 +609,7 @@
	sc_sysctl->sc = sc;
	sc_sysctl->pin = sc->sc_gpio_pins[i].gp_pin;
	SYSCTL_ADD_PROC(ctx, pinN_tree, OID_AUTO, "function",
	- CTLFLAG_RW \| CTLTYPE_STRING, sc_sysctl,
	+ CTLFLAG_RW \| CTLTYPE_STRING \| CTLFLAG_NEEDGIANT, sc_sysctl,
	sizeof(struct bcm_gpio_sysctl), bcm_gpio_func_proc,
	"A", "Pin Function");
	}
	Index: sys/arm/broadcom/bcm2835/bcm2835_pwm.c
	===================================================================
	--- sys/arm/broadcom/bcm2835/bcm2835_pwm.c
	+++ sys/arm/broadcom/bcm2835/bcm2835_pwm.c
	@@ -364,8 +364,9 @@
	if (bootverbose) {
	#define RR(x,y) \
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, y, \
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, 0x##x, \
	- bcm_pwm_reg_proc, "IU", "Register 0x" #x " " y);
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, \
	+ sc, 0x##x, bcm_pwm_reg_proc, "IU", \
	+ "Register 0x" #x " " y);

	RR(24, "DAT2")
	RR(20, "RNG2")
	@@ -379,31 +380,31 @@
	}

	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "pwm_freq",
	- CTLFLAG_RD \| CTLTYPE_UINT, sc, 0,
	+ CTLFLAG_RD \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, 0,
	bcm_pwm_pwm_freq_proc, "IU", "PWM frequency ch 1 (Hz)");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "period",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, 0,
	bcm_pwm_period_proc, "IU", "PWM period ch 1 (#clocks)");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "ratio",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, 0,
	bcm_pwm_ratio_proc, "IU", "PWM ratio ch 1 (0...period)");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "freq",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, 0,
	bcm_pwm_freq_proc, "IU", "PWM clock (Hz)");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "mode",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, 0,
	bcm_pwm_mode_proc, "IU", "PWM mode ch 1 (0=off, 1=pwm, 2=dither)");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "pwm_freq2",
	- CTLFLAG_RD \| CTLTYPE_UINT, sc, 0,
	+ CTLFLAG_RD \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, 0,
	bcm_pwm_pwm_freq2_proc, "IU", "PWM frequency ch 2 (Hz)");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "period2",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, 0,
	bcm_pwm_period2_proc, "IU", "PWM period ch 2 (#clocks)");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "ratio2",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, 0,
	bcm_pwm_ratio2_proc, "IU", "PWM ratio ch 2 (0...period)");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "mode2",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, 0,
	bcm_pwm_mode2_proc, "IU", "PWM mode ch 2 (0=off, 1=pwm, 2=dither)");
	}

	Index: sys/arm/broadcom/bcm2835/bcm2835_rng.c
	===================================================================
	--- sys/arm/broadcom/bcm2835/bcm2835_rng.c
	+++ sys/arm/broadcom/bcm2835/bcm2835_rng.c
	@@ -403,14 +403,14 @@
	"underrun", CTLFLAG_RD, &sc->sc_underrun,
	"Number of FIFO underruns");
	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
	- "2xspeed", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "2xspeed", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	sysctl_bcm2835_rng_2xspeed, "I", "Enable RBG 2X SPEED");
	SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
	"stall_count", CTLFLAG_RW, &sc->sc_stall_count,
	RNG_STALL_COUNT_DEFAULT, "Number of underruns to assume RNG stall");
	#ifdef BCM2835_RNG_DEBUG_REGISTERS
	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
	- "dumpregs", CTLTYPE_STRING \| CTLFLAG_RD, sc, 0,
	+ "dumpregs", CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, 0,
	sysctl_bcm2835_rng_dump, "S", "Dump RNG registers");
	#endif

	Index: sys/arm/broadcom/bcm2835/bcm2835_spi.c
	===================================================================
	--- sys/arm/broadcom/bcm2835/bcm2835_spi.c
	+++ sys/arm/broadcom/bcm2835/bcm2835_spi.c
	@@ -204,22 +204,22 @@
	tree_node = device_get_sysctl_tree(sc->sc_dev);
	tree = SYSCTL_CHILDREN(tree_node);
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "clock",
	- CTLFLAG_RD \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RD \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, sizeof(*sc),
	bcm_spi_clock_proc, "IU", "SPI BUS clock frequency");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "cpol",
	- CTLFLAG_RD \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RD \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, sizeof(*sc),
	bcm_spi_cpol_proc, "IU", "SPI BUS clock polarity");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "cpha",
	- CTLFLAG_RD \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RD \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, sizeof(*sc),
	bcm_spi_cpha_proc, "IU", "SPI BUS clock phase");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "cspol0",
	- CTLFLAG_RD \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RD \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, sizeof(*sc),
	bcm_spi_cspol0_proc, "IU", "SPI BUS chip select 0 polarity");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "cspol1",
	- CTLFLAG_RD \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RD \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, sizeof(*sc),
	bcm_spi_cspol1_proc, "IU", "SPI BUS chip select 1 polarity");
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "cspol2",
	- CTLFLAG_RD \| CTLTYPE_UINT, sc, sizeof(*sc),
	+ CTLFLAG_RD \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, sizeof(*sc),
	bcm_spi_cspol2_proc, "IU", "SPI BUS chip select 2 polarity");
	}

	Index: sys/arm/freescale/imx/imx6_anatop.c
	===================================================================
	--- sys/arm/freescale/imx/imx6_anatop.c
	+++ sys/arm/freescale/imx/imx6_anatop.c
	@@ -400,11 +400,13 @@
	"CPU frequency");

	SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_imx),
	- OID_AUTO, "cpu_minmhz", CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NOFETCH,
	+ OID_AUTO, "cpu_minmhz",
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NOFETCH \| CTLFLAG_NEEDGIANT,
	sc, 0, cpufreq_sysctl_minmhz, "IU", "Minimum CPU frequency");

	SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_imx),
	- OID_AUTO, "cpu_maxmhz", CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NOFETCH,
	+ OID_AUTO, "cpu_maxmhz",
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NOFETCH \| CTLFLAG_NEEDGIANT,
	sc, 0, cpufreq_sysctl_maxmhz, "IU", "Maximum CPU frequency");

	SYSCTL_ADD_INT(NULL, SYSCTL_STATIC_CHILDREN(_hw_imx),
	@@ -627,10 +629,12 @@
	0, tempmon_throttle_check, sc, 0);

	SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_imx),
	- OID_AUTO, "temperature", CTLTYPE_INT \| CTLFLAG_RD, sc, 0,
	+ OID_AUTO, "temperature",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, 0,
	temp_sysctl_handler, "IK", "Current die temperature");
	SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_imx),
	- OID_AUTO, "throttle_temperature", CTLTYPE_INT \| CTLFLAG_RW, sc,
	+ OID_AUTO, "throttle_temperature",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc,
	0, temp_throttle_sysctl_handler, "IK",
	"Throttle CPU when exceeding this temperature");
	}
	Index: sys/arm/mv/mv_thermal.c
	===================================================================
	--- sys/arm/mv/mv_thermal.c
	+++ sys/arm/mv/mv_thermal.c
	@@ -333,7 +333,7 @@
	oid = SYSCTL_CHILDREN(device_get_sysctl_tree(dev));
	/* There is always at least one sensor */
	SYSCTL_ADD_PROC(ctx, oid, OID_AUTO, "internal",
	- CTLTYPE_INT \| CTLFLAG_RD,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev, 0, mv_thermal_sysctl,
	"IK",
	"Internal Temperature");
	@@ -342,7 +342,7 @@
	snprintf(name, sizeof(name), "cpu%d", i);
	snprintf(desc, sizeof(desc), "CPU%d Temperature", i);
	SYSCTL_ADD_PROC(ctx, oid, OID_AUTO, name,
	- CTLTYPE_INT \| CTLFLAG_RD,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev, i + 1, mv_thermal_sysctl,
	"IK",
	desc);
	Index: sys/arm/mv/mv_ts.c
	===================================================================
	--- sys/arm/mv/mv_ts.c
	+++ sys/arm/mv/mv_ts.c
	@@ -150,7 +150,8 @@
	}
	ctx = device_get_sysctl_ctx(dev);
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "temperature", CTLTYPE_INT \| CTLFLAG_RD, dev,
	+ OID_AUTO, "temperature",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, dev,
	0, ts_sysctl_handler, "IK", "Current Temperature");

	return (0);
	Index: sys/arm/nvidia/tegra_soctherm.c
	===================================================================
	--- sys/arm/nvidia/tegra_soctherm.c
	+++ sys/arm/nvidia/tegra_soctherm.c
	@@ -519,7 +519,7 @@
	for (i = sc->ntsensors - 1; i >= 0; i--) {
	tmp = SYSCTL_ADD_PROC(&soctherm_sysctl_ctx,
	SYSCTL_CHILDREN(oid), OID_AUTO, sc->tsensors[i].name,
	- CTLTYPE_INT \| CTLFLAG_RD, sc, i,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, i,
	soctherm_sysctl_temperature, "IK", "SoC Temperature");
	if (tmp == NULL)
	return (ENXIO);
	Index: sys/arm/ti/am335x/am335x_ehrpwm.c
	===================================================================
	--- sys/arm/ti/am335x/am335x_ehrpwm.c
	+++ sys/arm/ti/am335x/am335x_ehrpwm.c
	@@ -589,23 +589,23 @@
	tree = device_get_sysctl_tree(sc->sc_dev);

	sc->sc_clkdiv_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "clkdiv", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "clkdiv", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	am335x_ehrpwm_sysctl_clkdiv, "I", "PWM clock prescaler");

	sc->sc_freq_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "freq", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "freq", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	am335x_ehrpwm_sysctl_freq, "I", "PWM frequency");

	sc->sc_period_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "period", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "period", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	am335x_ehrpwm_sysctl_period, "I", "PWM period");

	sc->sc_chanA_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "dutyA", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "dutyA", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	am335x_ehrpwm_sysctl_duty, "I", "Channel A duty cycles");

	sc->sc_chanB_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "dutyB", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "dutyB", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	am335x_ehrpwm_sysctl_duty, "I", "Channel B duty cycles");

	/* CONFIGURE EPWM1 */
	Index: sys/arm/ti/am335x/am335x_lcd.c
	===================================================================
	--- sys/arm/ti/am335x/am335x_lcd.c
	+++ sys/arm/ti/am335x/am335x_lcd.c
	@@ -1025,8 +1025,8 @@
	ctx = device_get_sysctl_ctx(sc->sc_dev);
	tree = device_get_sysctl_tree(sc->sc_dev);
	sc->sc_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "backlight", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	- am335x_lcd_sysctl_backlight, "I", "LCD backlight");
	+ "backlight", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, 0, am335x_lcd_sysctl_backlight, "I", "LCD backlight");
	sc->sc_backlight = 0;
	/* Check if eCAS interface is available at this point */
	if (am335x_pwm_config_ecap(PWM_UNIT,
	Index: sys/arm/ti/cpsw/if_cpsw.c
	===================================================================
	--- sys/arm/ti/cpsw/if_cpsw.c
	+++ sys/arm/ti/cpsw/if_cpsw.c
	@@ -2725,11 +2725,13 @@
	CTLFLAG_RW, &sc->debug, 0, "Enable switch debug messages");

	SYSCTL_ADD_PROC(ctx, parent, OID_AUTO, "attachedSecs",
	- CTLTYPE_UINT \| CTLFLAG_RD, sc, 0, cpsw_stat_attached, "IU",
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ sc, 0, cpsw_stat_attached, "IU",
	"Time since driver attach");

	SYSCTL_ADD_PROC(ctx, parent, OID_AUTO, "intr_coalesce_us",
	- CTLTYPE_UINT \| CTLFLAG_RW, sc, 0, cpsw_intr_coalesce, "IU",
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, 0, cpsw_intr_coalesce, "IU",
	"minimum time between interrupts");

	node = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "ports",
	@@ -2744,7 +2746,7 @@
	port, CTLFLAG_RD, NULL, "CPSW Port Statistics");
	port_parent = SYSCTL_CHILDREN(node);
	SYSCTL_ADD_PROC(ctx, port_parent, OID_AUTO, "uptime",
	- CTLTYPE_UINT \| CTLFLAG_RD, sc, i,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, i,
	cpsw_stat_uptime, "IU", "Seconds since driver init");
	}

	@@ -2754,8 +2756,8 @@
	for (i = 0; i < CPSW_SYSCTL_COUNT; ++i) {
	SYSCTL_ADD_PROC(ctx, stats_parent, i,
	cpsw_stat_sysctls[i].oid,
	- CTLTYPE_U64 \| CTLFLAG_RD, sc, 0,
	- cpsw_stats_sysctl, "IU",
	+ CTLTYPE_U64 \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ sc, 0, cpsw_stats_sysctl, "IU",
	cpsw_stat_sysctls[i].oid);
	}

	Index: sys/arm/ti/ti_adc.c
	===================================================================
	--- sys/arm/ti/ti_adc.c
	+++ sys/arm/ti/ti_adc.c
	@@ -562,7 +562,7 @@
	tree_node = device_get_sysctl_tree(sc->sc_dev);
	tree = SYSCTL_CHILDREN(tree_node);
	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "clockdiv",
	- CTLFLAG_RW \| CTLTYPE_UINT, sc, 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, sc, 0,
	ti_adc_clockdiv_proc, "IU", "ADC clock prescaler");
	inp_node = SYSCTL_ADD_NODE(ctx, tree, OID_AUTO, "ain",
	CTLFLAG_RD, NULL, "ADC inputs");
	@@ -577,13 +577,16 @@
	inpN_tree = SYSCTL_CHILDREN(inpN_node);

	SYSCTL_ADD_PROC(ctx, inpN_tree, OID_AUTO, "enable",
	- CTLFLAG_RW \| CTLTYPE_UINT, &ti_adc_inputs[ain], 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT,
	+ &ti_adc_inputs[ain], 0,
	ti_adc_enable_proc, "IU", "Enable ADC input");
	SYSCTL_ADD_PROC(ctx, inpN_tree, OID_AUTO, "open_delay",
	- CTLFLAG_RW \| CTLTYPE_UINT, &ti_adc_inputs[ain], 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT,
	+ &ti_adc_inputs[ain], 0,
	ti_adc_open_delay_proc, "IU", "ADC open delay");
	SYSCTL_ADD_PROC(ctx, inpN_tree, OID_AUTO, "samples_avg",
	- CTLFLAG_RW \| CTLTYPE_UINT, &ti_adc_inputs[ain], 0,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT,
	+ &ti_adc_inputs[ain], 0,
	ti_adc_samples_avg_proc, "IU", "ADC samples average");
	SYSCTL_ADD_INT(ctx, inpN_tree, OID_AUTO, "input",
	CTLFLAG_RD, &ti_adc_inputs[ain].value, 0,
	Index: sys/arm/ti/ti_pruss.c
	===================================================================
	--- sys/arm/ti/ti_pruss.c
	+++ sys/arm/ti/ti_pruss.c
	@@ -545,7 +545,8 @@
	OID_AUTO, "irq", CTLFLAG_RD, 0,
	"PRUSS Host Interrupts");
	SYSCTL_ADD_PROC(clist, SYSCTL_CHILDREN(poid), OID_AUTO,
	- "global_interrupt_enable", CTLFLAG_RW \| CTLTYPE_U8,
	+ "global_interrupt_enable",
	+ CTLFLAG_RW \| CTLTYPE_U8 \| CTLFLAG_NEEDGIANT,
	sc, 0, ti_pruss_global_interrupt_enable,
	"CU", "Global interrupt enable");

	@@ -567,13 +568,17 @@
	OID_AUTO, name, CTLFLAG_RD, 0,
	"PRUSS Interrupts");
	SYSCTL_ADD_PROC(clist, SYSCTL_CHILDREN(irq_nodes), OID_AUTO,
	- "channel", CTLFLAG_RW \| CTLTYPE_STRING, sc, i, ti_pruss_channel_map,
	+ "channel",
	+ CTLFLAG_RW \| CTLTYPE_STRING \| CTLFLAG_NEEDGIANT,
	+ sc, i, ti_pruss_channel_map,
	"A", "Channel attached to this irq");
	SYSCTL_ADD_PROC(clist, SYSCTL_CHILDREN(irq_nodes), OID_AUTO,
	- "event", CTLFLAG_RW \| CTLTYPE_STRING, sc, i, ti_pruss_event_map,
	+ "event", CTLFLAG_RW \| CTLTYPE_STRING \| CTLFLAG_NEEDGIANT,
	+ sc, i, ti_pruss_event_map,
	"A", "Event attached to this irq");
	SYSCTL_ADD_PROC(clist, SYSCTL_CHILDREN(irq_nodes), OID_AUTO,
	- "enable", CTLFLAG_RW \| CTLTYPE_U8, sc, i, ti_pruss_interrupt_enable,
	+ "enable", CTLFLAG_RW \| CTLTYPE_U8 \| CTLFLAG_NEEDGIANT,
	+ sc, i, ti_pruss_interrupt_enable,
	"CU", "Enable/Disable interrupt");

	sc->sc_irq_devs[i].event = -1;
	Index: sys/arm/ti/twl/twl_clks.c
	===================================================================
	--- sys/arm/ti/twl/twl_clks.c
	+++ sys/arm/ti/twl/twl_clks.c
	@@ -471,7 +471,7 @@

	/* Add a sysctl entry for the clock */
	new->oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, name,
	- CTLTYPE_INT \| CTLFLAG_RD, sc, 0,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, 0,
	twl_clks_sysctl_clock, "I", "external clock");

	/* Finally add the regulator to list of supported regulators */
	Index: sys/arm/ti/twl/twl_vreg.c
	===================================================================
	--- sys/arm/ti/twl/twl_vreg.c
	+++ sys/arm/ti/twl/twl_vreg.c
	@@ -848,7 +848,7 @@

	/* Add a sysctl entry for the voltage */
	new->oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, name,
	- CTLTYPE_INT \| CTLFLAG_RD, sc, 0,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, 0,
	twl_vreg_sysctl_voltage, "I", "voltage regulator");

	/* Finally add the regulator to list of supported regulators */
	Index: sys/arm/xilinx/zy7_devcfg.c
	===================================================================
	--- sys/arm/xilinx/zy7_devcfg.c
	+++ sys/arm/xilinx/zy7_devcfg.c
	@@ -105,8 +105,10 @@
	"Xilinx Zynq-7000 PL (FPGA) section");

	static int zy7_devcfg_sysctl_pl_done(SYSCTL_HANDLER_ARGS);
	-SYSCTL_PROC(_hw_fpga, OID_AUTO, pl_done, CTLTYPE_INT \| CTLFLAG_RD, NULL, 0,
	- zy7_devcfg_sysctl_pl_done, "I", "PL section config DONE signal");
	+SYSCTL_PROC(_hw_fpga, OID_AUTO, pl_done,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, NULL, 0,
	+ zy7_devcfg_sysctl_pl_done, "I",
	+ "PL section config DONE signal");

	static int zy7_en_level_shifters = 1;
	SYSCTL_INT(_hw_fpga, OID_AUTO, en_level_shifters, CTLFLAG_RW,
	@@ -119,9 +121,9 @@

	static int zy7_devcfg_fclk_sysctl_level_shifters(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_hw_fpga, OID_AUTO, level_shifters,
	- CTLFLAG_RW \| CTLTYPE_INT,
	- NULL, 0, zy7_devcfg_fclk_sysctl_level_shifters,
	- "I", "Enable/disable level shifters");
	+ CTLFLAG_RW \| CTLTYPE_INT \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, zy7_devcfg_fclk_sysctl_level_shifters, "I",
	+ "Enable/disable level shifters");

	/* cdev entry points. */
	static int zy7_devcfg_open(struct cdev , int, int, struct thread );
	@@ -379,13 +381,13 @@
	"Actual frequency");
	SYSCTL_ADD_PROC(&sc->sysctl_tree,
	SYSCTL_CHILDREN(fclk_node), OID_AUTO,
	- "freq", CTLFLAG_RW \| CTLTYPE_INT,
	+ "freq", CTLFLAG_RW \| CTLTYPE_INT \| CTLFLAG_NEEDGIANT,
	&fclk_configs[i], i,
	zy7_devcfg_fclk_sysctl_freq,
	"I", "Configured frequency");
	SYSCTL_ADD_PROC(&sc->sysctl_tree,
	SYSCTL_CHILDREN(fclk_node), OID_AUTO,
	- "source", CTLFLAG_RW \| CTLTYPE_STRING,
	+ "source", CTLFLAG_RW \| CTLTYPE_STRING \| CTLFLAG_NEEDGIANT,
	&fclk_configs[i], i,
	zy7_devcfg_fclk_sysctl_source,
	"A", "Clock source");
	Index: sys/arm64/rockchip/rk_tsadc.c
	===================================================================
	--- sys/arm64/rockchip/rk_tsadc.c
	+++ sys/arm64/rockchip/rk_tsadc.c
	@@ -566,7 +566,7 @@
	for (i = sc->conf->ntsensors - 1; i >= 0; i--) {
	tmp = SYSCTL_ADD_PROC(&tsadc_sysctl_ctx,
	SYSCTL_CHILDREN(oid), OID_AUTO, sc->conf->tsensors[i].name,
	- CTLTYPE_INT \| CTLFLAG_RD, sc, i,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, i,
	tsadc_sysctl_temperature, "IK", "SoC Temperature");
	if (tmp == NULL)
	return (ENXIO);
	Index: sys/cam/ata/ata_da.c
	===================================================================
	--- sys/cam/ata/ata_da.c
	+++ sys/cam/ata/ata_da.c
	@@ -1459,7 +1459,8 @@
	}

	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "delete_method", CTLTYPE_STRING \| CTLFLAG_RW,
	+ OID_AUTO, "delete_method",
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	softc, 0, adadeletemethodsysctl, "A",
	"BIO_DELETE execution method");
	SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
	@@ -1487,11 +1488,13 @@
	OID_AUTO, "rotating", CTLFLAG_RD \| CTLFLAG_MPSAFE,
	&softc->rotating, 0, "Rotating media");
	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "zone_mode", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "zone_mode",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	softc, 0, adazonemodesysctl, "A",
	"Zone Mode");
	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "zone_support", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "zone_support",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	softc, 0, adazonesupsysctl, "A",
	"Zone Support");
	SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
	Index: sys/cam/cam_iosched.c
	===================================================================
	--- sys/cam/cam_iosched.c
	+++ sys/cam/cam_iosched.c
	@@ -1015,7 +1015,8 @@
	"# of transactions completed with an error");

	SYSCTL_ADD_PROC(ctx, n,
	- OID_AUTO, "limiter", CTLTYPE_STRING \| CTLFLAG_RW,
	+ OID_AUTO, "limiter",
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	ios, 0, cam_iosched_limiter_sysctl, "A",
	"Current limiting type.");
	SYSCTL_ADD_INT(ctx, n,
	@@ -1032,7 +1033,8 @@
	"current resource");

	SYSCTL_ADD_PROC(ctx, n,
	- OID_AUTO, "latencies", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "latencies",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&ios->latencies, 0,
	cam_iosched_sysctl_latencies, "A",
	"Array of power of 2 latency from 1ms to 1.024s");
	@@ -1061,19 +1063,23 @@
	ctx = &clp->sysctl_ctx;

	SYSCTL_ADD_PROC(ctx, n,
	- OID_AUTO, "type", CTLTYPE_STRING \| CTLFLAG_RW,
	+ OID_AUTO, "type",
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	clp, 0, cam_iosched_control_type_sysctl, "A",
	"Control loop algorithm");
	SYSCTL_ADD_PROC(ctx, n,
	- OID_AUTO, "steer_interval", CTLTYPE_STRING \| CTLFLAG_RW,
	+ OID_AUTO, "steer_interval",
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&clp->steer_interval, 0, cam_iosched_sbintime_sysctl, "A",
	"How often to steer (in us)");
	SYSCTL_ADD_PROC(ctx, n,
	- OID_AUTO, "lolat", CTLTYPE_STRING \| CTLFLAG_RW,
	+ OID_AUTO, "lolat",
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&clp->lolat, 0, cam_iosched_sbintime_sysctl, "A",
	"Low water mark for Latency (in us)");
	SYSCTL_ADD_PROC(ctx, n,
	- OID_AUTO, "hilat", CTLTYPE_STRING \| CTLFLAG_RW,
	+ OID_AUTO, "hilat",
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&clp->hilat, 0, cam_iosched_sbintime_sysctl, "A",
	"Hi water mark for Latency (in us)");
	SYSCTL_ADD_INT(ctx, n,
	@@ -1201,7 +1207,8 @@
	"How biased towards read should we be independent of limits");

	SYSCTL_ADD_PROC(ctx, n,
	- OID_AUTO, "quanta", CTLTYPE_UINT \| CTLFLAG_RW,
	+ OID_AUTO, "quanta",
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&isc->quanta, 0, cam_iosched_quanta_sysctl, "I",
	"How many quanta per second do we slice the I/O up into");

	Index: sys/cam/ctl/ctl.c
	===================================================================
	--- sys/cam/ctl/ctl.c
	+++ sys/cam/ctl/ctl.c
	@@ -1986,7 +1986,8 @@
	}

	SYSCTL_ADD_PROC(&softc->sysctl_ctx,SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "ha_role", CTLTYPE_INT \| CTLFLAG_RWTUN,
	+ OID_AUTO, "ha_role",
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	softc, 0, ctl_ha_role_sysctl, "I", "HA role for this head");

	if (softc->is_single == 0) {
	Index: sys/cam/ctl/ctl_ha.c
	===================================================================
	--- sys/cam/ctl/ctl_ha.c
	+++ sys/cam/ctl/ctl_ha.c
	@@ -957,7 +957,8 @@
	ctl_ha_msg_shutdown, ctl_softc, SHUTDOWN_PRI_FIRST);
	SYSCTL_ADD_PROC(&ctl_softc->sysctl_ctx,
	SYSCTL_CHILDREN(ctl_softc->sysctl_tree),
	- OID_AUTO, "ha_peer", CTLTYPE_STRING \| CTLFLAG_RWTUN,
	+ OID_AUTO, "ha_peer",
	+ CTLTYPE_STRING \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	softc, 0, ctl_ha_peer_sysctl, "A", "HA peer connection method");

	if (ctl_ha_msg_register(CTL_HA_CHAN_DATA, ctl_dt_event_handler)
	Index: sys/cam/scsi/scsi_all.c
	===================================================================
	--- sys/cam/scsi/scsi_all.c
	+++ sys/cam/scsi/scsi_all.c
	@@ -9234,7 +9234,8 @@
	return (error);
	return (set_scsi_delay(delay));
	}
	-SYSCTL_PROC(_kern_cam, OID_AUTO, scsi_delay, CTLTYPE_INT\|CTLFLAG_RW,
	+SYSCTL_PROC(_kern_cam, OID_AUTO, scsi_delay,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_scsi_delay, "I",
	"Delay to allow devices to settle after a SCSI bus reset (ms)");

	Index: sys/cam/scsi/scsi_cd.c
	===================================================================
	--- sys/cam/scsi/scsi_cd.c
	+++ sys/cam/scsi/scsi_cd.c
	@@ -536,7 +536,8 @@
	* the fly.
	*/
	SYSCTL_ADD_PROC(&softc->sysctl_ctx,SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "minimum_cmd_size", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "minimum_cmd_size",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&softc->minimum_command_size, 0, cdcmdsizesysctl, "I",
	"Minimum CDB size");

	Index: sys/cam/scsi/scsi_da.c
	===================================================================
	--- sys/cam/scsi/scsi_da.c
	+++ sys/cam/scsi/scsi_da.c
	@@ -1538,7 +1538,8 @@
	"Disable detection of write-protected disks");

	SYSCTL_PROC(_kern_cam_da, OID_AUTO, default_softtimeout,
	- CTLTYPE_UINT \| CTLFLAG_RW, NULL, 0, dasysctlsofttimeout, "I",
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, dasysctlsofttimeout, "I",
	"Soft I/O timeout (ms)");
	TUNABLE_INT64("kern.cam.da.default_softtimeout", &da_default_softtimeout);

	@@ -2233,15 +2234,18 @@
	* the fly.
	*/
	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "delete_method", CTLTYPE_STRING \| CTLFLAG_RWTUN,
	+ OID_AUTO, "delete_method",
	+ CTLTYPE_STRING \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	softc, 0, dadeletemethodsysctl, "A",
	"BIO_DELETE execution method");
	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "delete_max", CTLTYPE_U64 \| CTLFLAG_RW,
	+ OID_AUTO, "delete_max",
	+ CTLTYPE_U64 \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	softc, 0, dadeletemaxsysctl, "Q",
	"Maximum BIO_DELETE size");
	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "minimum_cmd_size", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "minimum_cmd_size",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&softc->minimum_cmd_size, 0, dacmdsizesysctl, "I",
	"Minimum CDB size");
	SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
	@@ -2258,11 +2262,13 @@
	"Total lbas in the unmap/dsm commands sent");

	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "zone_mode", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "zone_mode",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	softc, 0, dazonemodesysctl, "A",
	"Zone Mode");
	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "zone_support", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "zone_support",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	softc, 0, dazonesupsysctl, "A",
	"Zone Support");
	SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
	Index: sys/cam/scsi/scsi_xpt.c
	===================================================================
	--- sys/cam/scsi/scsi_xpt.c
	+++ sys/cam/scsi/scsi_xpt.c
	@@ -80,7 +80,8 @@

	static int cam_srch_hi = 0;
	static int sysctl_cam_search_luns(SYSCTL_HANDLER_ARGS);
	-SYSCTL_PROC(_kern_cam, OID_AUTO, cam_srch_hi, CTLTYPE_INT \| CTLFLAG_RWTUN, 0, 0,
	+SYSCTL_PROC(_kern_cam, OID_AUTO, cam_srch_hi,
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT, 0, 0,
	sysctl_cam_search_luns, "I",
	"allow search above LUN 7 for SCSI3 and greater devices");

	Index: sys/compat/ndis/subr_ntoskrnl.c
	===================================================================
	--- sys/compat/ndis/subr_ntoskrnl.c
	+++ sys/compat/ndis/subr_ntoskrnl.c
	@@ -82,7 +82,8 @@
	#ifdef NTOSKRNL_DEBUG_TIMERS
	static int sysctl_show_timers(SYSCTL_HANDLER_ARGS);

	-SYSCTL_PROC(_debug, OID_AUTO, ntoskrnl_timers, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_debug, OID_AUTO, ntoskrnl_timers,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	NULL, 0, sysctl_show_timers, "I",
	"Show ntoskrnl timer stats");
	#endif
	Index: sys/contrib/ipfilter/netinet/mlfk_ipl.c
	===================================================================
	--- sys/contrib/ipfilter/netinet/mlfk_ipl.c
	+++ sys/contrib/ipfilter/netinet/mlfk_ipl.c
	@@ -83,20 +83,25 @@

	SYSCTL_DECL(_net_inet);
	#define SYSCTL_IPF(parent, nbr, name, access, ptr, val, descr) \
	- SYSCTL_OID(parent, nbr, name, CTLTYPE_INT\|CTLFLAG_VNET\|access, \
	- ptr, val, sysctl_ipf_int, "I", descr)
	+ SYSCTL_OID(parent, nbr, name, \
	+ CTLTYPE_INT \| CTLFLAG_VNET \| access \| CTLFLAG_NEEDGIANT, \
	+ ptr, val, sysctl_ipf_int, "I", descr)
	#define SYSCTL_DYN_IPF_NAT(parent, nbr, name, access,ptr, val, descr) \
	SYSCTL_ADD_OID(&ipf_clist, SYSCTL_STATIC_CHILDREN(parent), nbr, name, \
	- CTLFLAG_DYN\|CTLTYPE_INT\|CTLFLAG_VNET\|access, ptr, val, sysctl_ipf_int_nat, "I", descr)
	+ CTLFLAG_DYN \| CTLTYPE_INT \| CTLFLAG_VNET \| access \| CTLFLAG_NEEDGIANT, \
	+ ptr, val, sysctl_ipf_int_nat, "I", descr)
	#define SYSCTL_DYN_IPF_STATE(parent, nbr, name, access,ptr, val, descr) \
	SYSCTL_ADD_OID(&ipf_clist, SYSCTL_STATIC_CHILDREN(parent), nbr, name, \
	- CTLFLAG_DYN\|CTLTYPE_INT\|CTLFLAG_VNET\|access, ptr, val, sysctl_ipf_int_state, "I", descr)
	+ CTLFLAG_DYN \| CTLTYPE_INT \| CTLFLAG_VNET \| access \| CTLFLAG_NEEDGIANT, \
	+ ptr, val, sysctl_ipf_int_state, "I", descr)
	#define SYSCTL_DYN_IPF_FRAG(parent, nbr, name, access,ptr, val, descr) \
	SYSCTL_ADD_OID(&ipf_clist, SYSCTL_STATIC_CHILDREN(parent), nbr, name, \
	- CTLFLAG_DYN\|CTLTYPE_INT\|CTLFLAG_VNET\|access, ptr, val, sysctl_ipf_int_frag, "I", descr)
	+ CTLFLAG_DYN \| CTLTYPE_INT \| CTLFLAG_VNET \| access \| CTLFLAG_NEEDGIANT, \
	+ ptr, val, sysctl_ipf_int_frag, "I", descr)
	#define SYSCTL_DYN_IPF_AUTH(parent, nbr, name, access,ptr, val, descr) \
	SYSCTL_ADD_OID(&ipf_clist, SYSCTL_STATIC_CHILDREN(parent), nbr, name, \
	- CTLFLAG_DYN\|CTLTYPE_INT\|CTLFLAG_VNET\|access, ptr, val, sysctl_ipf_int_auth, "I", descr)
	+ CTLFLAG_DYN \| CTLTYPE_INT \| CTLFLAG_VNET \| access \| CTLFLAG_NEEDGIANT, \
	+ ptr, val, sysctl_ipf_int_auth, "I", descr)
	static struct sysctl_ctx_list ipf_clist;
	#define CTLFLAG_OFF 0x00800000 /* IPFilter must be disabled */
	#define CTLFLAG_RWO (CTLFLAG_RW\|CTLFLAG_OFF)
	Index: sys/ddb/db_capture.c
	===================================================================
	--- sys/ddb/db_capture.c
	+++ sys/ddb/db_capture.c
	@@ -165,7 +165,8 @@

	return (0);
	}
	-SYSCTL_PROC(_debug_ddb_capture, OID_AUTO, bufsize, CTLTYPE_UINT\|CTLFLAG_RW,
	+SYSCTL_PROC(_debug_ddb_capture, OID_AUTO, bufsize,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_debug_ddb_capture_bufsize, "IU",
	"Size of DDB capture buffer");

	@@ -191,7 +192,8 @@
	ch = '\0';
	return (SYSCTL_OUT(req, &ch, sizeof(ch)));
	}
	-SYSCTL_PROC(_debug_ddb_capture, OID_AUTO, data, CTLTYPE_STRING \| CTLFLAG_RD,
	+SYSCTL_PROC(_debug_ddb_capture, OID_AUTO, data,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	NULL, 0, sysctl_debug_ddb_capture_data, "A", "DDB capture data");

	/*
	Index: sys/ddb/db_script.c
	===================================================================
	--- sys/ddb/db_script.c
	+++ sys/ddb/db_script.c
	@@ -495,8 +495,9 @@
	free(buffer, M_TEMP);
	return (error);
	}
	-SYSCTL_PROC(_debug_ddb_scripting, OID_AUTO, scripts, CTLTYPE_STRING \|
	- CTLFLAG_RD, 0, 0, sysctl_debug_ddb_scripting_scripts, "A",
	+SYSCTL_PROC(_debug_ddb_scripting, OID_AUTO, scripts,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_debug_ddb_scripting_scripts, "A",
	"List of defined scripts");

	static int
	@@ -532,8 +533,9 @@
	free(buffer, M_TEMP);
	return (error);
	}
	-SYSCTL_PROC(_debug_ddb_scripting, OID_AUTO, script, CTLTYPE_STRING \|
	- CTLFLAG_RW, 0, 0, sysctl_debug_ddb_scripting_script, "A",
	+SYSCTL_PROC(_debug_ddb_scripting, OID_AUTO, script,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_debug_ddb_scripting_script, "A",
	"Set a script");

	/*
	@@ -559,6 +561,7 @@
	return (EINVAL); /* Don't confuse sysctl consumers. */
	return (0);
	}
	-SYSCTL_PROC(_debug_ddb_scripting, OID_AUTO, unscript, CTLTYPE_STRING \|
	- CTLFLAG_RW, 0, 0, sysctl_debug_ddb_scripting_unscript, "A",
	+SYSCTL_PROC(_debug_ddb_scripting, OID_AUTO, unscript,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_debug_ddb_scripting_unscript, "A",
	"Unset a script");
	Index: sys/dev/acpi_support/acpi_asus.c
	===================================================================
	--- sys/dev/acpi_support/acpi_asus.c
	+++ sys/dev/acpi_support/acpi_asus.c
	@@ -742,14 +742,15 @@
	SYSCTL_ADD_PROC(&sc->sysctl_ctx,
	SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
	acpi_asus_sysctls[i].name,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_ANYBODY,
	+ 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);
	}
	Index: sys/dev/acpi_support/acpi_asus_wmi.c
	===================================================================
	--- sys/dev/acpi_support/acpi_asus_wmi.c
	+++ sys/dev/acpi_support/acpi_asus_wmi.c
	@@ -429,14 +429,14 @@
	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);
	}
	Index: sys/dev/acpi_support/acpi_fujitsu.c
	===================================================================
	--- sys/dev/acpi_support/acpi_fujitsu.c
	+++ sys/dev/acpi_support/acpi_fujitsu.c
	@@ -418,7 +418,8 @@
	SYSCTL_ADD_PROC(&sc->sysctl_ctx,
	SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
	sysctl_table[i].name,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_ANYBODY,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_ANYBODY \|
	+ CTLFLAG_NEEDGIANT,
	sc, i, acpi_fujitsu_sysctl, "I",
	sysctl_table[i].description);
	}
	Index: sys/dev/acpi_support/acpi_hp.c
	===================================================================
	--- sys/dev/acpi_support/acpi_hp.c
	+++ sys/dev/acpi_support/acpi_hp.c
	@@ -593,13 +593,15 @@
	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);
	}
	Index: sys/dev/acpi_support/acpi_ibm.c
	===================================================================
	--- sys/dev/acpi_support/acpi_ibm.c
	+++ sys/dev/acpi_support/acpi_ibm.c
	@@ -516,13 +516,15 @@
	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);
	}
	@@ -532,7 +534,8 @@
	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,
	+ "thermal",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, 0, acpi_ibm_thermal_sysctl, "I",
	"Thermal zones");
	}
	@@ -541,7 +544,8 @@
	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,
	+ "handlerevents",
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	sc, 0, acpi_ibm_handlerevents_sysctl, "I",
	"devd(8) events handled by acpi_ibm");
	}
	Index: sys/dev/acpi_support/acpi_panasonic.c
	===================================================================
	--- sys/dev/acpi_support/acpi_panasonic.c
	+++ sys/dev/acpi_support/acpi_panasonic.c
	@@ -173,7 +173,8 @@
	SYSCTL_ADD_PROC(&sc->sysctl_ctx,
	SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
	sysctl_table[i].name,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_ANYBODY,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_ANYBODY \|
	+ CTLFLAG_NEEDGIANT,
	sc, i, acpi_panasonic_sysctl, "I", "");
	}

	Index: sys/dev/acpi_support/acpi_rapidstart.c
	===================================================================
	--- sys/dev/acpi_support/acpi_rapidstart.c
	+++ sys/dev/acpi_support/acpi_rapidstart.c
	@@ -90,14 +90,14 @@
	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);
	}
	Index: sys/dev/acpi_support/acpi_sony.c
	===================================================================
	--- sys/dev/acpi_support/acpi_sony.c
	+++ sys/dev/acpi_support/acpi_sony.c
	@@ -137,14 +137,14 @@
	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);
	}
	Index: sys/dev/acpi_support/acpi_toshiba.c
	===================================================================
	--- sys/dev/acpi_support/acpi_toshiba.c
	+++ sys/dev/acpi_support/acpi_toshiba.c
	@@ -253,7 +253,8 @@
	SYSCTL_ADD_PROC(&sc->sysctl_ctx,
	SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
	sysctl_table[i].name,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_ANYBODY,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_ANYBODY \|
	+ CTLFLAG_NEEDGIANT,
	sc, i, acpi_toshiba_sysctl, "I", "");
	}

	Index: sys/dev/acpi_support/atk0110.c
	===================================================================
	--- sys/dev/acpi_support/atk0110.c
	+++ sys/dev/acpi_support/atk0110.c
	@@ -234,7 +234,8 @@
	#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);
	}
	Index: sys/dev/acpica/acpi.c
	===================================================================
	--- sys/dev/acpica/acpi.c
	+++ sys/dev/acpica/acpi.c
	@@ -269,7 +269,8 @@
	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. */
	@@ -553,26 +554,32 @@
	SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
	device_get_name(dev), CTLFLAG_RD, 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,
	@@ -3352,7 +3359,7 @@
	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");
	}
	}
	@@ -4125,10 +4132,14 @@
	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
	Index: sys/dev/acpica/acpi_acad.c
	===================================================================
	--- sys/dev/acpica/acpi_acad.c
	+++ sys/dev/acpica/acpi_acad.c
	@@ -171,7 +171,8 @@
	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,
	+ OID_AUTO, "acline",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&sc->status, 0, acpi_acad_sysctl, "I", "");
	}

	Index: sys/dev/acpica/acpi_battery.c
	===================================================================
	--- sys/dev/acpica/acpi_battery.c
	+++ sys/dev/acpica/acpi_battery.c
	@@ -477,27 +477,27 @@
	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),
	Index: sys/dev/acpica/acpi_cpu.c
	===================================================================
	--- sys/dev/acpica/acpi_cpu.c
	+++ sys/dev/acpica/acpi_cpu.c
	@@ -1023,7 +1023,7 @@

	/* 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");

	@@ -1068,23 +1068,27 @@
	"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,
	+ 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,
	+ 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,
	+ 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,
	+ OID_AUTO, "cx_method",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	(void *)sc, 0, acpi_cpu_method_sysctl, "A",
	"Cx entrance methods");
	#endif
	Index: sys/dev/acpica/acpi_dock.c
	===================================================================
	--- sys/dev/acpica/acpi_dock.c
	+++ sys/dev/acpica/acpi_dock.c
	@@ -515,7 +515,7 @@
	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");

	Index: sys/dev/acpica/acpi_thermal.c
	===================================================================
	--- sys/dev/acpica/acpi_thermal.c
	+++ sys/dev/acpica/acpi_thermal.c
	@@ -263,14 +263,17 @@
	SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
	OID_AUTO, oidname, CTLFLAG_RD, 0, "", "thermal_zone");
	SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
	- OID_AUTO, "temperature", CTLTYPE_INT \| CTLFLAG_RD,
	+ 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,
	+ 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,
	+ OID_AUTO, "passive_cooling",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	sc, 0, acpi_tz_cooling_sysctl, "I",
	"enable passive (speed reduction) cooling");

	@@ -278,35 +281,42 @@
	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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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");
	Index: sys/dev/acpica/acpi_timer.c
	===================================================================
	--- sys/dev/acpica/acpi_timer.c
	+++ sys/dev/acpica/acpi_timer.c
	@@ -368,8 +368,10 @@
	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
	Index: sys/dev/acpica/acpi_video.c
	===================================================================
	--- sys/dev/acpica/acpi_video.c
	+++ sys/dev/acpica/acpi_video.c
	@@ -544,33 +544,36 @@
	SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
	SYSCTL_CHILDREN(vo->vo_sysctl_tree),
	OID_AUTO, "active",
	- CTLTYPE_INT\|CTLFLAG_RW, vo, 0,
	+ 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,
	+ 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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ vo, 0,
	acpi_video_vo_levels_sysctl, "I",
	"supported brightness levels");
	} else
	Index: sys/dev/adb/adb_kbd.c
	===================================================================
	--- sys/dev/adb/adb_kbd.c
	+++ sys/dev/adb/adb_kbd.c
	@@ -370,7 +370,8 @@
	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");
	}
	Index: sys/dev/adb/adb_mouse.c
	===================================================================
	--- sys/dev/adb/adb_mouse.c
	+++ sys/dev/adb/adb_mouse.c
	@@ -330,7 +330,8 @@
	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,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, 0, adb_tapping_sysctl,
	"I", "Tapping the pad causes button events");
	return;
	}
	Index: sys/dev/age/if_age.c
	===================================================================
	--- sys/dev/age/if_age.c
	+++ sys/dev/age/if_age.c
	@@ -749,12 +749,14 @@

	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,
	+ "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,
	+ "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. */
	@@ -773,7 +775,9 @@

	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,
	+ "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");

	Index: sys/dev/ahci/ahci.c
	===================================================================
	--- sys/dev/ahci/ahci.c
	+++ sys/dev/ahci/ahci.c
	@@ -904,7 +904,8 @@
	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",
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT, ch, 0,
	+ ahci_ch_disablephy_proc, "IU",
	"Disable PHY");
	return (0);

	Index: sys/dev/aic7xxx/aic79xx_osm.c
	===================================================================
	--- sys/dev/aic7xxx/aic79xx_osm.c
	+++ sys/dev/aic7xxx/aic79xx_osm.c
	@@ -164,7 +164,8 @@
	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,
	+ OID_AUTO, "clear",
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, ahd,
	0, ahd_clear_allcounters, "IU",
	"Clear all counters");

	@@ -185,7 +186,8 @@
	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,
	+ CTLFLAG_RW \| CTLTYPE_UINT \| CTLFLAG_NEEDGIANT,
	+ ahd, i,
	ahd_set_debugcounters, "IU",
	ahd_sysctl_errors_descriptions[i]);
	}
	Index: sys/dev/alc/if_alc.c
	===================================================================
	--- sys/dev/alc/if_alc.c
	+++ sys/dev/alc/if_alc.c
	@@ -1747,10 +1747,12 @@
	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,
	+ 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,
	+ 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;
	@@ -1778,7 +1780,8 @@
	}
	}
	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "process_limit",
	- CTLTYPE_INT \| CTLFLAG_RW, &sc->alc_process_limit, 0,
	+ 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. */
	Index: sys/dev/ale/if_ale.c
	===================================================================
	--- sys/dev/ale/if_ale.c
	+++ sys/dev/ale/if_ale.c
	@@ -792,10 +792,12 @@
	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,
	+ 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,
	+ 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;
	@@ -823,7 +825,8 @@
	}
	}
	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "process_limit",
	- CTLTYPE_INT \| CTLFLAG_RW, &sc->ale_process_limit, 0,
	+ 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. */
	Index: sys/dev/altera/atse/if_atse.c
	===================================================================
	--- sys/dev/altera/atse/if_atse.c
	+++ sys/dev/altera/atse/if_atse.c
	@@ -1237,7 +1237,8 @@
	}

	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 @@
	}

	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);
	}
	Index: sys/dev/amd_ecc_inject/ecc_inject.c
	===================================================================
	--- sys/dev/amd_ecc_inject/ecc_inject.c
	+++ sys/dev/amd_ecc_inject/ecc_inject.c
	@@ -133,16 +133,16 @@
	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");
	Index: sys/dev/amdtemp/amdtemp.c
	===================================================================
	--- sys/dev/amdtemp/amdtemp.c
	+++ sys/dev/amdtemp/amdtemp.c
	@@ -481,14 +481,15 @@

	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");

	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");

	@@ -499,13 +500,15 @@

	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");
	}
	@@ -557,7 +560,8 @@
	(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");
	}
	Index: sys/dev/an/if_an.c
	===================================================================
	--- sys/dev/an/if_an.c
	+++ sys/dev/an/if_an.c
	@@ -266,8 +266,10 @@
	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 @@
	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
	Index: sys/dev/asmc/asmc.c
	===================================================================
	--- sys/dev/asmc/asmc.c
	+++ sys/dev/asmc/asmc.c
	@@ -503,41 +503,43 @@

	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");
	}
	@@ -553,7 +555,7 @@
	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]);
	}
	@@ -568,20 +570,23 @@

	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,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_ANYBODY \|
	+ CTLFLAG_NEEDGIANT,
	dev, 0, model->smc_light_control, "I",
	"Keyboard backlight brightness control");
	}
	@@ -598,19 +603,19 @@

	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");

	Index: sys/dev/ath/ah_osdep.c
	===================================================================
	--- sys/dev/ath/ah_osdep.c
	+++ sys/dev/ath/ah_osdep.c
	@@ -236,8 +236,10 @@
	else
	return (ath_hal_setlogging(enable));
	}
	-SYSCTL_PROC(_hw_ath_hal, OID_AUTO, alq, CTLTYPE_INT\|CTLFLAG_RW,
	- 0, 0, sysctl_hw_ath_hal_log, "I", "Enable HAL register logging");
	+SYSCTL_PROC(_hw_ath_hal, OID_AUTO, alq,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_hw_ath_hal_log, "I",
	+ "Enable HAL register logging");
	SYSCTL_INT(_hw_ath_hal, OID_AUTO, alq_size, CTLFLAG_RW,
	&ath_hal_alq_qsize, 0, "In-memory log size (#records)");
	SYSCTL_INT(_hw_ath_hal, OID_AUTO, alq_lost, CTLFLAG_RW,
	Index: sys/dev/ath/ath_rate/sample/sample.c
	===================================================================
	--- sys/dev/ath/ath_rate/sample/sample.c
	+++ sys/dev/ath/ath_rate/sample/sample.c
	@@ -1364,16 +1364,18 @@
	struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "smoothing_rate", CTLTYPE_INT \| CTLFLAG_RW, ssc, 0,
	+ "smoothing_rate",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, ssc, 0,
	ath_rate_sysctl_smoothing_rate, "I",
	"sample: smoothing rate for avg tx time (%%)");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "sample_rate", CTLTYPE_INT \| CTLFLAG_RW, ssc, 0,
	+ "sample_rate", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, ssc, 0,
	ath_rate_sysctl_sample_rate, "I",
	"sample: percent air time devoted to sampling new rates (%%)");
	/* XXX max_successive_failures, stale_failure_timeout, min_switch */
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "sample_stats", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "sample_stats",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_rate_sysctl_stats, "I", "sample: print statistics");
	}

	Index: sys/dev/ath/if_ath_sysctl.c
	===================================================================
	--- sys/dev/ath/if_ath_sysctl.c
	+++ sys/dev/ath/if_ath_sysctl.c
	@@ -794,7 +794,8 @@
	CTLFLAG_RW, sc->sc_alq.sc_alq_filename, 0, "ALQ filename");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "enable", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "enable", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, 0,
	ath_sysctl_alq_log, "I", "");

	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	@@ -831,20 +832,25 @@
	"control debugging KTR");
	#endif /* ATH_DEBUG_ALQ */
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "slottime", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "slottime",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_slottime, "I", "802.11 slot time (us)");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "acktimeout", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "acktimeout",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_acktimeout, "I", "802.11 ACK timeout (us)");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "ctstimeout", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "ctstimeout",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_ctstimeout, "I", "802.11 CTS timeout (us)");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "softled", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "softled",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_softled, "I", "enable/disable software LED support");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "ledpin", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "ledpin",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_ledpin, "I", "GPIO pin connected to LED");
	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	"ledon", CTLFLAG_RW, &sc->sc_ledon, 0,
	@@ -854,7 +860,8 @@
	"idle time for inactivity LED (ticks)");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "hardled", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "hardled",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_hardled, "I", "enable/disable hardware LED support");
	/* XXX Laziness - configure pins, then flip hardled off/on */
	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	@@ -865,60 +872,71 @@
	"MAC Power LED pin, or -1 to disable");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "txantenna", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "txantenna",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_txantenna, "I", "antenna switch");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "rxantenna", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "rxantenna",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_rxantenna, "I", "default/rx antenna");
	if (ath_hal_hasdiversity(ah))
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "diversity", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "diversity",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_diversity, "I", "antenna diversity");
	sc->sc_txintrperiod = ATH_TXINTR_PERIOD;
	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	"txintrperiod", CTLFLAG_RW, &sc->sc_txintrperiod, 0,
	"tx descriptor batching");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "diag", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "diag", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_diag, "I", "h/w diagnostic control");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "tpscale", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "tpscale", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_tpscale, "I", "tx power scaling");
	if (ath_hal_hastpc(ah)) {
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "tpc", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "tpc",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_tpc, "I", "enable/disable per-packet TPC");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "tpack", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "tpack",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_tpack, "I", "tx power for ack frames");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "tpcts", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "tpcts",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_tpcts, "I", "tx power for cts frames");
	}
	if (ath_hal_hasrfsilent(ah)) {
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "rfsilent", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "rfsilent",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_rfsilent, "I", "h/w RF silent config");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "rfkill", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "rfkill",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_rfkill, "I", "enable/disable RF kill switch");
	}

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "txagg", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "txagg", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_txagg, "I", "");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "forcebstuck", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "forcebstuck",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_forcebstuck, "I", "");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "hangcheck", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "hangcheck",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_hangcheck, "I", "");

	if (ath_hal_hasintmit(ah)) {
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "intmit", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "intmit",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_intmit, "I", "interference mitigation");
	}
	sc->sc_monpass = HAL_RXERR_DECRYPT \| HAL_RXERR_MIC;
	@@ -989,7 +1007,8 @@
	"superframe", CTLFLAG_RD, &sc->sc_tdmabintval, 0,
	"TDMA calculated super frame");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "setcca", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "setcca",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_setcca, "I", "enable CCA control");
	}
	#endif
	@@ -1065,7 +1084,7 @@

	/* Create "clear" node */
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "clear_stats", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "clear_stats", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	ath_sysctl_clearstats, "I", "clear stats");

	/* Create stats node */
	Index: sys/dev/atkbdc/psm.c
	===================================================================
	--- sys/dev/atkbdc/psm.c
	+++ sys/dev/atkbdc/psm.c
	@@ -5788,7 +5788,8 @@
	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");
	@@ -5797,7 +5798,8 @@
	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)");
	@@ -5806,7 +5808,8 @@
	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)");
	@@ -5872,7 +5875,8 @@
	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");
	@@ -5881,7 +5885,8 @@
	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");
	@@ -5890,7 +5895,8 @@
	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");
	@@ -5899,7 +5905,8 @@
	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");
	@@ -5908,7 +5915,8 @@
	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");
	@@ -5917,7 +5925,8 @@
	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");
	@@ -5926,7 +5935,8 @@
	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");
	@@ -5935,7 +5945,8 @@
	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 "
	@@ -5945,7 +5956,8 @@
	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 "
	@@ -5955,7 +5967,8 @@
	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 "
	@@ -5965,7 +5978,8 @@
	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 "
	@@ -5975,7 +5989,8 @@
	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");
	@@ -5984,7 +5999,8 @@
	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");
	@@ -5993,7 +6009,8 @@
	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");
	@@ -6002,7 +6019,8 @@
	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");
	@@ -6011,7 +6029,8 @@
	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");
	@@ -6020,7 +6039,8 @@
	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)");
	@@ -6029,7 +6049,8 @@
	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 "
	@@ -6039,7 +6060,8 @@
	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");
	@@ -6048,7 +6070,8 @@
	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");
	@@ -6057,7 +6080,8 @@
	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)");
	@@ -6066,7 +6090,8 @@
	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");
	@@ -6075,7 +6100,8 @@
	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");
	@@ -6084,7 +6110,8 @@
	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");
	@@ -6094,7 +6121,8 @@
	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 "
	@@ -6104,7 +6132,8 @@
	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");
	@@ -6113,7 +6142,8 @@
	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");
	@@ -6122,7 +6152,8 @@
	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");
	@@ -6131,7 +6162,8 @@
	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");
	@@ -6140,7 +6172,8 @@
	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");
	@@ -6149,7 +6182,8 @@
	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");
	@@ -6157,7 +6191,8 @@
	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");
	@@ -6166,7 +6201,8 @@
	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");
	@@ -6758,7 +6794,8 @@
	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");
	@@ -6767,7 +6804,8 @@
	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");
	@@ -6776,7 +6814,8 @@
	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");
	@@ -6785,7 +6824,8 @@
	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");
	@@ -6794,7 +6834,8 @@
	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");
	@@ -6803,7 +6844,8 @@
	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");
	@@ -6812,7 +6854,8 @@
	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");
	@@ -6821,7 +6864,8 @@
	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");
	@@ -6830,7 +6874,8 @@
	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");
	@@ -6839,7 +6884,8 @@
	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");
	@@ -6848,7 +6894,8 @@
	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");
	@@ -6857,7 +6904,8 @@
	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");
	Index: sys/dev/bce/if_bce.c
	===================================================================
	--- sys/dev/bce/if_bce.c
	+++ sys/dev/bce/if_bce.c
	@@ -9299,13 +9299,13 @@
	}

	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 +9590,85 @@

	#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");

	Index: sys/dev/bfe/if_bfe.c
	===================================================================
	--- sys/dev/bfe/if_bfe.c
	+++ sys/dev/bfe/if_bfe.c
	@@ -478,7 +478,8 @@

	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,
	+ "stats", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	+ sysctl_bfe_stats,
	"I", "Statistics");

	/* Set up ifnet structure */
	Index: sys/dev/bge/if_bge.c
	===================================================================
	--- sys/dev/bge/if_bge.c
	+++ sys/dev/bge/if_bge.c
	@@ -6292,19 +6292,23 @@

	#ifdef BGE_REGISTER_DEBUG
	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "debug_info",
	- CTLTYPE_INT \| CTLFLAG_RW, sc, 0, bge_sysctl_debug_info, "I",
	+ 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",
	+ 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",
	+ 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",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	+ bge_sysctl_mem_read, "I",
	"Memory Read");

	#endif
	@@ -6355,7 +6359,8 @@
	}

	#define BGE_SYSCTL_STAT(sc, ctx, desc, parent, node, oid) \
	- SYSCTL_ADD_PROC(ctx, parent, OID_AUTO, oid, CTLTYPE_UINT\|CTLFLAG_RD, \
	+ 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)

	Index: sys/dev/bhnd/cores/pmu/bhnd_pmu.c
	===================================================================
	--- sys/dev/bhnd/cores/pmu/bhnd_pmu.c
	+++ sys/dev/bhnd/cores/pmu/bhnd_pmu.c
	@@ -191,15 +191,18 @@
	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);
	Index: sys/dev/bnxt/bnxt_sysctl.c
	===================================================================
	--- sys/dev/bnxt/bnxt_sysctl.c
	+++ sys/dev/bnxt/bnxt_sysctl.c
	@@ -861,11 +861,13 @@
	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,
	+ "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,
	+ "hwrm_min_ver", CTLTYPE_STRING \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ softc, 0,
	bnxt_hwrm_min_ver_sysctl, "A",
	"minimum hwrm API vesion to support");

	@@ -1205,43 +1207,55 @@
	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",
	+ 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",
	+ 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",
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ softc, 0, bnxt_set_coal_tx_frames_irq,
	"I", "interrupt coalescing Tx Frames IRQ");

	return 0;
	@@ -1317,17 +1331,21 @@
	return ENOMEM;

	SYSCTL_ADD_PROC(&softc->flow_ctrl_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "tx", CTLTYPE_INT\|CTLFLAG_RWTUN, softc, 0,
	+ "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,
	+ "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,
	+ "autoneg",
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ softc, 0,
	bnxt_flow_ctrl_autoneg, "A",
	"Enable or Disable Autoneg Flow Ctrl: 0 / 1");

	@@ -1343,29 +1361,39 @@
	return ENOMEM;

	SYSCTL_ADD_PROC(&softc->hw_lro_ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "enable", CTLTYPE_INT\|CTLFLAG_RWTUN, softc, 0,
	+ "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,
	+ "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,
	+ "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,
	+ "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,
	+ "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");

	@@ -1407,7 +1435,8 @@
	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;
	Index: sys/dev/bxe/bxe.c
	===================================================================
	--- sys/dev/bxe/bxe.c
	+++ sys/dev/bxe/bxe.c
	@@ -16164,19 +16164,19 @@
	"rx processing budget");

	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pause_param",
	- CTLTYPE_UINT \| CTLFLAG_RW, sc, 0,
	+ 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,
	+ 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,
	+ CTLTYPE_U64 \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, i,
	bxe_sysctl_eth_stat, "LU",
	bxe_eth_stats_arr[i].string);
	}
	@@ -16198,7 +16198,8 @@
	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,
	+ CTLTYPE_U64 \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ sc, q_stat,
	bxe_sysctl_eth_q_stat, "LU",
	bxe_eth_q_stats_arr[j].string);
	}
	Index: sys/dev/cxgb/cxgb_sge.c
	===================================================================
	--- sys/dev/cxgb/cxgb_sge.c
	+++ sys/dev/cxgb/cxgb_sge.c
	@@ -3451,13 +3451,13 @@

	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");

	@@ -3535,7 +3535,8 @@
	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,
	+ 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",
	@@ -3595,7 +3596,8 @@
	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],
	+ 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",
	@@ -3605,7 +3607,8 @@
	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],
	+ 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",
	@@ -3636,7 +3639,8 @@
	* 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), \
	+ 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);
	Index: sys/dev/cxgbe/t4_main.c
	===================================================================
	--- sys/dev/cxgbe/t4_main.c
	+++ sys/dev/cxgbe/t4_main.c
	@@ -6179,19 +6179,22 @@
	sc->params.nports, "# of ports");

	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "doorbells",
	- CTLTYPE_STRING \| CTLFLAG_RD, doorbells, (uintptr_t)&sc->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,
	+ 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,
	+ 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");

	@@ -6251,7 +6254,8 @@

	#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, \
	+ 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");
	@@ -6268,26 +6272,31 @@
	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",
	+ 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, sc, 0, sysctl_reset_sensor, "I",
	+ 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,
	@@ -6302,173 +6311,183 @@
	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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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",
	+ 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,7 +6547,8 @@
	&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,
	+ 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;
	@@ -6552,65 +6572,80 @@
	"autorcvbuf increment");

	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "timer_tick",
	- CTLTYPE_STRING \| CTLFLAG_RD, sc, 0, sysctl_tp_tick, "A",
	+ 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",
	+ 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",
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	+ S_KEEPALIVEMAXR2,
	sysctl_tp_shift_cnt, "IU",
	"Number of keepalive probes before abort");

	@@ -6620,7 +6655,8 @@
	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,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	+ i, sysctl_tp_backoff,
	"IU", "TOE retransmit backoff");
	}
	}
	@@ -6659,7 +6695,8 @@

	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");
	}

	@@ -6672,11 +6709,11 @@
	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");
	}
	@@ -6707,17 +6744,21 @@
	#endif

	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_tmr_idx",
	- CTLTYPE_INT \| CTLFLAG_RW, vi, 0, sysctl_holdoff_tmr_idx, "I",
	+ 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",
	+ 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",
	+ 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",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, vi, 0,
	+ sysctl_qsize_txq, "I",
	"tx queue size");
	}

	@@ -6740,28 +6781,34 @@
	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",
	+ 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",
	+ 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",
	+ 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,
	@@ -6801,12 +6848,14 @@
	SYSCTL_CHILDREN(oid), OID_AUTO, name, CTLFLAG_RD, NULL,
	"traffic class"));
	SYSCTL_ADD_PROC(ctx, children2, OID_AUTO, "flags",
	- CTLTYPE_STRING \| CTLFLAG_RD, tc_flags, (uintptr_t)&tc->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,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	+ (pi->port_id << 16) \| i,
	sysctl_tc_params, "A", "traffic class parameters");
	}

	@@ -6822,7 +6871,7 @@

	#define SYSCTL_ADD_T4_REG64(pi, name, desc, reg) \
	SYSCTL_ADD_OID(ctx, children, OID_AUTO, name, \
	- CTLTYPE_U64 \| CTLFLAG_RD, sc, reg, \
	+ 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",
	Index: sys/dev/cxgbe/t4_sge.c
	===================================================================
	--- sys/dev/cxgbe/t4_sge.c
	+++ sys/dev/cxgbe/t4_sge.c
	@@ -1006,7 +1006,8 @@
	struct sge_params *sp = &sc->params.sge;

	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "buffer_sizes",
	- CTLTYPE_STRING \| CTLFLAG_RD, &sc->sge, 0, sysctl_bufsizes, "A",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, &sc->sge, 0,
	+ sysctl_bufsizes, "A",
	"freelist buffer sizes");

	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "fl_pktshift", CTLFLAG_RD,
	@@ -3405,13 +3406,16 @@
	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",
	+ 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",
	+ 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",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, &iq->cidx, 0,
	+ sysctl_uint16, "I",
	"consumer index");
	}

	@@ -3431,7 +3435,8 @@
	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",
	+ 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");
	@@ -3695,13 +3700,16 @@
	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,
	+ 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,
	+ 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",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, &nm_rxq->iq_cidx, 0,
	+ sysctl_uint16, "I",
	"consumer index");

	children = SYSCTL_CHILDREN(oid);
	@@ -3710,7 +3718,8 @@
	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,
	+ 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");
	@@ -3778,10 +3787,12 @@
	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",
	+ 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",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, &nm_txq->pidx, 0,
	+ sysctl_uint16, "I",
	"producer index");

	return (rc);
	@@ -4099,10 +4110,12 @@
	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",
	+ 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",
	+ 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");
	@@ -4193,16 +4206,19 @@
	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",
	+ 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",
	+ 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",
	+ 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,
	Index: sys/dev/drm2/drm_sysctl.c
	===================================================================
	--- sys/dev/drm2/drm_sysctl.c
	+++ sys/dev/drm2/drm_sysctl.c
	@@ -103,7 +103,7 @@
	SYSCTL_CHILDREN(top),
	OID_AUTO,
	drm_sysctl_list[i].name,
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev,
	0,
	drm_sysctl_list[i].f,
	Index: sys/dev/e1000/if_em.c
	===================================================================
	--- sys/dev/e1000/if_em.c
	+++ sys/dev/e1000/if_em.c
	@@ -784,27 +784,32 @@
	/* SYSCTL stuff */
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "nvm", CTLTYPE_INT\|CTLFLAG_RW, adapter, 0,
	+ OID_AUTO, "nvm",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, adapter, 0,
	em_sysctl_nvm_info, "I", "NVM Information");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "debug", CTLTYPE_INT\|CTLFLAG_RW, adapter, 0,
	+ OID_AUTO, "debug",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, adapter, 0,
	em_sysctl_debug_info, "I", "Debug Information");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "fc", CTLTYPE_INT\|CTLFLAG_RW, adapter, 0,
	+ OID_AUTO, "fc",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, adapter, 0,
	em_set_flowcntl, "I", "Flow Control");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "reg_dump", CTLTYPE_STRING \| CTLFLAG_RD, adapter, 0,
	+ OID_AUTO, "reg_dump",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, adapter, 0,
	em_get_regs, "A", "Dump Registers");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "rs_dump", CTLTYPE_INT \| CTLFLAG_RW, adapter, 0,
	+ OID_AUTO, "rs_dump",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, adapter, 0,
	em_get_rs, "I", "Dump RS indexes");

	/* Determine hardware and mac info */
	@@ -1019,7 +1024,8 @@
	hw->dev_spec.ich8lan.eee_disable = eee_setting;
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "eee_control", CTLTYPE_INT\|CTLFLAG_RW,
	+ OID_AUTO, "eee_control",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	adapter, 0, em_sysctl_eee, "I",
	"Disable Energy Efficient Ethernet");

	@@ -4080,11 +4086,13 @@
	CTLFLAG_RD, &adapter->watchdog_events,
	"Watchdog timeouts");
	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "device_control",
	- CTLTYPE_UINT \| CTLFLAG_RD, adapter, E1000_CTRL,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ adapter, E1000_CTRL,
	em_sysctl_reg_handler, "IU",
	"Device Control Register");
	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rx_control",
	- CTLTYPE_UINT \| CTLFLAG_RD, adapter, E1000_RCTL,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ adapter, E1000_RCTL,
	em_sysctl_reg_handler, "IU",
	"Receiver Control Register");
	SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "fc_high_water",
	@@ -4102,12 +4110,14 @@
	queue_list = SYSCTL_CHILDREN(queue_node);

	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_head",
	- CTLTYPE_UINT \| CTLFLAG_RD, adapter,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ adapter,
	E1000_TDH(txr->me),
	em_sysctl_reg_handler, "IU",
	"Transmit Descriptor Head");
	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_tail",
	- CTLTYPE_UINT \| CTLFLAG_RD, adapter,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ adapter,
	E1000_TDT(txr->me),
	em_sysctl_reg_handler, "IU",
	"Transmit Descriptor Tail");
	@@ -4124,12 +4134,14 @@
	queue_list = SYSCTL_CHILDREN(queue_node);

	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_head",
	- CTLTYPE_UINT \| CTLFLAG_RD, adapter,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ adapter,
	E1000_RDH(rxr->me),
	em_sysctl_reg_handler, "IU",
	"Receive Descriptor Head");
	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_tail",
	- CTLTYPE_UINT \| CTLFLAG_RD, adapter,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ adapter,
	E1000_RDT(rxr->me),
	em_sysctl_reg_handler, "IU",
	"Receive Descriptor Tail");
	@@ -4434,7 +4446,7 @@
	info->value = value;
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(adapter->dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
	- OID_AUTO, name, CTLTYPE_INT\|CTLFLAG_RW,
	+ OID_AUTO, name, CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	info, 0, em_sysctl_int_delay, "I", description);
	}

	Index: sys/dev/ena/ena_sysctl.c
	===================================================================
	--- sys/dev/ena/ena_sysctl.c
	+++ sys/dev/ena/ena_sysctl.c
	@@ -289,13 +289,15 @@
	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",
	+ 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",
	+ 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");
	}
	Index: sys/dev/et/if_et.c
	===================================================================
	--- sys/dev/et/if_et.c
	+++ sys/dev/et/if_et.c
	@@ -2450,10 +2450,12 @@
	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",
	+ 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,
	Index: sys/dev/extres/clk/clk.c
	===================================================================
	--- sys/dev/extres/clk/clk.c
	+++ sys/dev/extres/clk/clk.c
	@@ -402,7 +402,7 @@
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	OID_AUTO, "clocks",
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	clkdom, 0, clkdom_sysctl,
	"A",
	"Clock list for the domain");
	@@ -639,21 +639,21 @@
	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");
	Index: sys/dev/extres/regulator/regulator.c
	===================================================================
	--- sys/dev/extres/regulator/regulator.c
	+++ sys/dev/extres/regulator/regulator.c
	@@ -453,7 +453,7 @@
	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)");
	Index: sys/dev/fxp/if_fxp.c
	===================================================================
	--- sys/dev/fxp/if_fxp.c
	+++ sys/dev/fxp/if_fxp.c
	@@ -3154,11 +3154,13 @@
	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));

	SYSCTL_ADD_PROC(ctx, child,
	- OID_AUTO, "int_delay", CTLTYPE_INT \| CTLFLAG_RW,
	+ 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,
	+ 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,
	Index: sys/dev/gpio/gpiobacklight.c
	===================================================================
	--- sys/dev/gpio/gpiobacklight.c
	+++ sys/dev/gpio/gpiobacklight.c
	@@ -131,7 +131,7 @@
	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);
	Index: sys/dev/hptmv/hptproc.c
	===================================================================
	--- sys/dev/hptmv/hptproc.c
	+++ sys/dev/hptmv/hptproc.c
	@@ -640,12 +640,14 @@
	#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, \
	+ 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_NEEDGIANT, \
	NULL, 0, hpt_status, "A", "Get/Set " #name " state")
	#endif

	Index: sys/dev/hwpmc/hwpmc_mod.c
	===================================================================
	--- sys/dev/hwpmc/hwpmc_mod.c
	+++ sys/dev/hwpmc/hwpmc_mod.c
	@@ -313,7 +313,7 @@
	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,
	+ CTLTYPE_STRING \| CTLFLAG_RWTUN \| CTLFLAG_NOFETCH \| CTLFLAG_NEEDGIANT,
	0, 0, pmc_debugflags_sysctl_handler, "A", "debug flags");
	#endif

	Index: sys/dev/hyperv/netvsc/if_hn.c
	===================================================================
	--- sys/dev/hyperv/netvsc/if_hn.c
	+++ sys/dev/hyperv/netvsc/if_hn.c
	@@ -576,12 +576,16 @@
	&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;
	Index: sys/dev/iicbus/ad7417.c
	===================================================================
	--- sys/dev/iicbus/ad7417.c
	+++ sys/dev/iicbus/ad7417.c
	@@ -445,7 +445,9 @@
	}
	/* I use i to pass the sensor id. */
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- unit, CTLTYPE_INT \| CTLFLAG_RD, dev,
	+ unit,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ dev,
	i, ad7417_sensor_sysctl,
	sc->sc_sensors[i].type == ADC7417_TEMP_SENSOR ?
	"IK" : "I", desc);
	Index: sys/dev/iicbus/ad7418.c
	===================================================================
	--- sys/dev/iicbus/ad7418.c
	+++ sys/dev/iicbus/ad7418.c
	@@ -118,10 +118,12 @@
	sx_init(&sc->sc_lock, "ad7418");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "temp", CTLTYPE_INT \| CTLFLAG_RD, sc, 0,
	+ "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,
	+ "volt",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, 0,
	ad7418_sysctl_voltage, "I", "input voltage");

	/* enable chip if configured in shutdown mode */
	Index: sys/dev/iicbus/ads111x.c
	===================================================================
	--- sys/dev/iicbus/ads111x.c
	+++ sys/dev/iicbus/ads111x.c
	@@ -409,13 +409,17 @@
	chantree = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(devtree), OID_AUTO,
	chanstr, CTLFLAG_RD, NULL, "channel data");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(chantree), OID_AUTO,
	- "gain_index", CTLTYPE_INT \| CTLFLAG_RWTUN, sc, chan,
	+ "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,
	+ "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,
	+ "voltage",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_SKIP \| CTLFLAG_NEEDGIANT,
	+ sc, chan,
	ads111x_sysctl_voltage, "I", "sampled voltage in microvolts");

	c->configured = true;
	@@ -556,13 +560,16 @@
	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. */
	Index: sys/dev/iicbus/adt746x.c
	===================================================================
	--- sys/dev/iicbus/adt746x.c
	+++ sys/dev/iicbus/adt746x.c
	@@ -521,7 +521,9 @@

	/* I use i to pass the fan id. */
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "pwm", CTLTYPE_INT \| CTLFLAG_RW, dev, i,
	+ "pwm",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ dev, i,
	adt746x_fanrpm_sysctl, "I", "Fan PWM in %");
	}

	@@ -647,7 +649,9 @@
	}
	/* I use i to pass the sensor id. */
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- unit, CTLTYPE_INT \| CTLFLAG_RD, dev, i,
	+ unit,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ dev, i,
	adt746x_sensor_sysctl,
	sc->sc_sensors[i].type == ADT746X_SENSOR_TEMP ?
	"IK" : "I", desc);
	Index: sys/dev/iicbus/max6690.c
	===================================================================
	--- sys/dev/iicbus/max6690.c
	+++ sys/dev/iicbus/max6690.c
	@@ -303,7 +303,8 @@
	"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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ dev, i % 2,
	max6690_sensor_sysctl, "IK", sysctl_desc);

	}
	Index: sys/dev/ioat/ioat.c
	===================================================================
	--- sys/dev/ioat/ioat.c
	+++ sys/dev/ioat/ioat.c
	@@ -1951,7 +1951,8 @@
	"submitter processing");

	SYSCTL_ADD_PROC(ctx, state, OID_AUTO, "chansts",
	- CTLTYPE_STRING \| CTLFLAG_RD, ioat, 0, sysctl_handle_chansts, "A",
	+ 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,
	@@ -1963,7 +1964,8 @@
	hammer = SYSCTL_CHILDREN(tmp);

	SYSCTL_ADD_PROC(ctx, hammer, OID_AUTO, "force_hw_reset",
	- CTLTYPE_INT \| CTLFLAG_RW, ioat, 0, sysctl_handle_reset, "I",
	+ 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,
	@@ -1990,7 +1992,8 @@
	"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",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, ioat, 0,
	+ sysctl_handle_dpi, "A",
	"Descriptors per interrupt");
	}

	Index: sys/dev/ioat/ioat_test.c
	===================================================================
	--- sys/dev/ioat/ioat_test.c
	+++ sys/dev/ioat/ioat_test.c
	@@ -576,7 +576,8 @@
	enable_ioat_test(enabled);
	return (0);
	}
	-SYSCTL_PROC(_hw_ioat, OID_AUTO, enable_ioat_test, CTLTYPE_INT \| CTLFLAG_RW,
	+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");

	Index: sys/dev/ipw/if_ipw.c
	===================================================================
	--- sys/dev/ipw/if_ipw.c
	+++ sys/dev/ipw/if_ipw.c
	@@ -330,12 +330,14 @@
	*/
	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",
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ sc, 0, ipw_sysctl_stats, "S",
	"statistics");

	/*
	Index: sys/dev/isci/isci_sysctl.c
	===================================================================
	--- sys/dev/isci/isci_sysctl.c
	+++ sys/dev/isci/isci_sysctl.c
	@@ -249,40 +249,49 @@
	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,
	+ "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,
	+ "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,
	+ "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,
	+ "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,
	+ "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");
	}
	Index: sys/dev/iscsi_initiator/isc_sm.c
	===================================================================
	--- sys/dev/iscsi_initiator/isc_sm.c
	+++ sys/dev/iscsi_initiator/isc_sm.c
	@@ -644,7 +644,7 @@
	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 @@
	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 @@
	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");

	Index: sys/dev/isl/isl.c
	===================================================================
	--- sys/dev/isl/isl.c
	+++ sys/dev/isl/isl.c
	@@ -206,7 +206,8 @@
	if (use_als) {
	SYSCTL_ADD_PROC(sysctl_ctx,
	SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
	- "als", CTLTYPE_INT \| CTLFLAG_RD,
	+ "als",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, ISL_METHOD_ALS, isl_sysctl, "I",
	"Current ALS sensor read-out");
	}
	@@ -214,7 +215,7 @@
	if (use_ir) {
	SYSCTL_ADD_PROC(sysctl_ctx,
	SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
	- "ir", CTLTYPE_INT \| CTLFLAG_RD,
	+ "ir", CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, ISL_METHOD_IR, isl_sysctl, "I",
	"Current IR sensor read-out");
	}
	@@ -222,20 +223,22 @@
	if (use_prox) {
	SYSCTL_ADD_PROC(sysctl_ctx,
	SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
	- "prox", CTLTYPE_INT \| CTLFLAG_RD,
	+ "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,
	+ "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,
	+ "range", CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, ISL_METHOD_RANGE, isl_sysctl, "I",
	"Current proximity sensor range");

	Index: sys/dev/isp/isp_freebsd.c
	===================================================================
	--- sys/dev/isp/isp_freebsd.c
	+++ sys/dev/isp/isp_freebsd.c
	@@ -223,7 +223,8 @@
	"Cause a Lost Frame on a Read");
	#endif
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "role", CTLTYPE_INT \| CTLFLAG_RW, isp, chan,
	+ "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,
	Index: sys/dev/iwi/if_iwi.c
	===================================================================
	--- sys/dev/iwi/if_iwi.c
	+++ sys/dev/iwi/if_iwi.c
	@@ -3331,11 +3331,13 @@
	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",
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, 0,
	+ iwi_sysctl_stats, "S",
	"statistics");

	sc->bluetooth = 0;
	@@ -3510,7 +3512,8 @@
	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,
	+ "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,
	Index: sys/dev/ixgbe/if_bypass.c
	===================================================================
	--- sys/dev/ixgbe/if_bypass.c
	+++ sys/dev/ixgbe/if_bypass.c
	@@ -746,7 +746,8 @@
	*/
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "bypass_log", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "bypass_log",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	adapter, 0, ixgbe_bp_log, "I", "Bypass Log");

	/* All other setting are hung from the 'bypass' node */
	@@ -757,39 +758,39 @@
	bp_list = SYSCTL_CHILDREN(bp_node);

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
	- OID_AUTO, "version", CTLTYPE_INT \| CTLFLAG_RD,
	+ OID_AUTO, "version", CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	adapter, 0, ixgbe_bp_version, "I", "Bypass Version");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
	- OID_AUTO, "state", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "state", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	adapter, 0, ixgbe_bp_set_state, "I", "Bypass State");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
	- OID_AUTO, "timeout", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "timeout", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	adapter, 0, ixgbe_bp_timeout, "I", "Bypass Timeout");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
	- OID_AUTO, "main_on", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "main_on", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	adapter, 0, ixgbe_bp_main_on, "I", "Bypass Main On");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
	- OID_AUTO, "main_off", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "main_off", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	adapter, 0, ixgbe_bp_main_off, "I", "Bypass Main Off");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
	- OID_AUTO, "aux_on", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "aux_on", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	adapter, 0, ixgbe_bp_aux_on, "I", "Bypass Aux On");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
	- OID_AUTO, "aux_off", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "aux_off", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	adapter, 0, ixgbe_bp_aux_off, "I", "Bypass Aux Off");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
	- OID_AUTO, "wd_set", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "wd_set", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	adapter, 0, ixgbe_bp_wd_set, "I", "Set BP Watchdog");

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
	- OID_AUTO, "wd_reset", CTLTYPE_INT \| CTLFLAG_WR,
	+ OID_AUTO, "wd_reset", CTLTYPE_INT \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT,
	adapter, 0, ixgbe_bp_wd_reset, "S", "Bypass WD Reset");

	adapter->feat_en \|= IXGBE_FEATURE_BYPASS;
	Index: sys/dev/ixgbe/if_ix.c
	===================================================================
	--- sys/dev/ixgbe/if_ix.c
	+++ sys/dev/ixgbe/if_ix.c
	@@ -1550,10 +1550,12 @@
	queue_list = SYSCTL_CHILDREN(queue_node);

	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_head",
	- CTLTYPE_UINT \| CTLFLAG_RD, txr, sizeof(txr),
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ txr, sizeof(txr),
	ixgbe_sysctl_tdh_handler, "IU", "Transmit Descriptor Head");
	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_tail",
	- CTLTYPE_UINT \| CTLFLAG_RD, txr, sizeof(txr),
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ txr, sizeof(txr),
	ixgbe_sysctl_tdt_handler, "IU", "Transmit Descriptor Tail");
	SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx",
	CTLFLAG_RD, &txr->tso_tx, "TSO");
	@@ -1570,7 +1572,8 @@
	queue_list = SYSCTL_CHILDREN(queue_node);

	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "interrupt_rate",
	- CTLTYPE_UINT \| CTLFLAG_RW, &adapter->rx_queues[i],
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &adapter->rx_queues[i],
	sizeof(&adapter->rx_queues[i]),
	ixgbe_sysctl_interrupt_rate_handler, "IU",
	"Interrupt Rate");
	@@ -1578,10 +1581,12 @@
	CTLFLAG_RD, &(adapter->rx_queues[i].irqs),
	"irqs on this queue");
	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_head",
	- CTLTYPE_UINT \| CTLFLAG_RD, rxr, sizeof(rxr),
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ rxr, sizeof(rxr),
	ixgbe_sysctl_rdh_handler, "IU", "Receive Descriptor Head");
	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_tail",
	- CTLTYPE_UINT \| CTLFLAG_RD, rxr, sizeof(rxr),
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ rxr, sizeof(rxr),
	ixgbe_sysctl_rdt_handler, "IU", "Receive Descriptor Tail");
	SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_packets",
	CTLFLAG_RD, &rxr->rx_packets, "Queue Packets Received");
	@@ -2529,37 +2534,42 @@

	/* Sysctls for all devices */
	SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "fc",
	- CTLTYPE_INT \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_flowcntl, "I",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ adapter, 0, ixgbe_sysctl_flowcntl, "I",
	IXGBE_SYSCTL_DESC_SET_FC);

	SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "advertise_speed",
	- CTLTYPE_INT \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_advertise, "I",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ adapter, 0, ixgbe_sysctl_advertise, "I",
	IXGBE_SYSCTL_DESC_ADV_SPEED);

	#ifdef IXGBE_DEBUG
	/* testing sysctls (for all devices) */
	SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "power_state",
	- CTLTYPE_INT \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_power_state,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ adapter, 0, ixgbe_sysctl_power_state,
	"I", "PCI Power State");

	SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "print_rss_config",
	- CTLTYPE_STRING \| CTLFLAG_RD, adapter, 0,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, adapter, 0,
	ixgbe_sysctl_print_rss_config, "A", "Prints RSS Configuration");
	#endif
	/* for X550 series devices */
	if (hw->mac.type >= ixgbe_mac_X550)
	SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "dmac",
	- CTLTYPE_U16 \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_dmac,
	+ CTLTYPE_U16 \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ adapter, 0, ixgbe_sysctl_dmac,
	"I", "DMA Coalesce");

	/* for WoL-capable devices */
	if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) {
	SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "wol_enable",
	- CTLTYPE_INT \| CTLFLAG_RW, adapter, 0,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, adapter, 0,
	ixgbe_sysctl_wol_enable, "I", "Enable/Disable Wake on LAN");

	SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "wufc",
	- CTLTYPE_U32 \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_wufc,
	+ CTLTYPE_U32 \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, adapter, 0,
	+ ixgbe_sysctl_wufc,
	"I", "Enable/Disable Wake Up Filters");
	}

	@@ -2573,18 +2583,20 @@
	phy_list = SYSCTL_CHILDREN(phy_node);

	SYSCTL_ADD_PROC(ctx_list, phy_list, OID_AUTO, "temp",
	- CTLTYPE_U16 \| CTLFLAG_RD, adapter, 0, ixgbe_sysctl_phy_temp,
	+ CTLTYPE_U16 \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, adapter, 0,
	+ ixgbe_sysctl_phy_temp,
	"I", "Current External PHY Temperature (Celsius)");

	SYSCTL_ADD_PROC(ctx_list, phy_list, OID_AUTO,
	- "overtemp_occurred", CTLTYPE_U16 \| CTLFLAG_RD, adapter, 0,
	+ "overtemp_occurred",
	+ CTLTYPE_U16 \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, adapter, 0,
	ixgbe_sysctl_phy_overtemp_occurred, "I",
	"External PHY High Temperature Event Occurred");
	}

	if (adapter->feat_cap & IXGBE_FEATURE_EEE) {
	SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "eee_state",
	- CTLTYPE_INT \| CTLFLAG_RW, adapter, 0,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, adapter, 0,
	ixgbe_sysctl_eee_state, "I", "EEE Power Save State");
	}
	} /* ixgbe_add_device_sysctls */
	Index: sys/dev/ixgbe/if_ixv.c
	===================================================================
	--- sys/dev/ixgbe/if_ixv.c
	+++ sys/dev/ixgbe/if_ixv.c
	@@ -418,7 +418,8 @@
	/* SYSCTL APIs */
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "debug",
	- CTLTYPE_INT \| CTLFLAG_RW, adapter, 0, ixv_sysctl_debug, "I",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, adapter, 0,
	+ ixv_sysctl_debug, "I",
	"Debug Info");

	/* Determine hardware revision */
	Index: sys/dev/ixl/if_iavf.c
	===================================================================
	--- sys/dev/ixl/if_iavf.c
	+++ sys/dev/ixl/if_iavf.c
	@@ -2049,16 +2049,19 @@
	struct sysctl_oid_list *debug_list;

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "current_speed", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "current_speed",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, 0, iavf_sysctl_current_speed, "A", "Current Port Speed");

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "tx_itr", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "tx_itr",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	sc, 0, iavf_sysctl_tx_itr, "I",
	"Immediately set TX ITR value for all queues");

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "rx_itr", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "rx_itr",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	sc, 0, iavf_sysctl_rx_itr, "I",
	"Immediately set RX ITR value for all queues");

	@@ -2077,19 +2080,23 @@
	&sc->dbg_mask, 0, "Non-shared code debug message level");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "filter_list", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "filter_list",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, 0, iavf_sysctl_sw_filter_list, "A", "SW Filter List");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "queue_interrupt_table", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "queue_interrupt_table",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, 0, iavf_sysctl_queue_interrupt_table, "A", "View MSI-X indices for TX/RX queues");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "do_vf_reset", CTLTYPE_INT \| CTLFLAG_WR,
	+ OID_AUTO, "do_vf_reset",
	+ CTLTYPE_INT \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT,
	sc, 0, iavf_sysctl_vf_reset, "A", "Request a VF reset from PF");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "do_vflr_reset", CTLTYPE_INT \| CTLFLAG_WR,
	+ OID_AUTO, "do_vflr_reset",
	+ CTLTYPE_INT \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT,
	sc, 0, iavf_sysctl_vflr_reset, "A", "Request a VFLR reset from HW");

	/* Add stats sysctls */
	Index: sys/dev/ixl/ixl_pf_main.c
	===================================================================
	--- sys/dev/ixl/ixl_pf_main.c
	+++ sys/dev/ixl/ixl_pf_main.c
	@@ -3121,37 +3121,44 @@

	/* Set up sysctls */
	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "fc", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "fc", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_set_flowcntl, "I", IXL_SYSCTL_HELP_FC);

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "advertise_speed", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "advertise_speed",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_set_advertise, "I", IXL_SYSCTL_HELP_SET_ADVERTISE);

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "supported_speeds", CTLTYPE_INT \| CTLFLAG_RD,
	+ OID_AUTO, "supported_speeds",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_supported_speeds, "I", IXL_SYSCTL_HELP_SUPPORTED_SPEED);

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "current_speed", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "current_speed",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_current_speed, "A", "Current Port Speed");

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "fw_version", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "fw_version",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_show_fw, "A", "Firmware version");

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "unallocated_queues", CTLTYPE_INT \| CTLFLAG_RD,
	+ OID_AUTO, "unallocated_queues",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_unallocated_queues, "I",
	"Queues not allocated to a PF or VF");

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "tx_itr", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "tx_itr",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_pf_tx_itr, "I",
	"Immediately set TX ITR value for all queues");

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "rx_itr", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "rx_itr",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_pf_rx_itr, "I",
	"Immediately set RX ITR value for all queues");

	@@ -3170,28 +3177,34 @@
	fec_list = SYSCTL_CHILDREN(fec_node);

	SYSCTL_ADD_PROC(ctx, fec_list,
	- OID_AUTO, "fc_ability", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "fc_ability",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_fec_fc_ability, "I", "FC FEC ability enabled");

	SYSCTL_ADD_PROC(ctx, fec_list,
	- OID_AUTO, "rs_ability", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "rs_ability",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_fec_rs_ability, "I", "RS FEC ability enabled");

	SYSCTL_ADD_PROC(ctx, fec_list,
	- OID_AUTO, "fc_requested", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "fc_requested",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_fec_fc_request, "I", "FC FEC mode requested on link");

	SYSCTL_ADD_PROC(ctx, fec_list,
	- OID_AUTO, "rs_requested", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "rs_requested",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_fec_rs_request, "I", "RS FEC mode requested on link");

	SYSCTL_ADD_PROC(ctx, fec_list,
	- OID_AUTO, "auto_fec_enabled", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "auto_fec_enabled",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_fec_auto_enable, "I", "Let FW decide FEC ability/request modes");
	}

	SYSCTL_ADD_PROC(ctx, ctx_list,
	- OID_AUTO, "fw_lldp", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "fw_lldp",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_fw_lldp, "I", IXL_SYSCTL_HELP_FW_LLDP);

	/* Add sysctls meant to print debug information, but don't list them
	@@ -3209,77 +3222,95 @@
	&pf->dbg_mask, 0, "Non-shared code debug message level");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "link_status", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "link_status",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_link_status, "A", IXL_SYSCTL_HELP_LINK_STATUS);

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "phy_abilities", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "phy_abilities",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_phy_abilities, "A", "PHY Abilities");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "filter_list", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "filter_list",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_sw_filter_list, "A", "SW Filter List");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "hw_res_alloc", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "hw_res_alloc",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_hw_res_alloc, "A", "HW Resource Allocation");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "switch_config", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "switch_config",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_switch_config, "A", "HW Switch Configuration");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "rss_key", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "rss_key",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_hkey, "A", "View RSS key");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "rss_lut", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "rss_lut",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_hlut, "A", "View RSS lookup table");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "rss_hena", CTLTYPE_ULONG \| CTLFLAG_RD,
	+ OID_AUTO, "rss_hena",
	+ CTLTYPE_ULONG \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_hena, "LU", "View enabled packet types for RSS");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "disable_fw_link_management", CTLTYPE_INT \| CTLFLAG_WR,
	+ OID_AUTO, "disable_fw_link_management",
	+ CTLTYPE_INT \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_fw_link_management, "I", "Disable FW Link Management");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "dump_debug_data", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "dump_debug_data",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_dump_debug_data, "A", "Dump Debug Data from FW");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "do_pf_reset", CTLTYPE_INT \| CTLFLAG_WR,
	+ OID_AUTO, "do_pf_reset",
	+ CTLTYPE_INT \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_do_pf_reset, "I", "Tell HW to initiate a PF reset");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "do_core_reset", CTLTYPE_INT \| CTLFLAG_WR,
	+ OID_AUTO, "do_core_reset",
	+ CTLTYPE_INT \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_do_core_reset, "I", "Tell HW to initiate a CORE reset");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "do_global_reset", CTLTYPE_INT \| CTLFLAG_WR,
	+ OID_AUTO, "do_global_reset",
	+ CTLTYPE_INT \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_do_global_reset, "I", "Tell HW to initiate a GLOBAL reset");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "do_emp_reset", CTLTYPE_INT \| CTLFLAG_WR,
	+ OID_AUTO, "do_emp_reset",
	+ CTLTYPE_INT \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_do_emp_reset, "I",
	"(This doesn't work) Tell HW to initiate a EMP (entire firmware) reset");

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "queue_interrupt_table", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "queue_interrupt_table",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_queue_interrupt_table, "A", "View MSI-X indices for TX/RX queues");

	if (pf->has_i2c) {
	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "read_i2c_byte", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "read_i2c_byte",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_read_i2c_byte, "I", IXL_SYSCTL_HELP_READ_I2C);

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "write_i2c_byte", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "write_i2c_byte",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_write_i2c_byte, "I", IXL_SYSCTL_HELP_WRITE_I2C);

	SYSCTL_ADD_PROC(ctx, debug_list,
	- OID_AUTO, "read_i2c_diag_data", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "read_i2c_diag_data",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pf, 0, ixl_sysctl_read_i2c_diag_data, "A", "Dump selected diagnostic data from FW");
	}
	}
	Index: sys/dev/jme/if_jme.c
	===================================================================
	--- sys/dev/jme/if_jme.c
	+++ sys/dev/jme/if_jme.c
	@@ -994,23 +994,28 @@
	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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &sc->jme_process_limit, 0,
	sysctl_hw_jme_proc_limit, "I",
	"max number of Rx events to process");

	Index: sys/dev/liquidio/lio_sysctl.c
	===================================================================
	--- sys/dev/liquidio/lio_sysctl.c
	+++ sys/dev/liquidio/lio_sysctl.c
	@@ -155,7 +155,7 @@
	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,
	+ 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",
	@@ -164,7 +164,7 @@
	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,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, lio, 0,
	lio_get_set_pauseparam, "I",
	"Get and set pause parameters.\n" \
	"0 - off\n" \
	@@ -172,30 +172,36 @@
	"2 - tx pause \n" \
	"3 - rx and tx pause");
	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "register-dump",
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	+ 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,
	Index: sys/dev/mge/if_mge.c
	===================================================================
	--- sys/dev/mge/if_mge.c
	+++ sys/dev/mge/if_mge.c
	@@ -2147,10 +2147,12 @@
	children = SYSCTL_CHILDREN(tree);

	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rx_time",
	- CTLTYPE_UINT \| CTLFLAG_RW, sc, MGE_IC_RX, mge_sysctl_ic,
	+ 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,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, MGE_IC_TX, mge_sysctl_ic,
	"I", "IC TX time threshold");
	}

	Index: sys/dev/mlx5/mlx5_en/mlx5_en_main.c
	===================================================================
	--- sys/dev/mlx5/mlx5_en/mlx5_en_main.c
	+++ sys/dev/mlx5/mlx5_en/mlx5_en_main.c
	@@ -3830,7 +3830,8 @@
	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,
	+ OID_AUTO, "fw_version",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, priv, 0,
	sysctl_firmware, "A", "HCA firmware version");

	SYSCTL_ADD_STRING(&priv->sysctl_ctx, SYSCTL_CHILDREN(priv->sysctl_hw),
	Index: sys/dev/mpr/mpr.c
	===================================================================
	--- sys/dev/mpr/mpr.c
	+++ sys/dev/mpr/mpr.c
	@@ -1879,7 +1879,9 @@
	"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,
	+ 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),
	Index: sys/dev/mps/mps.c
	===================================================================
	--- sys/dev/mps/mps.c
	+++ sys/dev/mps/mps.c
	@@ -1788,15 +1788,19 @@
	"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,
	+ 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),
	Index: sys/dev/mpt/mpt_raid.c
	===================================================================
	--- sys/dev/mpt/mpt_raid.c
	+++ sys/dev/mpt/mpt_raid.c
	@@ -1826,17 +1826,21 @@
	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,
	+ "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,
	+ "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,
	+ "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,
	Index: sys/dev/msk/if_msk.c
	===================================================================
	--- sys/dev/msk/if_msk.c
	+++ sys/dev/msk/if_msk.c
	@@ -1798,7 +1798,8 @@

	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");

	@@ -4477,11 +4478,13 @@
	#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)

	Index: sys/dev/mwl/if_mwl.c
	===================================================================
	--- sys/dev/mwl/if_mwl.c
	+++ sys/dev/mwl/if_mwl.c
	@@ -4784,7 +4784,8 @@

	sc->sc_debug = mwl_debug;
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "debug", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "debug",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	mwl_sysctl_debug, "I", "control debugging printfs");
	#endif
	}
	Index: sys/dev/mxge/if_mxge.c
	===================================================================
	--- sys/dev/mxge/if_mxge.c
	+++ sys/dev/mxge/if_mxge.c
	@@ -1508,19 +1508,19 @@
	/* performance related tunables */
	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
	"intr_coal_delay",
	- CTLTYPE_INT\|CTLFLAG_RW, sc,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, 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,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc,
	0, mxge_change_throttle,
	"I", "transmit throttling");

	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
	"flow_control_enabled",
	- CTLTYPE_INT\|CTLFLAG_RW, sc,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc,
	0, mxge_change_flow_control,
	"I", "interrupt coalescing delay in usecs");

	@@ -1533,74 +1533,81 @@
	Need to swap it */
	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
	"link_up",
	- CTLTYPE_INT\|CTLFLAG_RD, &fw->link_up,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ &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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ &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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ &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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ &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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ &fw->dropped_overrun,
	0, mxge_handle_be32,
	"I", "dropped_overrun");
	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
	"dropped_pause",
	- CTLTYPE_INT\|CTLFLAG_RD,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ &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,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ &fw->dropped_unicast_filtered,
	0, mxge_handle_be32,
	"I", "dropped_unicast_filtered");

	Index: sys/dev/neta/if_mvneta.c
	===================================================================
	--- sys/dev/neta/if_mvneta.c
	+++ sys/dev/neta/if_mvneta.c
	@@ -3470,7 +3470,8 @@
	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,
	+ 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",
	@@ -3481,7 +3482,7 @@
	CTLFLAG_RD, &sc->counter_watchdog, 0, "TX Watchdog Counter");

	SYSCTL_ADD_PROC(ctx, mchildren, OID_AUTO, "reset",
	- CTLTYPE_INT\|CTLFLAG_RW, (void *)sc, 0,
	+ 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++) {
	@@ -3499,7 +3500,7 @@

	/* 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]");
	}
	Index: sys/dev/nfe/if_nfe.c
	===================================================================
	--- sys/dev/nfe/if_nfe.c
	+++ sys/dev/nfe/if_nfe.c
	@@ -3122,7 +3122,8 @@
	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,
	+ 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");

	Index: sys/dev/nge/if_nge.c
	===================================================================
	--- sys/dev/nge/if_nge.c
	+++ sys/dev/nge/if_nge.c
	@@ -2652,7 +2652,8 @@
	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,
	+ 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;
	Index: sys/dev/ntb/ntb_hw/ntb_hw_intel.c
	===================================================================
	--- sys/dev/ntb/ntb_hw/ntb_hw_intel.c
	+++ sys/dev/ntb/ntb_hw/ntb_hw_intel.c
	@@ -2249,14 +2249,16 @@
	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,
	+ 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,
	+ 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",
	@@ -2280,7 +2282,8 @@
	}

	SYSCTL_ADD_PROC(ctx, tree_par, OID_AUTO, "features",
	- CTLFLAG_RD \| CTLTYPE_STRING, ntb, 0, sysctl_handle_features, "A",
	+ 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,
	@@ -2313,63 +2316,63 @@
	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");
	}
	@@ -2381,7 +2384,7 @@
	CTLFLAG_RD, 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");

	@@ -2390,55 +2393,55 @@
	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 +2449,75 @@
	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");
	Index: sys/dev/nvme/nvme_sysctl.c
	===================================================================
	--- sys/dev/nvme/nvme_sysctl.c
	+++ sys/dev/nvme/nvme_sysctl.c
	@@ -288,7 +288,8 @@
	"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,
	+ "dump_debug",
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, qpair, 0,
	nvme_sysctl_dump_debug, "IU", "Dump debug data");
	}

	@@ -311,44 +312,52 @@
	"Number of I/O queue pairs");

	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
	- "int_coal_time", CTLTYPE_UINT \| CTLFLAG_RW, ctrlr, 0,
	+ "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,
	+ "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,
	+ "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,
	+ "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",
	Index: sys/dev/oce/oce_sysctl.c
	===================================================================
	--- sys/dev/oce/oce_sysctl.c
	+++ sys/dev/oce/oce_sysctl.c
	@@ -128,15 +128,15 @@
	0,"PVID");

	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "loop_back",
	- CTLTYPE_INT \| CTLFLAG_RW, (void *)sc, 0,
	+ 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,
	+ 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,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, (void *)sc, 1,
	oce_sys_aic_enable, "I", "aic flags");

	/*
	@@ -146,7 +146,8 @@
	* "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,
	+ 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,
	Index: sys/dev/ocs_fc/ocs_ioctl.c
	===================================================================
	--- sys/dev/ocs_fc/ocs_ioctl.c
	+++ sys/dev/ocs_fc/ocs_ioctl.c
	@@ -1132,36 +1132,43 @@
	0, "SLI Interface");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "fw_upgrade",
	- CTLTYPE_STRING \| CTLFLAG_RW, (void *)ocs, 0,
	+ 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,
	+ "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,
	+ "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,
	+ "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,
	+ "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,
	+ "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,
	+ "configured_speed",
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	ocs, 0, ocs_sysctl_config_speed, "IU",
	"Configured Speed, 0-Auto, 2000, 4000, 8000, 16000, 32000");

	@@ -1171,12 +1178,14 @@
	0, "Bus Info");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "fcid", CTLTYPE_STRING \| CTLFLAG_RD,
	+ "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,
	+ "port_state",
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	ocs, 0, ocs_sysctl_port_state, "A",
	"configured port state");

	@@ -1189,12 +1198,14 @@
	OID_AUTO, name, CTLFLAG_RW, 0, "Virtual port");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(vtree), OID_AUTO,
	- "wwnn", CTLTYPE_STRING \| CTLFLAG_RW,
	+ "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,
	+ "wwpn",
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	fcp, 0, ocs_sysctl_vport_wwpn, "A",
	"World Wide Port Name");

	Index: sys/dev/ofw/ofw_fdt.c
	===================================================================
	--- sys/dev/ofw/ofw_fdt.c
	+++ sys/dev/ofw/ofw_fdt.c
	@@ -123,7 +123,8 @@
	return;

	SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_fdt), OID_AUTO, "dtb",
	- CTLTYPE_OPAQUE \| CTLFLAG_RD, NULL, 0, sysctl_handle_dtb, "",
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, NULL, 0,
	+ sysctl_handle_dtb, "",
	"Device Tree Blob");
	}
	SYSINIT(dtb_oid, SI_SUB_KMEM, SI_ORDER_ANY, sysctl_register_fdt_oid, NULL);
	Index: sys/dev/ow/ow.c
	===================================================================
	--- sys/dev/ow/ow.c
	+++ sys/dev/ow/ow.c
	@@ -183,8 +183,8 @@
	return (0); \
	} \
	SYSCTL_PROC(_hw_ow_ ## mode, OID_AUTO, param, \
	- CTLTYPE_INT \| CTLFLAG_RWTUN, 0, sizeof(int), \
	- sysctl_ow_timing_ ## mode ## _ ## param, "I", \
	+ 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)")

	#define OW_TIMING_SYSCTL(param) \
	Index: sys/dev/ow/ow_temp.c
	===================================================================
	--- sys/dev/ow/ow_temp.c
	+++ sys/dev/ow/ow_temp.c
	@@ -198,7 +198,8 @@
	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),
	Index: sys/dev/qlnx/qlnxe/qlnx_os.c
	===================================================================
	--- sys/dev/qlnx/qlnxe/qlnx_os.c
	+++ sys/dev/qlnx/qlnxe/qlnx_os.c
	@@ -2310,20 +2310,21 @@
	"tx_coalesce_usecs");

	SYSCTL_ADD_PROC(ctx, children,
	- OID_AUTO, "trigger_dump", (CTLTYPE_INT \| CTLFLAG_RW),
	+ 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),
	+ 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),
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	(void *)ha, 0,
	qlnx_set_tx_coalesce, "I",
	"tx interrupt coalesce period microseconds");
	Index: sys/dev/qlxgb/qla_os.c
	===================================================================
	--- sys/dev/qlxgb/qla_os.c
	+++ sys/dev/qlxgb/qla_os.c
	@@ -152,7 +152,8 @@

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "stats", CTLTYPE_INT \| CTLFLAG_RD,
	+ OID_AUTO, "stats",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	(void *)ha, 0,
	qla_sysctl_get_stats, "I", "Statistics");

	Index: sys/dev/qlxgbe/ql_hw.c
	===================================================================
	--- sys/dev/qlxgbe/ql_hw.c
	+++ sys/dev/qlxgbe/ql_hw.c
	@@ -980,7 +980,8 @@

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "port_cfg", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "port_cfg",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	(void *)ha, 0,
	qla_sysctl_port_cfg, "I",
	"Set Port Configuration if values below "
	@@ -993,7 +994,8 @@

	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,
	+ 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"
	@@ -1002,7 +1004,8 @@

	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,
	+ 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"
	@@ -1098,7 +1101,8 @@

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "peg_stop", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "peg_stop",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	(void *)ha, 0,
	qla_sysctl_stop_pegs, "I", "Peg Stop");

	Index: sys/dev/qlxgbe/ql_os.c
	===================================================================
	--- sys/dev/qlxgbe/ql_os.c
	+++ sys/dev/qlxgbe/ql_os.c
	@@ -177,7 +177,8 @@

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "link_status", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "link_status",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	(void *)ha, 0,
	qla_sysctl_get_link_status, "I", "Link Status");

	Index: sys/dev/qlxge/qls_hw.c
	===================================================================
	--- sys/dev/qlxge/qls_hw.c
	+++ sys/dev/qlxge/qls_hw.c
	@@ -161,13 +161,15 @@

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "mpi_dump", CTLTYPE_INT \| CTLFLAG_RW,
	+ 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,
	+ OID_AUTO, "link_status",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	(void *)ha, 0,
	qls_syctl_link_status, "I", "Link Status");
	}
	Index: sys/dev/qlxge/qls_os.c
	===================================================================
	--- sys/dev/qlxge/qls_os.c
	+++ sys/dev/qlxge/qls_os.c
	@@ -281,7 +281,8 @@

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "drvr_stats", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "drvr_stats",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	(void *)ha, 0,
	qls_sysctl_get_drvr_stats, "I", "Driver Maintained Statistics");

	Index: sys/dev/random/fortuna.c
	===================================================================
	--- sys/dev/random/fortuna.c
	+++ sys/dev/random/fortuna.c
	@@ -303,7 +303,8 @@
	"Fortuna Parameters");
	SYSCTL_ADD_PROC(&random_clist,
	SYSCTL_CHILDREN(random_fortuna_o), OID_AUTO,
	- "minpoolsize", CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+ "minpoolsize",
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&fortuna_state.fs_minpoolsize, RANDOM_FORTUNA_DEFPOOLSIZE,
	random_check_uint_fs_minpoolsize, "IU",
	"Minimum pool size necessary to cause a reseed");
	Index: sys/dev/random/random_harvestq.c
	===================================================================
	--- sys/dev/random/random_harvestq.c
	+++ sys/dev/random/random_harvestq.c
	@@ -305,8 +305,10 @@
	(orig_value & user_immutable_mask);
	return (0);
	}
	-SYSCTL_PROC(_kern_random_harvest, OID_AUTO, mask, CTLTYPE_UINT \| CTLFLAG_RW,
	- NULL, 0, random_check_uint_harvestmask, "IU", "Entropy harvesting mask");
	+SYSCTL_PROC(_kern_random_harvest, OID_AUTO, mask,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, random_check_uint_harvestmask, "IU",
	+ "Entropy harvesting mask");

	/* ARGSUSED */
	static int
	@@ -326,7 +328,8 @@
	return (error);
	}
	SYSCTL_PROC(_kern_random_harvest, OID_AUTO, mask_bin,
	- CTLTYPE_STRING \| CTLFLAG_RD, NULL, 0, random_print_harvestmask, "A",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, random_print_harvestmask, "A",
	"Entropy harvesting mask (printable)");

	static const char *random_source_descr[ENTROPYSOURCE] = {
	@@ -387,7 +390,8 @@
	return (error);
	}
	SYSCTL_PROC(_kern_random_harvest, OID_AUTO, mask_symbolic,
	- CTLTYPE_STRING \| CTLFLAG_RD, NULL, 0, random_print_harvestmask_symbolic,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, random_print_harvestmask_symbolic,
	"A", "Entropy harvesting mask (symbolic)");

	/* ARGSUSED */
	Index: sys/dev/re/if_re.c
	===================================================================
	--- sys/dev/re/if_re.c
	+++ sys/dev/re/if_re.c
	@@ -3969,13 +3969,15 @@
	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",
	+ 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,
	+ 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;
	Index: sys/dev/safe/safe.c
	===================================================================
	--- sys/dev/safe/safe.c
	+++ sys/dev/safe/safe.c
	@@ -2162,6 +2162,8 @@
	}
	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 */
	Index: sys/dev/sfxge/sfxge.c
	===================================================================
	--- sys/dev/sfxge/sfxge.c
	+++ sys/dev/sfxge/sfxge.c
	@@ -971,7 +971,8 @@
	return;

	SYSCTL_ADD_PROC(
	- ctx, list, OID_AUTO, keyword, CTLTYPE_STRING\|CTLFLAG_RD,
	+ 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", "");
	}
	Index: sys/dev/sfxge/sfxge_ev.c
	===================================================================
	--- sys/dev/sfxge/sfxge_ev.c
	+++ sys/dev/sfxge/sfxge_ev.c
	@@ -503,7 +503,7 @@
	SYSCTL_ADD_PROC(
	ctx, SYSCTL_CHILDREN(evq_stats_node),
	OID_AUTO, efx_ev_qstat_name(sc->enp, id),
	- CTLTYPE_U64\|CTLFLAG_RD,
	+ CTLTYPE_U64 \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	evq, id, sfxge_evq_stat_handler, "Q",
	"");
	}
	@@ -566,7 +566,8 @@
	efx_ev_qstat_name(sc->enp, id));
	SYSCTL_ADD_PROC(
	ctx, stat_list,
	- OID_AUTO, name, CTLTYPE_U64\|CTLFLAG_RD,
	+ OID_AUTO, name,
	+ CTLTYPE_U64 \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, id, sfxge_ev_stat_handler, "Q",
	"");
	}
	@@ -1004,7 +1005,8 @@
	*/
	sc->ev_moderation = SFXGE_MODERATION;
	SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
	- OID_AUTO, "int_mod", CTLTYPE_UINT\|CTLFLAG_RW,
	+ OID_AUTO, "int_mod",
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	sc, 0, sfxge_int_mod_handler, "IU",
	"sfxge interrupt moderation (us)");

	Index: sys/dev/sfxge/sfxge_port.c
	===================================================================
	--- sys/dev/sfxge/sfxge_port.c
	+++ sys/dev/sfxge/sfxge_port.c
	@@ -196,7 +196,8 @@
	name = efx_mac_stat_name(sc->enp, id);
	SYSCTL_ADD_PROC(
	ctx, stat_list,
	- OID_AUTO, name, CTLTYPE_U64\|CTLFLAG_RD,
	+ OID_AUTO, name,
	+ CTLTYPE_U64 \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, id, sfxge_mac_stat_handler, "Q",
	"");
	}
	@@ -652,7 +653,8 @@
	name = efx_phy_stat_name(sc->enp, id);
	SYSCTL_ADD_PROC(
	ctx, stat_list,
	- OID_AUTO, name, CTLTYPE_UINT\|CTLFLAG_RD,
	+ OID_AUTO, name,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, id, sfxge_phy_stat_handler,
	id == EFX_PHY_STAT_OUI ? "IX" : "IU",
	"");
	@@ -787,10 +789,12 @@
	* 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_NEEDGIANT, 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_NEEDGIANT, sc, 0,
	sfxge_port_link_fc_handler, "IU", "link flow control mode");
	#endif

	@@ -806,7 +810,8 @@
	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_NEEDGIANT, sc, 0,
	sfxge_port_stats_update_period_ms_handler, "IU",
	"interface statistics refresh period");

	Index: sys/dev/sfxge/sfxge_rx.c
	===================================================================
	--- sys/dev/sfxge/sfxge_rx.c
	+++ sys/dev/sfxge/sfxge_rx.c
	@@ -1359,7 +1359,7 @@
	SYSCTL_ADD_PROC(
	ctx, stat_list,
	OID_AUTO, sfxge_rx_stats[id].name,
	- CTLTYPE_UINT\|CTLFLAG_RD,
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, id, sfxge_rx_stat_handler, "IU",
	"");
	}
	Index: sys/dev/sfxge/sfxge_tx.c
	===================================================================
	--- sys/dev/sfxge/sfxge_tx.c
	+++ sys/dev/sfxge/sfxge_tx.c
	@@ -1969,7 +1969,7 @@
	SYSCTL_ADD_PROC(
	ctx, stat_list,
	OID_AUTO, sfxge_tx_stats[id].name,
	- CTLTYPE_ULONG\|CTLFLAG_RD,
	+ CTLTYPE_ULONG \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, id, sfxge_tx_stat_handler, "LU",
	"");
	}
	Index: sys/dev/sk/if_sk.c
	===================================================================
	--- sys/dev/sk/if_sk.c
	+++ sys/dev/sk/if_sk.c
	@@ -1596,7 +1596,8 @@

	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");

	Index: sys/dev/sound/clone.c
	===================================================================
	--- sys/dev/sound/clone.c
	+++ sys/dev/sound/clone.c
	@@ -158,7 +158,8 @@

	return (err);
	}
	-SYSCTL_PROC(_hw_snd, OID_AUTO, timestamp_precision, CTLTYPE_INT \| CTLFLAG_RW,
	+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
	Index: sys/dev/sound/pci/atiixp.c
	===================================================================
	--- sys/dev/sound/pci/atiixp.c
	+++ sys/dev/sound/pci/atiixp.c
	@@ -1096,7 +1096,9 @@

	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),
	+ "polling",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc->dev, sizeof(sc->dev),
	sysctl_atiixp_polling, "I", "Enable polling mode");

	snprintf(status, SND_STATUSLEN, "at memory 0x%jx irq %jd %s",
	Index: sys/dev/sound/pci/emu10kx.c
	===================================================================
	--- sys/dev/sound/pci/emu10kx.c
	+++ sys/dev/sound/pci/emu10kx.c
	@@ -1579,7 +1579,8 @@
	SYSCTL_ADD_PROC(sc->ctx,
	SYSCTL_CHILDREN(sc->root),
	OID_AUTO, sysctl_name,
	- CTLTYPE_INT \| CTLFLAG_RW, sc, mix_id,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, mix_id,
	sysctl_emu_mixer_control, "I", "");
	}

	@@ -1621,7 +1622,7 @@
	SYSCTL_ADD_PROC(sc->ctx,
	SYSCTL_CHILDREN(sc->root),
	OID_AUTO, "_digital",
	- CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	sysctl_emu_digitalswitch_control, "I", "Enable digital output");

	return;
	Index: sys/dev/sound/pci/es137x.c
	===================================================================
	--- sys/dev/sound/pci/es137x.c
	+++ sys/dev/sound/pci/es137x.c
	@@ -1647,7 +1647,9 @@
	<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),
	+ "spdif_enabled",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ dev, sizeof(dev),
	sysctl_es137x_spdif_enable, "I",
	"Enable S/PDIF output on primary playback channel");
	} else if (devid == ES1370_PCI_ID) {
	@@ -1663,7 +1665,8 @@
	<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_NEEDGIANT,
	dev, sizeof(dev), sysctl_es137x_fixed_rate, "I",
	"Enable fixed rate playback/recording");
	}
	@@ -1680,7 +1683,8 @@
	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),
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ dev, sizeof(dev),
	sysctl_es137x_single_pcm_mixer, "I",
	"Single PCM mixer controller for both DAC1/DAC2");
	}
	@@ -1693,12 +1697,14 @@
	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),
	+ "latency_timer",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, 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),
	+ "polling",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, dev, sizeof(dev),
	sysctl_es_polling, "I",
	"Enable polling mode");
	}
	Index: sys/dev/sound/pci/hda/hdaa.c
	===================================================================
	--- sys/dev/sound/pci/hda/hdaa.c
	+++ sys/dev/sound/pci/hda/hdaa.c
	@@ -1554,19 +1554,22 @@
	snprintf(buf, sizeof(buf), "nid%d", w->nid);
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
	- buf, CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_MPSAFE,
	+ buf,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_MPSAFE,
	w, 0, hdaa_sysctl_caps, "A", "Node capabilities");
	if (w->type == HDA_PARAM_AUDIO_WIDGET_CAP_TYPE_PIN_COMPLEX) {
	snprintf(buf, sizeof(buf), "nid%d_config", w->nid);
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
	- buf, CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_MPSAFE,
	+ buf,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_MPSAFE,
	&w->wclass.pin.newconf, 0, hdaa_sysctl_config, "A",
	"Current pin configuration");
	snprintf(buf, sizeof(buf), "nid%d_original", w->nid);
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
	- buf, CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_MPSAFE,
	+ buf,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_MPSAFE,
	&w->wclass.pin.original, 0, hdaa_sysctl_config, "A",
	"Original pin configuration");
	}
	@@ -6671,7 +6674,7 @@
	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,
	Index: sys/dev/sound/pci/hda/hdac.c
	===================================================================
	--- sys/dev/sound/pci/hda/hdac.c
	+++ sys/dev/sound/pci/hda/hdac.c
	@@ -1565,11 +1565,13 @@

	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),
	+ "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),
	+ "polling", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc->dev, sizeof(sc->dev),
	sysctl_hdac_polling, "I", "Enable polling mode");
	}

	Index: sys/dev/sound/pci/via8233.c
	===================================================================
	--- sys/dev/sound/pci/via8233.c
	+++ sys/dev/sound/pci/via8233.c
	@@ -258,17 +258,20 @@
	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),
	+ "spdif_enabled",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, 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),
	+ "dxs_src",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, 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),
	+ "polling",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, dev, sizeof(dev),
	sysctl_via_polling, "I",
	"Enable polling mode");
	}
	Index: sys/dev/sound/pcm/ac97.c
	===================================================================
	--- sys/dev/sound/pcm/ac97.c
	+++ sys/dev/sound/pcm/ac97.c
	@@ -919,7 +919,7 @@
	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_NEEDGIANT,
	codec, sizeof(codec), sysctl_hw_snd_ac97_eapd,
	"I", "AC97 External Amplifier");
	}
	Index: sys/dev/sound/pcm/channel.c
	===================================================================
	--- sys/dev/sound/pcm/channel.c
	+++ sys/dev/sound/pcm/channel.c
	@@ -68,9 +68,10 @@

	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 @@

	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 @@

	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 @@

	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 @@

	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;
	Index: sys/dev/sound/pcm/feeder_eq.c
	===================================================================
	--- sys/dev/sound/pcm/feeder_eq.c
	+++ sys/dev/sound/pcm/feeder_eq.c
	@@ -684,7 +684,8 @@

	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),
	+ "eq",
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT, d, sizeof(d),
	sysctl_dev_pcm_eq, "I",
	"Bass/Treble Equalizer (0=disable, 1=enable, 2=bypass)");

	@@ -696,7 +697,8 @@

	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),
	+ "eq_preamp",
	+ CTLTYPE_STRING \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT, d, sizeof(d),
	sysctl_dev_pcm_eq_preamp, "A", buf);
	}
	#endif
	Index: sys/dev/sound/pcm/feeder_rate.c
	===================================================================
	--- sys/dev/sound/pcm/feeder_rate.c
	+++ sys/dev/sound/pcm/feeder_rate.c
	@@ -185,7 +185,8 @@

	return (0);
	}
	-SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_min, CTLTYPE_INT \| CTLFLAG_RWTUN,
	+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");

	@@ -207,7 +208,8 @@

	return (0);
	}
	-SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_max, CTLTYPE_INT \| CTLFLAG_RWTUN,
	+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");

	@@ -229,7 +231,8 @@

	return (0);
	}
	-SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_round, CTLTYPE_INT \| CTLFLAG_RWTUN,
	+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");

	@@ -281,7 +284,8 @@

	return (0);
	}
	-SYSCTL_PROC(_hw_snd, OID_AUTO, feeder_rate_quality, CTLTYPE_INT \| CTLFLAG_RWTUN,
	+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)");
	Index: sys/dev/sound/pcm/mixer.c
	===================================================================
	--- sys/dev/sound/pcm/mixer.c
	+++ sys/dev/sound/pcm/mixer.c
	@@ -889,7 +889,8 @@
	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,
	+ OID_AUTO, "hwvol_mixer",
	+ CTLTYPE_STRING \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT, m, 0,
	sysctl_hw_snd_hwvol_mixer, "A", "");
	return 0;
	}
	Index: sys/dev/sound/pcm/sndstat.c
	===================================================================
	--- sys/dev/sound/pcm/sndstat.c
	+++ sys/dev/sound/pcm/sndstat.c
	@@ -100,8 +100,10 @@
	}
	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)
	Index: sys/dev/sound/pcm/sound.c
	===================================================================
	--- sys/dev/sound/pcm/sound.c
	+++ sys/dev/sound/pcm/sound.c
	@@ -443,9 +443,9 @@
	}
	/* 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 +473,10 @@
	}
	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,7 +1009,8 @@

	return (err);
	}
	-SYSCTL_PROC(_hw_snd, OID_AUTO, clone_gc, CTLTYPE_INT \| CTLFLAG_RWTUN,
	+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,23 +1027,27 @@
	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),
	+ "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),
	+ "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),
	+ "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),
	+ "clone_gc",
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT, d, sizeof(d),
	sysctl_dev_pcm_clone_gc, "I",
	"clone garbage collector");
	#endif
	Index: sys/dev/sound/pcm/vchan.c
	===================================================================
	--- sys/dev/sound/pcm/vchan.c
	+++ sys/dev/sound/pcm/vchan.c
	@@ -948,45 +948,53 @@
	/* 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_NEEDGIANT,
	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_NEEDGIANT,
	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_NEEDGIANT,
	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_NEEDGIANT,
	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_NEEDGIANT,
	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_NEEDGIANT,
	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_NEEDGIANT,
	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_NEEDGIANT,
	VCHAN_SYSCTL_DATA(unit, REC), VCHAN_SYSCTL_DATA_SIZE,
	sysctl_dev_pcm_vchanformat, "A", "virtual channel mixing format");
	}
	Index: sys/dev/sound/usb/uaudio.c
	===================================================================
	--- sys/dev/sound/usb/uaudio.c
	+++ sys/dev/sound/usb/uaudio.c
	@@ -133,7 +133,8 @@

	return (0);
	}
	-SYSCTL_PROC(_hw_usb_uaudio, OID_AUTO, buffer_ms, CTLTYPE_INT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_uaudio, OID_AUTO, buffer_ms,
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	0, sizeof(int), uaudio_buffer_ms_sysctl, "I",
	"uaudio buffering delay from 2ms to 8ms");
	#else
	@@ -2932,7 +2933,8 @@

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(control_tree),
	- OID_AUTO, "val", CTLTYPE_INT \| CTLFLAG_RWTUN, sc,
	+ OID_AUTO, "val",
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT, sc,
	pmc->wValue[chan],
	uaudio_mixer_sysctl_handler, "I", "Current value");

	Index: sys/dev/stge/if_stge.c
	===================================================================
	--- sys/dev/stge/if_stge.c
	+++ sys/dev/stge/if_stge.c
	@@ -476,12 +476,16 @@

	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,
	+ "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,
	+ "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. */
	Index: sys/dev/tsec/if_tsec.c
	===================================================================
	--- sys/dev/tsec/if_tsec.c
	+++ sys/dev/tsec/if_tsec.c
	@@ -1684,17 +1684,21 @@
	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,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, 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,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, 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,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, 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,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, TSEC_IC_TX,
	+ tsec_sysctl_ic_count,
	"I", "IC TX frame count threshold (0-255)");
	}

	Index: sys/dev/uart/uart_core.c
	===================================================================
	--- sys/dev/uart/uart_core.c
	+++ sys/dev/uart/uart_core.c
	@@ -209,7 +209,8 @@
	#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",
	+ 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");

	Index: sys/dev/usb/input/atp.c
	===================================================================
	--- sys/dev/usb/input/atp.c
	+++ sys/dev/usb/input/atp.c
	@@ -196,7 +196,8 @@

	static u_int atp_mickeys_scale_factor = ATP_SCALE_FACTOR;
	static int atp_sysctl_scale_factor_handler(SYSCTL_HANDLER_ARGS);
	-SYSCTL_PROC(_hw_usb_atp, OID_AUTO, scale_factor, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_atp, OID_AUTO, scale_factor,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&atp_mickeys_scale_factor, sizeof(atp_mickeys_scale_factor),
	atp_sysctl_scale_factor_handler, "IU", "movement scale factor");

	Index: sys/dev/usb/input/ums.c
	===================================================================
	--- sys/dev/usb/input/ums.c
	+++ sys/dev/usb/input/ums.c
	@@ -750,7 +750,8 @@

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "parseinfo", CTLTYPE_STRING\|CTLFLAG_RD,
	+ OID_AUTO, "parseinfo",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	sc, 0, ums_sysctl_handler_parseinfo,
	"", "Dump of parsed HID report descriptor");

	Index: sys/dev/usb/net/uhso.c
	===================================================================
	--- sys/dev/usb/net/uhso.c
	+++ sys/dev/usb/net/uhso.c
	@@ -599,7 +599,8 @@
	CTLFLAG_RD, uhso_port[UHSO_IFACE_PORT(sc->sc_type)], 0,
	"Port available at this interface");
	SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "radio",
	- CTLTYPE_INT \| CTLFLAG_RWTUN, sc, 0, uhso_radio_sysctl, "I", "Enable radio");
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT, sc, 0,
	+ uhso_radio_sysctl, "I", "Enable radio");

	/*
	* The default interface description on most Option devices isn't
	Index: sys/dev/usb/net/usb_ethernet.c
	===================================================================
	--- sys/dev/usb/net/usb_ethernet.c
	+++ sys/dev/usb/net/usb_ethernet.c
	@@ -277,7 +277,7 @@
	OID_AUTO, num, CTLFLAG_RD, NULL, "");
	SYSCTL_ADD_PROC(&ue->ue_sysctl_ctx,
	SYSCTL_CHILDREN(ue->ue_sysctl_oid), OID_AUTO,
	- "%parent", CTLTYPE_STRING \| CTLFLAG_RD, ue, 0,
	+ "%parent", CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, ue, 0,
	ue_sysctl_parent, "A", "parent device");

	UE_LOCK(ue);
	Index: sys/dev/usb/serial/ufoma.c
	===================================================================
	--- sys/dev/usb/serial/ufoma.c
	+++ sys/dev/usb/serial/ufoma.c
	@@ -457,15 +457,18 @@
	soid = device_get_sysctl_tree(dev);

	SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "supportmode",
	- CTLFLAG_RD\|CTLTYPE_STRING, sc, 0, ufoma_sysctl_support,
	+ CTLFLAG_RD \| CTLTYPE_STRING \| CTLFLAG_NEEDGIANT,
	+ sc, 0, ufoma_sysctl_support,
	"A", "Supporting port role");

	SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "currentmode",
	- CTLFLAG_RD\|CTLTYPE_STRING, sc, 0, ufoma_sysctl_current,
	+ CTLFLAG_RD \| CTLTYPE_STRING \| CTLFLAG_NEEDGIANT,
	+ sc, 0, ufoma_sysctl_current,
	"A", "Current port role");

	SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "openmode",
	- CTLFLAG_RW\|CTLTYPE_STRING, sc, 0, ufoma_sysctl_open,
	+ CTLFLAG_RW \| CTLTYPE_STRING \| CTLFLAG_NEEDGIANT,
	+ sc, 0, ufoma_sysctl_open,
	"A", "Mode to transit when port is opened");
	SYSCTL_ADD_UINT(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "comunit",
	CTLFLAG_RD, &(sc->sc_super_ucom.sc_unit), 0,
	Index: sys/dev/usb/usb_debug.c
	===================================================================
	--- sys/dev/usb/usb_debug.c
	+++ sys/dev/usb/usb_debug.c
	@@ -79,34 +79,44 @@
	static SYSCTL_NODE(_hw_usb, OID_AUTO, timings, CTLFLAG_RW, 0, "Timings");
	static int usb_timings_sysctl_handler(SYSCTL_HANDLER_ARGS);

	-SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_reset_delay, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_reset_delay,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&usb_port_reset_delay, sizeof(usb_port_reset_delay),
	usb_timings_sysctl_handler, "IU", "Port Reset Delay");
	-SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_root_reset_delay, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_root_reset_delay,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&usb_port_root_reset_delay, sizeof(usb_port_root_reset_delay),
	usb_timings_sysctl_handler, "IU", "Root Port Reset Delay");
	-SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_reset_recovery, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_reset_recovery,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&usb_port_reset_recovery, sizeof(usb_port_reset_recovery),
	usb_timings_sysctl_handler, "IU", "Port Reset Recovery");
	-SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_powerup_delay, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_powerup_delay,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&usb_port_powerup_delay, sizeof(usb_port_powerup_delay),
	usb_timings_sysctl_handler, "IU", "Port PowerUp Delay");
	-SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_resume_delay, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_resume_delay,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&usb_port_resume_delay, sizeof(usb_port_resume_delay),
	usb_timings_sysctl_handler, "IU", "Port Resume Delay");
	-SYSCTL_PROC(_hw_usb_timings, OID_AUTO, set_address_settle, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_timings, OID_AUTO, set_address_settle,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&usb_set_address_settle, sizeof(usb_set_address_settle),
	usb_timings_sysctl_handler, "IU", "Set Address Settle");
	-SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_delay, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_delay,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&usb_resume_delay, sizeof(usb_resume_delay),
	usb_timings_sysctl_handler, "IU", "Resume Delay");
	-SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_wait, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_wait,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&usb_resume_wait, sizeof(usb_resume_wait),
	usb_timings_sysctl_handler, "IU", "Resume Wait");
	-SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_recovery, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_recovery,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&usb_resume_recovery, sizeof(usb_resume_recovery),
	usb_timings_sysctl_handler, "IU", "Resume Recovery");
	-SYSCTL_PROC(_hw_usb_timings, OID_AUTO, extra_power_up_time, CTLTYPE_UINT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_hw_usb_timings, OID_AUTO, extra_power_up_time,
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	&usb_extra_power_up_time, sizeof(usb_extra_power_up_time),
	usb_timings_sysctl_handler, "IU", "Extra PowerUp Time");
	#endif
	Index: sys/dev/usb/usb_hub_acpi.c
	===================================================================
	--- sys/dev/usb/usb_hub_acpi.c
	+++ sys/dev/usb/usb_hub_acpi.c
	@@ -395,7 +395,8 @@
	acpi_uhub_parse_pld(dev, devinfo->Address, ah, tree);
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	tree, OID_AUTO, "info",
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ CTLTYPE_STRING \| CTLFLAG_RD \|
	+ CTLFLAG_NEEDGIANT,
	&sc->port[devinfo->Address - 1], 0,
	acpi_uhub_port_sysctl,
	"A", "Port information");
	Index: sys/dev/virtio/block/virtio_blk.c
	===================================================================
	--- sys/dev/virtio/block/virtio_blk.c
	+++ sys/dev/virtio/block/virtio_blk.c
	@@ -1386,7 +1386,8 @@
	child = SYSCTL_CHILDREN(tree);

	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "writecache_mode",
	- CTLTYPE_INT \| CTLFLAG_RW, sc, 0, vtblk_write_cache_sysctl,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	+ vtblk_write_cache_sysctl,
	"I", "Write cache mode (writethrough (0) or writeback (1))");
	}

	Index: sys/dev/vr/if_vr.c
	===================================================================
	--- sys/dev/vr/if_vr.c
	+++ sys/dev/vr/if_vr.c
	@@ -626,7 +626,8 @@
	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,
	+ OID_AUTO, "stats", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, 0,
	vr_sysctl_stats, "I", "Statistics");

	error = 0;
	Index: sys/dev/vte/if_vte.c
	===================================================================
	--- sys/dev/vte/if_vte.c
	+++ sys/dev/vte/if_vte.c
	@@ -564,10 +564,12 @@
	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,
	+ 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,
	+ 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;
	Index: sys/dev/wbwd/wbwd.c
	===================================================================
	--- sys/dev/wbwd/wbwd.c
	+++ sys/dev/wbwd/wbwd.c
	@@ -628,14 +628,17 @@
	"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,
	+ 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. */
	Index: sys/dev/xen/blkfront/blkfront.c
	===================================================================
	--- sys/dev/xen/blkfront/blkfront.c
	+++ sys/dev/xen/blkfront/blkfront.c
	@@ -924,7 +924,8 @@
	"communication channel pages (negotiated)");

	SYSCTL_ADD_PROC(sysctl_ctx, children, OID_AUTO,
	- "features", CTLTYPE_STRING\|CTLFLAG_RD, xbd, 0,
	+ "features",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, xbd, 0,
	xbd_sysctl_features, "A", "protocol features (negotiated)");
	}

	Index: sys/dev/xen/netback/netback.c
	===================================================================
	--- sys/dev/xen/netback/netback.c
	+++ sys/dev/xen/netback/netback.c
	@@ -1157,7 +1157,7 @@
	SYSCTL_CHILDREN(sysctl_tree),
	OID_AUTO,
	"unit_test_results",
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	xnb,
	0,
	xnb_unit_test_main,
	@@ -1168,7 +1168,7 @@
	SYSCTL_CHILDREN(sysctl_tree),
	OID_AUTO,
	"dump_rings",
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	xnb,
	0,
	xnb_dump_rings,
	Index: sys/fs/nfsclient/nfs_clnfsiod.c
	===================================================================
	--- sys/fs/nfsclient/nfs_clnfsiod.c
	+++ sys/fs/nfsclient/nfs_clnfsiod.c
	@@ -124,7 +124,8 @@
	NFSUNLOCKIOD();
	return (0);
	}
	-SYSCTL_PROC(_vfs_nfs, OID_AUTO, iodmin, CTLTYPE_UINT \| CTLFLAG_RW, 0,
	+SYSCTL_PROC(_vfs_nfs, OID_AUTO, iodmin,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, 0,
	sizeof (nfs_iodmin), sysctl_iodmin, "IU",
	"Min number of nfsiod kthreads to keep as spares");

	@@ -160,7 +161,8 @@
	NFSUNLOCKIOD();
	return (0);
	}
	-SYSCTL_PROC(_vfs_nfs, OID_AUTO, iodmax, CTLTYPE_UINT \| CTLFLAG_RW, 0,
	+SYSCTL_PROC(_vfs_nfs, OID_AUTO, iodmax,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, 0,
	sizeof (ncl_iodmax), sysctl_iodmax, "IU",
	"Max number of nfsiod kthreads");

	Index: sys/geom/cache/g_cache.c
	===================================================================
	--- sys/geom/cache/g_cache.c
	+++ sys/geom/cache/g_cache.c
	@@ -84,10 +84,14 @@
	(u_int )arg1 = val;
	return (0);
	}
	-SYSCTL_PROC(_kern_geom_cache, OID_AUTO, used_lo, CTLTYPE_UINT\|CTLFLAG_RW,
	- &g_cache_used_lo, 0, sysctl_handle_pct, "IU", "");
	-SYSCTL_PROC(_kern_geom_cache, OID_AUTO, used_hi, CTLTYPE_UINT\|CTLFLAG_RW,
	- &g_cache_used_hi, 0, sysctl_handle_pct, "IU", "");
	+SYSCTL_PROC(_kern_geom_cache, OID_AUTO, used_lo,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &g_cache_used_lo, 0, sysctl_handle_pct, "IU",
	+ "");
	+SYSCTL_PROC(_kern_geom_cache, OID_AUTO, used_hi,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &g_cache_used_hi, 0, sysctl_handle_pct, "IU",
	+ "");


	static int g_cache_destroy(struct g_cache_softc *sc, boolean_t force);
	Index: sys/geom/geom_disk.c
	===================================================================
	--- sys/geom/geom_disk.c
	+++ sys/geom/geom_disk.c
	@@ -741,7 +741,8 @@
	"LED name");
	SYSCTL_ADD_PROC(&sc->sysctl_ctx,
	SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, "flags",
	- CTLTYPE_STRING \| CTLFLAG_RD, dp, 0, g_disk_sysctl_flags,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, dp, 0,
	+ g_disk_sysctl_flags,
	"A", "Report disk flags");
	}
	pp->private = sc;
	Index: sys/geom/geom_kern.c
	===================================================================
	--- sys/geom/geom_kern.c
	+++ sys/geom/geom_kern.c
	@@ -206,17 +206,20 @@

	SYSCTL_NODE(_kern, OID_AUTO, geom, CTLFLAG_RW, 0, "GEOMetry management");

	-SYSCTL_PROC(_kern_geom, OID_AUTO, confxml, CTLTYPE_STRING\|CTLFLAG_RD,
	- 0, 0, sysctl_kern_geom_confxml, "",
	- "Dump the GEOM config in XML");
	-
	-SYSCTL_PROC(_kern_geom, OID_AUTO, confdot, CTLTYPE_STRING\|CTLFLAG_RD,
	- 0, 0, sysctl_kern_geom_confdot, "",
	- "Dump the GEOM config in dot");
	-
	-SYSCTL_PROC(_kern_geom, OID_AUTO, conftxt, CTLTYPE_STRING\|CTLFLAG_RD,
	- 0, 0, sysctl_kern_geom_conftxt, "",
	- "Dump the GEOM config in txt");
	+SYSCTL_PROC(_kern_geom, OID_AUTO, confxml,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_kern_geom_confxml, "",
	+ "Dump the GEOM config in XML");
	+
	+SYSCTL_PROC(_kern_geom, OID_AUTO, confdot,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_kern_geom_confdot, "",
	+ "Dump the GEOM config in dot");
	+
	+SYSCTL_PROC(_kern_geom, OID_AUTO, conftxt,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_kern_geom_conftxt, "",
	+ "Dump the GEOM config in txt");

	SYSCTL_INT(_kern_geom, OID_AUTO, debugflags, CTLFLAG_RWTUN,
	&g_debugflags, 0, "Set various trace levels for GEOM debugging");
	Index: sys/geom/journal/g_journal.c
	===================================================================
	--- sys/geom/journal/g_journal.c
	+++ sys/geom/journal/g_journal.c
	@@ -128,7 +128,8 @@
	return (0);
	}
	SYSCTL_PROC(_kern_geom_journal, OID_AUTO, record_entries,
	- CTLTYPE_UINT \| CTLFLAG_RW, NULL, 0, g_journal_record_entries_sysctl, "I",
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, NULL, 0,
	+ g_journal_record_entries_sysctl, "I",
	"Maximum number of entires in one journal record");
	SYSCTL_UINT(_kern_geom_journal, OID_AUTO, optimize, CTLFLAG_RW,
	&g_journal_do_optimize, 0, "Try to combine bios on flush and copy");
	@@ -160,7 +161,8 @@
	return (0);
	}
	SYSCTL_PROC(_kern_geom_journal_cache, OID_AUTO, limit,
	- CTLTYPE_ULONG \| CTLFLAG_RWTUN, NULL, 0, g_journal_cache_limit_sysctl, "I",
	+ CTLTYPE_ULONG \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT, NULL, 0,
	+ g_journal_cache_limit_sysctl, "I",
	"Maximum number of allocated bytes");
	SYSCTL_UINT(_kern_geom_journal_cache, OID_AUTO, divisor, CTLFLAG_RDTUN,
	&g_journal_cache_divisor, 0,
	@@ -182,7 +184,8 @@
	return (0);
	}
	SYSCTL_PROC(_kern_geom_journal_cache, OID_AUTO, switch,
	- CTLTYPE_UINT \| CTLFLAG_RW, NULL, 0, g_journal_cache_switch_sysctl, "I",
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, NULL, 0,
	+ g_journal_cache_switch_sysctl, "I",
	"Force switch when we hit this percent of cache use");
	SYSCTL_UINT(_kern_geom_journal_cache, OID_AUTO, misses, CTLFLAG_RW,
	&g_journal_cache_misses, 0, "Number of cache misses");
	Index: sys/geom/stripe/g_stripe.c
	===================================================================
	--- sys/geom/stripe/g_stripe.c
	+++ sys/geom/stripe/g_stripe.c
	@@ -88,8 +88,10 @@
	g_stripe_fast = fast;
	return (error);
	}
	-SYSCTL_PROC(_kern_geom_stripe, OID_AUTO, fast, CTLTYPE_INT \| CTLFLAG_RWTUN,
	- NULL, 0, g_sysctl_stripe_fast, "I", "Fast, but memory-consuming, mode");
	+SYSCTL_PROC(_kern_geom_stripe, OID_AUTO, fast,
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, g_sysctl_stripe_fast, "I",
	+ "Fast, but memory-consuming, mode");
	static u_int g_stripe_maxmem = MAXPHYS * 100;
	SYSCTL_UINT(_kern_geom_stripe, OID_AUTO, maxmem, CTLFLAG_RDTUN, &g_stripe_maxmem,
	0, "Maximum memory that can be allocated in \"fast\" mode (in bytes)");
	Index: sys/geom/zero/g_zero.c
	===================================================================
	--- sys/geom/zero/g_zero.c
	+++ sys/geom/zero/g_zero.c
	@@ -49,8 +49,10 @@
	static SYSCTL_NODE(_kern_geom, OID_AUTO, zero, CTLFLAG_RW, 0,
	"GEOM_ZERO stuff");
	static int g_zero_clear = 1;
	-SYSCTL_PROC(_kern_geom_zero, OID_AUTO, clear, CTLTYPE_INT\|CTLFLAG_RW,
	- &g_zero_clear, 0, g_zero_clear_sysctl, "I", "Clear read data buffer");
	+SYSCTL_PROC(_kern_geom_zero, OID_AUTO, clear,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &g_zero_clear, 0, g_zero_clear_sysctl, "I",
	+ "Clear read data buffer");
	static int g_zero_byte = 0;
	SYSCTL_INT(_kern_geom_zero, OID_AUTO, byte, CTLFLAG_RW, &g_zero_byte, 0,
	"Byte (octet) value to clear the buffers with");
	Index: sys/gnu/gcov/gcov_subr.c
	===================================================================
	--- sys/gnu/gcov/gcov_subr.c
	+++ sys/gnu/gcov/gcov_subr.c
	@@ -163,7 +163,11 @@

	static SYSCTL_NODE(_debug, OID_AUTO, gcov, CTLFLAG_RD, NULL,
	"gcov code coverage");
	-SYSCTL_PROC(_debug_gcov, OID_AUTO, reset, CTLTYPE_INT \| CTLFLAG_RW,
	- NULL, 0, gcov_stats_reset_sysctl, "I", "Reset all profiling counts");
	-SYSCTL_PROC(_debug_gcov, OID_AUTO, enable, CTLTYPE_INT \| CTLFLAG_RW,
	- NULL, 0, gcov_stats_enable_sysctl, "I", "Enable code coverage");
	+SYSCTL_PROC(_debug_gcov, OID_AUTO, reset,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, gcov_stats_reset_sysctl, "I",
	+ "Reset all profiling counts");
	+SYSCTL_PROC(_debug_gcov, OID_AUTO, enable,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, gcov_stats_enable_sysctl, "I",
	+ "Enable code coverage");
	Index: sys/i386/i386/elan-mmcr.c
	===================================================================
	--- sys/i386/i386/elan-mmcr.c
	+++ sys/i386/i386/elan-mmcr.c
	@@ -221,8 +221,10 @@
	return (0);
	}

	-SYSCTL_OID(_machdep, OID_AUTO, elan_gpio_config, CTLTYPE_STRING \| CTLFLAG_RW,
	- NULL, 0, sysctl_machdep_elan_gpio_config, "A", "Elan CPU GPIO pin config");
	+SYSCTL_OID(_machdep, OID_AUTO, elan_gpio_config,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_machdep_elan_gpio_config, "A",
	+ "Elan CPU GPIO pin config");

	#ifdef CPU_ELAN_PPS
	static void
	@@ -321,8 +323,10 @@
	return (error);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, elan_freq, CTLTYPE_UINT \| CTLFLAG_RW,
	- 0, sizeof (u_int), sysctl_machdep_elan_freq, "IU", "");
	+SYSCTL_PROC(_machdep, OID_AUTO, elan_freq,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof (u_int), sysctl_machdep_elan_freq, "IU",
	+ "");

	/*
	* Positively identifying the Elan can only be done through the PCI id of
	Index: sys/i386/i386/longrun.c
	===================================================================
	--- sys/i386/i386/longrun.c
	+++ sys/i386/i386/longrun.c
	@@ -280,26 +280,32 @@
	"crusoe", CTLFLAG_RD, 0,
	"Transmeta Crusoe LongRun support");
	SYSCTL_ADD_PROC(&crusoe_sysctl_ctx, SYSCTL_CHILDREN(crusoe_sysctl_tree),
	- OID_AUTO, "longrun", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "longrun",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&crusoe_longrun, 0, tmx86_longrun_sysctl, "I",
	"LongRun mode [0-3]");
	SYSCTL_ADD_PROC(&crusoe_sysctl_ctx, SYSCTL_CHILDREN(crusoe_sysctl_tree),
	- OID_AUTO, "frequency", CTLTYPE_INT \| CTLFLAG_RD,
	+ OID_AUTO, "frequency",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&crusoe_frequency, 0, tmx86_status_sysctl, "I",
	"Current frequency (MHz)");
	SYSCTL_ADD_PROC(&crusoe_sysctl_ctx, SYSCTL_CHILDREN(crusoe_sysctl_tree),
	- OID_AUTO, "voltage", CTLTYPE_INT \| CTLFLAG_RD,
	+ OID_AUTO, "voltage",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&crusoe_voltage, 0, tmx86_status_sysctl, "I",
	"Current voltage (mV)");
	SYSCTL_ADD_PROC(&crusoe_sysctl_ctx, SYSCTL_CHILDREN(crusoe_sysctl_tree),
	- OID_AUTO, "percentage", CTLTYPE_INT \| CTLFLAG_RD,
	+ OID_AUTO, "percentage",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&crusoe_percentage, 0, tmx86_status_sysctl, "I",
	"Processing performance (%)");
	SYSCTL_ADD_PROC(&crusoe_sysctl_ctx, SYSCTL_CHILDREN(crusoe_sysctl_tree),
	- OID_AUTO, "performance_longrun", CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_RW,
	+ OID_AUTO, "performance_longrun",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&crusoe_performance_longrun, 0, tmx86_longrun_profile_sysctl, "I", "");
	SYSCTL_ADD_PROC(&crusoe_sysctl_ctx, SYSCTL_CHILDREN(crusoe_sysctl_tree),
	- OID_AUTO, "economy_longrun", CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_RW,
	+ OID_AUTO, "economy_longrun",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&crusoe_economy_longrun, 0, tmx86_longrun_profile_sysctl, "I", "");

	/* register performance profile change handler */
	Index: sys/i386/i386/machdep.c
	===================================================================
	--- sys/i386/i386/machdep.c
	+++ sys/i386/i386/machdep.c
	@@ -2665,8 +2665,10 @@
	}
	return (error);
	}
	-SYSCTL_PROC(_machdep, OID_AUTO, smap, CTLTYPE_OPAQUE\|CTLFLAG_RD, NULL, 0,
	- smap_sysctl_handler, "S,bios_smap_xattr", "Raw BIOS SMAP data");
	+SYSCTL_PROC(_machdep, OID_AUTO, smap,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, NULL, 0,
	+ smap_sysctl_handler, "S,bios_smap_xattr",
	+ "Raw BIOS SMAP data");

	void
	spinlock_enter(void)
	Index: sys/i386/i386/mp_clock.c
	===================================================================
	--- sys/i386/i386/mp_clock.c
	+++ sys/i386/i386/mp_clock.c
	@@ -81,8 +81,10 @@
	return (error);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, piix_freq, CTLTYPE_INT \| CTLFLAG_RW,
	- 0, sizeof(u_int), sysctl_machdep_piix_freq, "I", "");
	+SYSCTL_PROC(_machdep, OID_AUTO, piix_freq,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof(u_int), sysctl_machdep_piix_freq, "I",
	+ "");

	static unsigned
	piix_get_timecount(struct timecounter *tc)
	Index: sys/i386/i386/prof_machdep.c
	===================================================================
	--- sys/i386/i386/prof_machdep.c
	+++ sys/i386/i386/prof_machdep.c
	@@ -300,8 +300,10 @@
	return (error);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, cputime_clock, CTLTYPE_INT \| CTLFLAG_RW,
	- 0, sizeof(u_int), sysctl_machdep_cputime_clock, "I", "");
	+SYSCTL_PROC(_machdep, OID_AUTO, cputime_clock,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof(u_int), sysctl_machdep_cputime_clock, "I",
	+ "");

	/*
	* The start and stop routines need not be here since we turn off profiling
	Index: sys/kern/kern_acct.c
	===================================================================
	--- sys/kern/kern_acct.c
	+++ sys/kern/kern_acct.c
	@@ -187,7 +187,8 @@
	acctchkfreq = value;
	return (0);
	}
	-SYSCTL_PROC(_kern, OID_AUTO, acct_chkfreq, CTLTYPE_INT\|CTLFLAG_RW,
	+SYSCTL_PROC(_kern, OID_AUTO, acct_chkfreq,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&acctchkfreq, 0, sysctl_acct_chkfreq, "I",
	"frequency for checking the free space");

	Index: sys/kern/kern_cons.c
	===================================================================
	--- sys/kern/kern_cons.c
	+++ sys/kern/kern_cons.c
	@@ -360,8 +360,10 @@
	return (error);
	}

	-SYSCTL_PROC(_kern, OID_AUTO, console, CTLTYPE_STRING\|CTLFLAG_RW,
	- 0, 0, sysctl_kern_console, "A", "Console device control");
	+SYSCTL_PROC(_kern, OID_AUTO, console,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_kern_console, "A",
	+ "Console device control");

	/*
	* User has changed the state of the console muting.
	@@ -378,9 +380,10 @@
	return (error);
	}

	-SYSCTL_PROC(_kern, OID_AUTO, consmute, CTLTYPE_INT\|CTLFLAG_RW,
	- 0, sizeof(cn_mute), sysctl_kern_consmute, "I",
	- "State of the console muting");
	+SYSCTL_PROC(_kern, OID_AUTO, consmute,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof(cn_mute), sysctl_kern_consmute, "I",
	+ "State of the console muting");

	void
	cngrab()
	Index: sys/kern/kern_cpu.c
	===================================================================
	--- sys/kern/kern_cpu.c
	+++ sys/kern/kern_cpu.c
	@@ -186,11 +186,13 @@
	M_DEVBUF, M_WAITOK);
	SYSCTL_ADD_PROC(&sc->sysctl_ctx,
	SYSCTL_CHILDREN(device_get_sysctl_tree(parent)),
	- OID_AUTO, "freq", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ OID_AUTO, "freq",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	cpufreq_curr_sysctl, "I", "Current CPU frequency");
	SYSCTL_ADD_PROC(&sc->sysctl_ctx,
	SYSCTL_CHILDREN(device_get_sysctl_tree(parent)),
	- OID_AUTO, "freq_levels", CTLTYPE_STRING \| CTLFLAG_RD, sc, 0,
	+ OID_AUTO, "freq_levels",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, 0,
	cpufreq_levels_sysctl, "A", "CPU frequency levels");

	/*
	@@ -1020,7 +1022,8 @@
	/* Add a sysctl to get each driver's settings separately. */
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "freq_settings", CTLTYPE_STRING \| CTLFLAG_RD, dev, 0,
	+ OID_AUTO, "freq_settings",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, dev, 0,
	cpufreq_settings_sysctl, "A", "CPU frequency driver settings");

	/*
	Index: sys/kern/kern_fail.c
	===================================================================
	--- sys/kern/kern_fail.c
	+++ sys/kern/kern_fail.c
	@@ -1142,5 +1142,6 @@
	return (0);
	}
	SYSCTL_OID(_debug_fail_point, OID_AUTO, test_trigger_fail_point,
	- CTLTYPE_STRING \| CTLFLAG_RD, NULL, 0, sysctl_test_fail_point, "A",
	- "Trigger test fail points");
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_test_fail_point, "A",
	+ "Trigger test fail points");
	Index: sys/kern/kern_ffclock.c
	===================================================================
	--- sys/kern/kern_ffclock.c
	+++ sys/kern/kern_ffclock.c
	@@ -191,7 +191,8 @@
	return (error);
	}

	-SYSCTL_PROC(_kern_sysclock, OID_AUTO, available, CTLTYPE_STRING \| CTLFLAG_RD,
	+SYSCTL_PROC(_kern_sysclock, OID_AUTO, available,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_kern_sysclock_available, "A",
	"List of available system clocks");

	@@ -231,7 +232,8 @@
	return (error);
	}

	-SYSCTL_PROC(_kern_sysclock, OID_AUTO, active, CTLTYPE_STRING \| CTLFLAG_RW,
	+SYSCTL_PROC(_kern_sysclock, OID_AUTO, active,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_kern_sysclock_active, "A",
	"Name of the active system clock which is currently serving time");

	Index: sys/kern/kern_fork.c
	===================================================================
	--- sys/kern/kern_fork.c
	+++ sys/kern/kern_fork.c
	@@ -236,8 +236,10 @@
	return (error);
	}

	-SYSCTL_PROC(_kern, OID_AUTO, randompid, CTLTYPE_INT\|CTLFLAG_RW,
	- 0, 0, sysctl_kern_randompid, "I", "Random PID modulus. Special values: 0: disable, 1: choose random value");
	+SYSCTL_PROC(_kern, OID_AUTO, randompid,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_kern_randompid, "I",
	+ "Random PID modulus. Special values: 0: disable, 1: choose random value");

	extern bitstr_t proc_id_pidmap;
	extern bitstr_t proc_id_grpidmap;
	Index: sys/kern/kern_intr.c
	===================================================================
	--- sys/kern/kern_intr.c
	+++ sys/kern/kern_intr.c
	@@ -1574,8 +1574,10 @@
	return (sysctl_handle_opaque(oidp, intrnames, sintrnames, req));
	}

	-SYSCTL_PROC(_hw, OID_AUTO, intrnames, CTLTYPE_OPAQUE \| CTLFLAG_RD,
	- NULL, 0, sysctl_intrnames, "", "Interrupt Names");
	+SYSCTL_PROC(_hw, OID_AUTO, intrnames,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_intrnames, "",
	+ "Interrupt Names");

	static int
	sysctl_intrcnt(SYSCTL_HANDLER_ARGS)
	@@ -1601,8 +1603,10 @@
	return (sysctl_handle_opaque(oidp, intrcnt, sintrcnt, req));
	}

	-SYSCTL_PROC(_hw, OID_AUTO, intrcnt, CTLTYPE_OPAQUE \| CTLFLAG_RD,
	- NULL, 0, sysctl_intrcnt, "", "Interrupt Counts");
	+SYSCTL_PROC(_hw, OID_AUTO, intrcnt,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_intrcnt, "",
	+ "Interrupt Counts");

	#ifdef DDB
	/*
	Index: sys/kern/kern_ktr.c
	===================================================================
	--- sys/kern/kern_ktr.c
	+++ sys/kern/kern_ktr.c
	@@ -150,8 +150,10 @@

	return (error);
	}
	-SYSCTL_PROC(_debug_ktr, OID_AUTO, clear, CTLTYPE_INT\|CTLFLAG_RW, 0, 0,
	- sysctl_debug_ktr_clear, "I", "Clear KTR Buffer");
	+SYSCTL_PROC(_debug_ktr, OID_AUTO, clear,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_debug_ktr_clear, "I",
	+ "Clear KTR Buffer");

	/*
	* This is a sysctl proc so that it is serialized as !MPSAFE along with
	@@ -171,8 +173,9 @@
	return (error);
	}

	-SYSCTL_PROC(_debug_ktr, OID_AUTO, mask, CTLTYPE_U64 \| CTLFLAG_RWTUN, 0, 0,
	- sysctl_debug_ktr_mask, "QU",
	+SYSCTL_PROC(_debug_ktr, OID_AUTO, mask,
	+ CTLTYPE_U64 \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_debug_ktr_mask, "QU",
	"Bitmask of KTR event classes for which logging is enabled");

	#if KTR_ENTRIES > KTR_BOOT_ENTRIES
	@@ -242,8 +245,10 @@
	return (error);
	}

	-SYSCTL_PROC(_debug_ktr, OID_AUTO, entries, CTLTYPE_INT\|CTLFLAG_RW, 0, 0,
	- sysctl_debug_ktr_entries, "I", "Number of entries in the KTR buffer");
	+SYSCTL_PROC(_debug_ktr, OID_AUTO, entries,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_debug_ktr_entries, "I",
	+ "Number of entries in the KTR buffer");

	#ifdef KTR_VERBOSE
	int ktr_verbose = KTR_VERBOSE;
	@@ -305,8 +310,9 @@
	return (error);
	}
	SYSCTL_PROC(_debug_ktr, OID_AUTO, alq_enable,
	- CTLTYPE_INT\|CTLFLAG_RW, 0, 0, sysctl_debug_ktr_alq_enable,
	- "I", "Enable KTR logging");
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_debug_ktr_alq_enable, "I",
	+ "Enable KTR logging");
	#endif

	void
	Index: sys/kern/kern_ktrace.c
	===================================================================
	--- sys/kern/kern_ktrace.c
	+++ sys/kern/kern_ktrace.c
	@@ -233,7 +233,8 @@
	return (ENOSPC);
	return (0);
	}
	-SYSCTL_PROC(_kern_ktrace, OID_AUTO, request_pool, CTLTYPE_UINT\|CTLFLAG_RW,
	+SYSCTL_PROC(_kern_ktrace, OID_AUTO, request_pool,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ktr_requestpool, 0, sysctl_kern_ktrace_request_pool, "IU",
	"Pool buffer size for ktrace(1)");

	Index: sys/kern/kern_linker.c
	===================================================================
	--- sys/kern/kern_linker.c
	+++ sys/kern/kern_linker.c
	@@ -2259,5 +2259,7 @@
	return (SYSCTL_OUT(req, "", 1));
	}

	-SYSCTL_PROC(_kern, OID_AUTO, function_list, CTLTYPE_OPAQUE \| CTLFLAG_RD,
	- NULL, 0, sysctl_kern_function_list, "", "kernel function list");
	+SYSCTL_PROC(_kern, OID_AUTO, function_list,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_kern_function_list, "",
	+ "kernel function list");
	Index: sys/kern/kern_malloc.c
	===================================================================
	--- sys/kern/kern_malloc.c
	+++ sys/kern/kern_malloc.c
	@@ -1226,7 +1226,8 @@
	return (error);
	}

	-SYSCTL_PROC(_kern, OID_AUTO, malloc_stats, CTLFLAG_RD\|CTLTYPE_STRUCT,
	+SYSCTL_PROC(_kern, OID_AUTO, malloc_stats,
	+ CTLFLAG_RD \| CTLTYPE_STRUCT \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_kern_malloc_stats, "s,malloc_type_ustats",
	"Return malloc types");

	@@ -1431,6 +1432,8 @@
	return (error);
	}

	-SYSCTL_OID(_kern, OID_AUTO, mprof, CTLTYPE_STRING\|CTLFLAG_RD,
	- NULL, 0, sysctl_kern_mprof, "A", "Malloc Profiling");
	+SYSCTL_OID(_kern, OID_AUTO, mprof,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_kern_mprof, "A",
	+ "Malloc Profiling");
	#endif /* MALLOC_PROFILE */
	Index: sys/kern/kern_mbuf.c
	===================================================================
	--- sys/kern/kern_mbuf.c
	+++ sys/kern/kern_mbuf.c
	@@ -193,8 +193,9 @@
	}
	return (error);
	}
	-SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbclusters, CTLTYPE_INT\|CTLFLAG_RW,
	-&nmbclusters, 0, sysctl_nmbclusters, "IU",
	+SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbclusters,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &nmbclusters, 0, sysctl_nmbclusters, "IU",
	"Maximum number of mbuf clusters allowed");

	static int
	@@ -214,8 +215,9 @@
	}
	return (error);
	}
	-SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbjumbop, CTLTYPE_INT\|CTLFLAG_RW,
	-&nmbjumbop, 0, sysctl_nmbjumbop, "IU",
	+SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbjumbop,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &nmbjumbop, 0, sysctl_nmbjumbop, "IU",
	"Maximum number of mbuf page size jumbo clusters allowed");

	static int
	@@ -235,8 +237,9 @@
	}
	return (error);
	}
	-SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbjumbo9, CTLTYPE_INT\|CTLFLAG_RW,
	-&nmbjumbo9, 0, sysctl_nmbjumbo9, "IU",
	+SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbjumbo9,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &nmbjumbo9, 0, sysctl_nmbjumbo9, "IU",
	"Maximum number of mbuf 9k jumbo clusters allowed");

	static int
	@@ -256,8 +259,9 @@
	}
	return (error);
	}
	-SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbjumbo16, CTLTYPE_INT\|CTLFLAG_RW,
	-&nmbjumbo16, 0, sysctl_nmbjumbo16, "IU",
	+SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbjumbo16,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &nmbjumbo16, 0, sysctl_nmbjumbo16, "IU",
	"Maximum number of mbuf 16k jumbo clusters allowed");

	static int
	@@ -277,8 +281,9 @@
	}
	return (error);
	}
	-SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbufs, CTLTYPE_INT\|CTLFLAG_RW,
	-&nmbufs, 0, sysctl_nmbufs, "IU",
	+SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbufs,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &nmbufs, 0, sysctl_nmbufs, "IU",
	"Maximum number of mbufs allowed");

	/*
	Index: sys/kern/kern_mib.c
	===================================================================
	--- sys/kern/kern_mib.c
	+++ sys/kern/kern_mib.c
	@@ -182,7 +182,8 @@
	val = ctob(p);
	return (sysctl_handle_long(oidp, &val, 0, req));
	}
	-SYSCTL_PROC(_hw, HW_PHYSMEM, physmem, CTLTYPE_ULONG \| CTLFLAG_RD,
	+SYSCTL_PROC(_hw, HW_PHYSMEM, physmem,
	+ CTLTYPE_ULONG \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_hw_physmem, "LU",
	"Amount of physical memory (in bytes)");

	@@ -197,7 +198,8 @@
	val = ctob(p);
	return (sysctl_handle_long(oidp, &val, 0, req));
	}
	-SYSCTL_PROC(_hw, HW_REALMEM, realmem, CTLTYPE_ULONG \| CTLFLAG_RD,
	+SYSCTL_PROC(_hw, HW_REALMEM, realmem,
	+ CTLTYPE_ULONG \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_hw_realmem, "LU",
	"Amount of memory (in bytes) reported by the firmware");

	@@ -213,7 +215,8 @@
	val = ctob(p);
	return (sysctl_handle_long(oidp, &val, 0, req));
	}
	-SYSCTL_PROC(_hw, HW_USERMEM, usermem, CTLTYPE_ULONG \| CTLFLAG_RD,
	+SYSCTL_PROC(_hw, HW_USERMEM, usermem,
	+ CTLTYPE_ULONG \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_hw_usermem, "LU",
	"Amount of memory (in bytes) which is not wired");

	@@ -244,8 +247,10 @@
	error = SYSCTL_OUT(req, pagesizes, sizeof(pagesizes));
	return (error);
	}
	-SYSCTL_PROC(_hw, OID_AUTO, pagesizes, CTLTYPE_ULONG \| CTLFLAG_RD,
	- NULL, 0, sysctl_hw_pagesizes, "LU", "Supported page sizes");
	+SYSCTL_PROC(_hw, OID_AUTO, pagesizes,
	+ CTLTYPE_ULONG \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_hw_pagesizes, "LU",
	+ "Supported page sizes");

	#ifdef SCTL_MASK32
	int adaptive_machine_arch = 1;
	@@ -393,8 +398,9 @@
	}

	SYSCTL_PROC(_kern, KERN_SECURELVL, securelevel,
	- CTLTYPE_INT\|CTLFLAG_RW\|CTLFLAG_PRISON, 0, 0, sysctl_kern_securelvl,
	- "I", "Current secure level");
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_PRISON \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_kern_securelvl, "I",
	+ "Current secure level");

	#ifdef INCLUDE_CONFIG_FILE
	/* Actual kernel configuration options. */
	Index: sys/kern/kern_poll.c
	===================================================================
	--- sys/kern/kern_poll.c
	+++ sys/kern/kern_poll.c
	@@ -131,8 +131,10 @@

	return (0);
	}
	-SYSCTL_PROC(_kern_polling, OID_AUTO, burst_max, CTLTYPE_UINT \| CTLFLAG_RW,
	- 0, sizeof(uint32_t), poll_burst_max_sysctl, "I", "Max Polling burst size");
	+SYSCTL_PROC(_kern_polling, OID_AUTO, burst_max,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof(uint32_t), poll_burst_max_sysctl, "I",
	+ "Max Polling burst size");

	static int poll_each_burst_sysctl(SYSCTL_HANDLER_ARGS)
	{
	@@ -155,9 +157,10 @@

	return (0);
	}
	-SYSCTL_PROC(_kern_polling, OID_AUTO, each_burst, CTLTYPE_UINT \| CTLFLAG_RW,
	- 0, sizeof(uint32_t), poll_each_burst_sysctl, "I",
	- "Max size of each burst");
	+SYSCTL_PROC(_kern_polling, OID_AUTO, each_burst,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof(uint32_t), poll_each_burst_sysctl, "I",
	+ "Max size of each burst");

	static uint32_t poll_in_idle_loop=0; /* do we poll in idle loop ? */
	SYSCTL_UINT(_kern_polling, OID_AUTO, idle_poll, CTLFLAG_RW,
	@@ -181,9 +184,10 @@

	return (0);
	}
	-SYSCTL_PROC(_kern_polling, OID_AUTO, user_frac, CTLTYPE_UINT \| CTLFLAG_RW,
	- 0, sizeof(uint32_t), user_frac_sysctl, "I",
	- "Desired user fraction of cpu time");
	+SYSCTL_PROC(_kern_polling, OID_AUTO, user_frac,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof(uint32_t), user_frac_sysctl, "I",
	+ "Desired user fraction of cpu time");

	static uint32_t reg_frac_count = 0;
	static uint32_t reg_frac = 20 ;
	@@ -206,9 +210,10 @@

	return (0);
	}
	-SYSCTL_PROC(_kern_polling, OID_AUTO, reg_frac, CTLTYPE_UINT \| CTLFLAG_RW,
	- 0, sizeof(uint32_t), reg_frac_sysctl, "I",
	- "Every this many cycles check registers");
	+SYSCTL_PROC(_kern_polling, OID_AUTO, reg_frac,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof(uint32_t), reg_frac_sysctl, "I",
	+ "Every this many cycles check registers");

	static uint32_t short_ticks;
	SYSCTL_UINT(_kern_polling, OID_AUTO, short_ticks, CTLFLAG_RD,
	Index: sys/kern/kern_prot.c
	===================================================================
	--- sys/kern/kern_prot.c
	+++ sys/kern/kern_prot.c
	@@ -1678,8 +1678,8 @@
	* systems.
	*/
	SYSCTL_PROC(_security_bsd, OID_AUTO, unprivileged_proc_debug,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_PRISON \| CTLFLAG_SECURE, 0, 0,
	- sysctl_unprivileged_proc_debug, "I",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_PRISON \| CTLFLAG_SECURE \|
	+ CTLFLAG_NEEDGIANT, 0, 0, sysctl_unprivileged_proc_debug, "I",
	"Unprivileged processes may use process debugging facilities");

	/*-
	Index: sys/kern/kern_rctl.c
	===================================================================
	--- sys/kern/kern_rctl.c
	+++ sys/kern/kern_rctl.c
	@@ -104,19 +104,23 @@
	SYSCTL_UINT(_kern_racct_rctl, OID_AUTO, devctl_rate_limit, CTLFLAG_RWTUN,
	&rctl_devctl_rate_limit, 0, "Maximum number of devctl messages per second");
	SYSCTL_PROC(_kern_racct_rctl, OID_AUTO, throttle_min,
	- CTLTYPE_UINT \| CTLFLAG_RWTUN, 0, 0, &rctl_throttle_min_sysctl, "IU",
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ 0, 0, &rctl_throttle_min_sysctl, "IU",
	"Shortest throttling duration, in hz");
	TUNABLE_INT("kern.racct.rctl.throttle_min", &rctl_throttle_min);
	SYSCTL_PROC(_kern_racct_rctl, OID_AUTO, throttle_max,
	- CTLTYPE_UINT \| CTLFLAG_RWTUN, 0, 0, &rctl_throttle_max_sysctl, "IU",
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ 0, 0, &rctl_throttle_max_sysctl, "IU",
	"Longest throttling duration, in hz");
	TUNABLE_INT("kern.racct.rctl.throttle_max", &rctl_throttle_max);
	SYSCTL_PROC(_kern_racct_rctl, OID_AUTO, throttle_pct,
	- CTLTYPE_UINT \| CTLFLAG_RWTUN, 0, 0, &rctl_throttle_pct_sysctl, "IU",
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ 0, 0, &rctl_throttle_pct_sysctl, "IU",
	"Throttling penalty for process consumption, in percent");
	TUNABLE_INT("kern.racct.rctl.throttle_pct", &rctl_throttle_pct);
	SYSCTL_PROC(_kern_racct_rctl, OID_AUTO, throttle_pct2,
	- CTLTYPE_UINT \| CTLFLAG_RWTUN, 0, 0, &rctl_throttle_pct2_sysctl, "IU",
	+ CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ 0, 0, &rctl_throttle_pct2_sysctl, "IU",
	"Throttling penalty for container consumption, in percent");
	TUNABLE_INT("kern.racct.rctl.throttle_pct2", &rctl_throttle_pct2);

	Index: sys/kern/kern_sendfile.c
	===================================================================
	--- sys/kern/kern_sendfile.c
	+++ sys/kern/kern_sendfile.c
	@@ -125,8 +125,10 @@
	COUNTER_ARRAY_ZERO(sfstat, sizeof(s) / sizeof(uint64_t));
	return (SYSCTL_OUT(req, &s, sizeof(s)));
	}
	-SYSCTL_PROC(_kern_ipc, OID_AUTO, sfstat, CTLTYPE_OPAQUE \| CTLFLAG_RW,
	- NULL, 0, sfstat_sysctl, "I", "sendfile statistics");
	+SYSCTL_PROC(_kern_ipc, OID_AUTO, sfstat,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sfstat_sysctl, "I",
	+ "sendfile statistics");

	static void
	sendfile_free_mext(struct mbuf *m)
	Index: sys/kern/kern_shutdown.c
	===================================================================
	--- sys/kern/kern_shutdown.c
	+++ sys/kern/kern_shutdown.c
	@@ -734,8 +734,9 @@
	static int kassert_sysctl_kassert(SYSCTL_HANDLER_ARGS);

	SYSCTL_PROC(_debug_kassert, OID_AUTO, kassert,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE, NULL, 0,
	- kassert_sysctl_kassert, "I", "set to trigger a test kassert");
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, kassert_sysctl_kassert, "I",
	+ "set to trigger a test kassert");

	static int
	kassert_sysctl_kassert(SYSCTL_HANDLER_ARGS)
	@@ -1011,7 +1012,8 @@
	sbuf_delete(&sb);
	return (error);
	}
	-SYSCTL_PROC(_kern_shutdown, OID_AUTO, dumpdevname, CTLTYPE_STRING \| CTLFLAG_RD,
	+SYSCTL_PROC(_kern_shutdown, OID_AUTO, dumpdevname,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&dumper_configs, 0, dumpdevname_sysctl_handler, "A",
	"Device(s) for kernel dumps");

	Index: sys/kern/kern_sig.c
	===================================================================
	--- sys/kern/kern_sig.c
	+++ sys/kern/kern_sig.c
	@@ -3310,9 +3310,10 @@
	num_cores = new_val;
	return (0);
	}
	-SYSCTL_PROC(_debug, OID_AUTO, ncores, CTLTYPE_INT\|CTLFLAG_RW,
	- 0, sizeof(int), sysctl_debug_num_cores_check, "I",
	- "Maximum number of generated process corefiles while using index format");
	+SYSCTL_PROC(_debug, OID_AUTO, ncores,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof(int), sysctl_debug_num_cores_check, "I",
	+ "Maximum number of generated process corefiles while using index format");

	#define GZIP_SUFFIX ".gz"
	#define ZSTD_SUFFIX ".zst"
	@@ -3333,7 +3334,8 @@
	compress_user_cores = val;
	return (error);
	}
	-SYSCTL_PROC(_kern, OID_AUTO, compress_user_cores, CTLTYPE_INT \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_kern, OID_AUTO, compress_user_cores,
	+ CTLTYPE_INT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	0, sizeof(int), sysctl_compress_user_cores, "I",
	"Enable compression of user corefiles ("
	__XSTRING(COMPRESS_GZIP) " = gzip, "
	Index: sys/kern/kern_switch.c
	===================================================================
	--- sys/kern/kern_switch.c
	+++ sys/kern/kern_switch.c
	@@ -142,8 +142,10 @@
	return (0);
	}

	-SYSCTL_PROC(_kern_sched_stats, OID_AUTO, reset, CTLTYPE_INT \| CTLFLAG_WR, NULL,
	- 0, sysctl_stats_reset, "I", "Reset scheduler statistics");
	+SYSCTL_PROC(_kern_sched_stats, OID_AUTO, reset,
	+ CTLTYPE_INT \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_stats_reset, "I",
	+ "Reset scheduler statistics");
	#endif

	/************************************************************************
	Index: sys/kern/kern_sysctl.c
	===================================================================
	--- sys/kern/kern_sysctl.c
	+++ sys/kern/kern_sysctl.c
	@@ -96,9 +96,13 @@
	* The sysctlmemlock is used to limit the amount of user memory wired for
	* sysctl requests. This is implemented by serializing any userland
	* sysctl requests larger than a single page via an exclusive lock.
	+ *
	+ * The sysctlstringlock is used to protect concurrent access to writable
	+ * string nodes in sysctl_handle_string().
	*/
	static struct rmlock sysctllock;
	static struct sx __exclusive_cache_line sysctlmemlock;
	+static struct sx sysctlstringlock;

	#define SYSCTL_WLOCK() rm_wlock(&sysctllock)
	#define SYSCTL_WUNLOCK() rm_wunlock(&sysctllock)
	@@ -170,10 +174,16 @@
	else
	SYSCTL_WUNLOCK();

	- if (!(oid->oid_kind & CTLFLAG_MPSAFE))
	+ /*
	+ * Temporary compatibilty with 3rd party software defining
	+ * CTLFLAG_MPSAFE and/or until we decide to drop this flag.
	+ */
	+ if ((oid->oid_kind & CTLFLAG_NEEDGIANT) \|\|
	+ !(oid->oid_kind & CTLFLAG_MPSAFE))
	mtx_lock(&Giant);
	error = oid->oid_handler(oid, arg1, arg2, req);
	- if (!(oid->oid_kind & CTLFLAG_MPSAFE))
	+ if ((oid->oid_kind & CTLFLAG_NEEDGIANT) \|\|
	+ !(oid->oid_kind & CTLFLAG_MPSAFE))
	mtx_unlock(&Giant);

	KFAIL_POINT_ERROR(_debug_fail_point, sysctl_running, error);
	@@ -918,6 +928,7 @@
	struct sysctl_oid **oidp;

	sx_init(&sysctlmemlock, "sysctl mem");
	+ sx_init(&sysctlstringlock, "sysctl string handler");
	SYSCTL_INIT();
	SYSCTL_WLOCK();
	SET_FOREACH(oidp, sysctl_set)
	@@ -1639,11 +1650,12 @@
	int error = 0, ro_string = 0;

	/*
	+ * If the sysctl isn't writable, treat it as a read-only string.
	* A zero-length buffer indicates a fixed size read-only
	* string. In ddb, don't worry about trying to make a malloced
	* snapshot.
	*/
	- if (arg2 == 0 \|\| kdb_active) {
	+ if ((CTLFLAG_WR & ~(oidp->oid_kind)) \|\| arg2 == 0 \|\| kdb_active) {
	arg2 = strlen((char *)arg1) + 1;
	ro_string = 1;
	}
	@@ -1653,19 +1665,25 @@

	if (ro_string) {
	tmparg = arg1;
	+ outlen = strlen(tmparg) + 1;
	} else {
	- /* try to make a coherent snapshot of the string */
	tmparg = malloc(arg2, M_SYSCTLTMP, M_WAITOK);
	+ sx_slock(&sysctlstringlock);
	memcpy(tmparg, arg1, arg2);
	+ outlen = strnlen(tmparg, arg2 - 1) + 1;
	+ sx_sunlock(&sysctlstringlock);
	}

	- outlen = strnlen(tmparg, arg2 - 1) + 1;
	error = SYSCTL_OUT(req, tmparg, outlen);

	if (!ro_string)
	free(tmparg, M_SYSCTLTMP);
	} else {
	+ if (!ro_string)
	+ sx_slock(&sysctlstringlock);
	outlen = strnlen((char *)arg1, arg2 - 1) + 1;
	+ if (!ro_string)
	+ sx_sunlock(&sysctlstringlock);
	error = SYSCTL_OUT(req, NULL, outlen);
	}
	if (error \|\| !req->newptr)
	@@ -1674,9 +1692,11 @@
	if ((req->newlen - req->newidx) >= arg2) {
	error = EINVAL;
	} else {
	+ sx_xlock(&sysctlstringlock);
	arg2 = (req->newlen - req->newidx);
	error = SYSCTL_IN(req, arg1, arg2);
	((char *)arg1)[arg2] = '\0';
	+ sx_xunlock(&sysctlstringlock);
	}
	return (error);
	}
	Index: sys/kern/kern_tc.c
	===================================================================
	--- sys/kern/kern_tc.c
	+++ sys/kern/kern_tc.c
	@@ -102,8 +102,10 @@
	volatile time_t time_uptime = 1;

	static int sysctl_kern_boottime(SYSCTL_HANDLER_ARGS);
	-SYSCTL_PROC(_kern, KERN_BOOTTIME, boottime, CTLTYPE_STRUCT\|CTLFLAG_RD,
	- NULL, 0, sysctl_kern_boottime, "S,timeval", "System boottime");
	+SYSCTL_PROC(_kern, KERN_BOOTTIME, boottime,
	+ CTLTYPE_STRUCT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_kern_boottime, "S,timeval",
	+ "System boottime");

	SYSCTL_NODE(_kern, OID_AUTO, timecounter, CTLFLAG_RW, 0, "");
	static SYSCTL_NODE(_kern_timecounter, OID_AUTO, tc, CTLFLAG_RW, 0, "");
	@@ -1233,10 +1235,12 @@
	"mask", CTLFLAG_RD, &(tc->tc_counter_mask), 0,
	"mask for implemented bits");
	SYSCTL_ADD_PROC(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
	- "counter", CTLTYPE_UINT \| CTLFLAG_RD, tc, sizeof(*tc),
	+ "counter",
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, tc, sizeof(*tc),
	sysctl_kern_timecounter_get, "IU", "current timecounter value");
	SYSCTL_ADD_PROC(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
	- "frequency", CTLTYPE_U64 \| CTLFLAG_RD, tc, sizeof(*tc),
	+ "frequency",
	+ CTLTYPE_U64 \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, tc, sizeof(*tc),
	sysctl_kern_timecounter_freq, "QU", "timecounter frequency");
	SYSCTL_ADD_INT(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
	"quality", CTLFLAG_RD, &(tc->tc_quality), 0,
	@@ -1536,7 +1540,8 @@
	return (EINVAL);
	}

	-SYSCTL_PROC(_kern_timecounter, OID_AUTO, hardware, CTLTYPE_STRING \| CTLFLAG_RW,
	+SYSCTL_PROC(_kern_timecounter, OID_AUTO, hardware,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_kern_timecounter_hardware, "A",
	"Timecounter hardware selected");

	@@ -1560,8 +1565,10 @@
	return (error);
	}

	-SYSCTL_PROC(_kern_timecounter, OID_AUTO, choice, CTLTYPE_STRING \| CTLFLAG_RD,
	- 0, 0, sysctl_kern_timecounter_choice, "A", "Timecounter hardware detected");
	+SYSCTL_PROC(_kern_timecounter, OID_AUTO, choice,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_kern_timecounter_choice, "A",
	+ "Timecounter hardware detected");

	/*
	* RFC 2783 PPS-API implementation.
	Index: sys/kern/posix4_mib.c
	===================================================================
	--- sys/kern/posix4_mib.c
	+++ sys/kern/posix4_mib.c
	@@ -62,8 +62,9 @@
	SYSCTL_INT(_p1003_1b, num, name, CTLFLAG_RD \| CTLFLAG_CAPRD, \
	facility + num - 1, 0, "");
	#define P1B_SYSCTL_RW(num, name) \
	- SYSCTL_PROC(_p1003_1b, num, name, CTLTYPE_INT \| CTLFLAG_RW, NULL, num, \
	- p31b_sysctl_proc, "I", "");
	+ SYSCTL_PROC(_p1003_1b, num, name, \
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, \
	+ NULL, num, p31b_sysctl_proc, "I", "");

	#else

	Index: sys/kern/sched_4bsd.c
	===================================================================
	--- sys/kern/sched_4bsd.c
	+++ sys/kern/sched_4bsd.c
	@@ -213,7 +213,8 @@

	SYSCTL_STRING(_kern_sched, OID_AUTO, name, CTLFLAG_RD, "4BSD", 0,
	"Scheduler name");
	-SYSCTL_PROC(_kern_sched, OID_AUTO, quantum, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_kern_sched, OID_AUTO, quantum,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	NULL, 0, sysctl_kern_quantum, "I",
	"Quantum for timeshare threads in microseconds");
	SYSCTL_INT(_kern_sched, OID_AUTO, slice, CTLFLAG_RW, &sched_slice, 0,
	Index: sys/kern/sched_ule.c
	===================================================================
	--- sys/kern/sched_ule.c
	+++ sys/kern/sched_ule.c
	@@ -3080,7 +3080,8 @@
	SYSCTL_NODE(_kern, OID_AUTO, sched, CTLFLAG_RW, 0, "Scheduler");
	SYSCTL_STRING(_kern_sched, OID_AUTO, name, CTLFLAG_RD, "ULE", 0,
	"Scheduler name");
	-SYSCTL_PROC(_kern_sched, OID_AUTO, quantum, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_kern_sched, OID_AUTO, quantum,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	NULL, 0, sysctl_kern_quantum, "I",
	"Quantum for timeshare threads in microseconds");
	SYSCTL_INT(_kern_sched, OID_AUTO, slice, CTLFLAG_RW, &sched_slice, 0,
	Index: sys/kern/subr_bus.c
	===================================================================
	--- sys/kern/subr_bus.c
	+++ sys/kern/subr_bus.c
	@@ -240,7 +240,8 @@
	SYSCTL_STATIC_CHILDREN(_dev), OID_AUTO, dc->name,
	CTLFLAG_RD, NULL, "");
	SYSCTL_ADD_PROC(&dc->sysctl_ctx, SYSCTL_CHILDREN(dc->sysctl_tree),
	- OID_AUTO, "%parent", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "%parent",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dc, DEVCLASS_SYSCTL_PARENT, devclass_sysctl_handler, "A",
	"parent class");
	}
	@@ -304,23 +305,28 @@
	dev->nameunit + strlen(dc->name),
	CTLFLAG_RD, NULL, "", "device_index");
	SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
	- OID_AUTO, "%desc", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "%desc",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev, DEVICE_SYSCTL_DESC, device_sysctl_handler, "A",
	"device description");
	SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
	- OID_AUTO, "%driver", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "%driver",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev, DEVICE_SYSCTL_DRIVER, device_sysctl_handler, "A",
	"device driver name");
	SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
	- OID_AUTO, "%location", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "%location",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev, DEVICE_SYSCTL_LOCATION, device_sysctl_handler, "A",
	"device location relative to parent");
	SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
	- OID_AUTO, "%pnpinfo", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "%pnpinfo",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev, DEVICE_SYSCTL_PNPINFO, device_sysctl_handler, "A",
	"device identification");
	SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
	- OID_AUTO, "%parent", CTLTYPE_STRING \| CTLFLAG_RD,
	+ OID_AUTO, "%parent",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev, DEVICE_SYSCTL_PARENT, device_sysctl_handler, "A",
	"parent device");
	if (bus_get_domain(dev, &domain) == 0)
	Index: sys/kern/subr_devstat.c
	===================================================================
	--- sys/kern/subr_devstat.c
	+++ sys/kern/subr_devstat.c
	@@ -439,8 +439,10 @@
	static SYSCTL_NODE(_kern, OID_AUTO, devstat, CTLFLAG_RD, NULL,
	"Device Statistics");

	-SYSCTL_PROC(_kern_devstat, OID_AUTO, all, CTLFLAG_RD\|CTLTYPE_OPAQUE,
	- NULL, 0, sysctl_devstat, "S,devstat", "All devices in the devstat list");
	+SYSCTL_PROC(_kern_devstat, OID_AUTO, all,
	+ CTLFLAG_RD \| CTLTYPE_OPAQUE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_devstat, "S,devstat",
	+ "All devices in the devstat list");
	/*
	* Export the number of devices in the system so that userland utilities
	* can determine how much memory to allocate to hold all the devices.
	Index: sys/kern/subr_kdb.c
	===================================================================
	--- sys/kern/subr_kdb.c
	+++ sys/kern/subr_kdb.c
	@@ -88,31 +88,40 @@

	static SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW, NULL, "KDB nodes");

	-SYSCTL_PROC(_debug_kdb, OID_AUTO, available, CTLTYPE_STRING \| CTLFLAG_RD, NULL,
	- 0, kdb_sysctl_available, "A", "list of available KDB backends");
	+SYSCTL_PROC(_debug_kdb, OID_AUTO, available,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, kdb_sysctl_available, "A",
	+ "list of available KDB backends");

	-SYSCTL_PROC(_debug_kdb, OID_AUTO, current, CTLTYPE_STRING \| CTLFLAG_RW, NULL,
	- 0, kdb_sysctl_current, "A", "currently selected KDB backend");
	+SYSCTL_PROC(_debug_kdb, OID_AUTO, current,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, kdb_sysctl_current, "A",
	+ "currently selected KDB backend");

	SYSCTL_PROC(_debug_kdb, OID_AUTO, enter,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE, NULL, 0,
	- kdb_sysctl_enter, "I", "set to enter the debugger");
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, kdb_sysctl_enter, "I",
	+ "set to enter the debugger");

	SYSCTL_PROC(_debug_kdb, OID_AUTO, panic,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE, NULL, 0,
	- kdb_sysctl_panic, "I", "set to panic the kernel");
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, kdb_sysctl_panic, "I",
	+ "set to panic the kernel");

	SYSCTL_PROC(_debug_kdb, OID_AUTO, trap,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE, NULL, 0,
	- kdb_sysctl_trap, "I", "set to cause a page fault via data access");
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, kdb_sysctl_trap, "I",
	+ "set to cause a page fault via data access");

	SYSCTL_PROC(_debug_kdb, OID_AUTO, trap_code,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE, NULL, 0,
	- kdb_sysctl_trap_code, "I", "set to cause a page fault via code access");
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, kdb_sysctl_trap_code, "I",
	+ "set to cause a page fault via code access");

	SYSCTL_PROC(_debug_kdb, OID_AUTO, stack_overflow,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE, NULL, 0,
	- kdb_sysctl_stack_overflow, "I", "set to cause a stack overflow");
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, kdb_sysctl_stack_overflow, "I",
	+ "set to cause a stack overflow");

	SYSCTL_INT(_debug_kdb, OID_AUTO, break_to_debugger,
	CTLFLAG_RWTUN \| CTLFLAG_SECURE,
	Index: sys/kern/subr_lock.c
	===================================================================
	--- sys/kern/subr_lock.c
	+++ sys/kern/subr_lock.c
	@@ -733,11 +733,17 @@
	&lock_prof_skipcount, 0, "Sample approximately every N lock acquisitions.");
	SYSCTL_INT(_debug_lock_prof, OID_AUTO, rejected, CTLFLAG_RD,
	&lock_prof_rejected, 0, "Number of rejected profiling records");
	-SYSCTL_PROC(_debug_lock_prof, OID_AUTO, stats, CTLTYPE_STRING \| CTLFLAG_RD,
	- NULL, 0, dump_lock_prof_stats, "A", "Lock profiling statistics");
	-SYSCTL_PROC(_debug_lock_prof, OID_AUTO, reset, CTLTYPE_INT \| CTLFLAG_RW,
	- NULL, 0, reset_lock_prof_stats, "I", "Reset lock profiling statistics");
	-SYSCTL_PROC(_debug_lock_prof, OID_AUTO, enable, CTLTYPE_INT \| CTLFLAG_RW,
	- NULL, 0, enable_lock_prof, "I", "Enable lock profiling");
	+SYSCTL_PROC(_debug_lock_prof, OID_AUTO, stats,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, dump_lock_prof_stats, "A",
	+ "Lock profiling statistics");
	+SYSCTL_PROC(_debug_lock_prof, OID_AUTO, reset,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, reset_lock_prof_stats, "I",
	+ "Reset lock profiling statistics");
	+SYSCTL_PROC(_debug_lock_prof, OID_AUTO, enable,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, enable_lock_prof, "I",
	+ "Enable lock profiling");

	#endif
	Index: sys/kern/subr_param.c
	===================================================================
	--- sys/kern/subr_param.c
	+++ sys/kern/subr_param.c
	@@ -137,7 +137,8 @@
	"Maximum stack size");
	SYSCTL_ULONG(_kern, OID_AUTO, sgrowsiz, CTLFLAG_RWTUN \| CTLFLAG_NOFETCH, &sgrowsiz, 0,
	"Amount to grow stack on a stack fault");
	-SYSCTL_PROC(_kern, OID_AUTO, vm_guest, CTLFLAG_RD \| CTLTYPE_STRING,
	+SYSCTL_PROC(_kern, OID_AUTO, vm_guest,
	+ CTLFLAG_RD \| CTLTYPE_STRING \| CTLFLAG_NEEDGIANT,
	NULL, 0, sysctl_kern_vm_guest, "A",
	"Virtual machine guest detected?");

	Index: sys/kern/subr_rtc.c
	===================================================================
	--- sys/kern/subr_rtc.c
	+++ sys/kern/subr_rtc.c
	@@ -81,7 +81,8 @@
	"Enable debug printing of RTC clock I/O; 1=reads, 2=writes, 3=both.");

	static int sysctl_clock_do_io(SYSCTL_HANDLER_ARGS);
	-SYSCTL_PROC(_debug, OID_AUTO, clock_do_io, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_debug, OID_AUTO, clock_do_io,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_clock_do_io, "I",
	"Trigger one-time IO on RTC clocks; 1=read (and discard), 2=write");

	Index: sys/kern/subr_sleepqueue.c
	===================================================================
	--- sys/kern/subr_sleepqueue.c
	+++ sys/kern/subr_sleepqueue.c
	@@ -1427,13 +1427,18 @@
	return (error);
	}

	-SYSCTL_PROC(_debug_sleepq, OID_AUTO, stats, CTLTYPE_STRING \| CTLFLAG_RD,
	- NULL, 0, dump_sleepq_prof_stats, "A", "Sleepqueue profiling statistics");
	-SYSCTL_PROC(_debug_sleepq, OID_AUTO, reset, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_debug_sleepq, OID_AUTO, stats,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, dump_sleepq_prof_stats, "A",
	+ "Sleepqueue profiling statistics");
	+SYSCTL_PROC(_debug_sleepq, OID_AUTO, reset,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	NULL, 0, reset_sleepq_prof_stats, "I",
	"Reset sleepqueue profiling statistics");
	-SYSCTL_PROC(_debug_sleepq, OID_AUTO, enable, CTLTYPE_INT \| CTLFLAG_RW,
	- NULL, 0, enable_sleepq_prof, "I", "Enable sleepqueue profiling");
	+SYSCTL_PROC(_debug_sleepq, OID_AUTO, enable,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, enable_sleepq_prof, "I",
	+ "Enable sleepqueue profiling");
	#endif

	#ifdef DDB
	Index: sys/kern/subr_stats.c
	===================================================================
	--- sys/kern/subr_stats.c
	+++ sys/kern/subr_stats.c
	@@ -3896,7 +3896,8 @@
	SYSCTL_NODE(_kern, OID_AUTO, stats, CTLFLAG_RW, NULL,
	"stats(9) MIB");

	-SYSCTL_PROC(_kern_stats, OID_AUTO, templates, CTLTYPE_STRING\|CTLFLAG_RD,
	+SYSCTL_PROC(_kern_stats, OID_AUTO, templates,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	NULL, 0, stats_tpl_list_available, "A",
	"list the name/hash of all available stats(9) templates");

	Index: sys/kern/subr_witness.c
	===================================================================
	--- sys/kern/subr_witness.c
	+++ sys/kern/subr_witness.c
	@@ -372,8 +372,10 @@
	* completely disabled.
	*/
	static int witness_watch = 1;
	-SYSCTL_PROC(_debug_witness, OID_AUTO, watch, CTLFLAG_RWTUN \| CTLTYPE_INT, NULL, 0,
	- sysctl_debug_witness_watch, "I", "witness is watching lock operations");
	+SYSCTL_PROC(_debug_witness, OID_AUTO, watch,
	+ CTLFLAG_RWTUN \| CTLTYPE_INT \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_debug_witness_watch, "I",
	+ "witness is watching lock operations");

	#ifdef KDB
	/*
	@@ -424,20 +426,24 @@
	};

	static enum witness_channel witness_channel = WITNESS_CONSOLE;
	-SYSCTL_PROC(_debug_witness, OID_AUTO, output_channel, CTLTYPE_STRING \|
	- CTLFLAG_RWTUN, NULL, 0, sysctl_debug_witness_channel, "A",
	+SYSCTL_PROC(_debug_witness, OID_AUTO, output_channel,
	+ CTLTYPE_STRING \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_debug_witness_channel, "A",
	"Output channel for warnings");

	/*
	* Call this to print out the relations between locks.
	*/
	-SYSCTL_PROC(_debug_witness, OID_AUTO, fullgraph, CTLTYPE_STRING \| CTLFLAG_RD,
	- NULL, 0, sysctl_debug_witness_fullgraph, "A", "Show locks relation graphs");
	+SYSCTL_PROC(_debug_witness, OID_AUTO, fullgraph,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_debug_witness_fullgraph, "A",
	+ "Show locks relation graphs");

	/*
	* Call this to print out the witness faulty stacks.
	*/
	-SYSCTL_PROC(_debug_witness, OID_AUTO, badstacks, CTLTYPE_STRING \| CTLFLAG_RD,
	+SYSCTL_PROC(_debug_witness, OID_AUTO, badstacks,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	NULL, 0, sysctl_debug_witness_badstacks, "A", "Show bad witness stacks");

	static struct mtx w_mtx;
	Index: sys/kern/uipc_mbuf.c
	===================================================================
	--- sys/kern/uipc_mbuf.c
	+++ sys/kern/uipc_mbuf.c
	@@ -2114,10 +2114,14 @@
	}


	-SYSCTL_PROC(_kern_ipc, OID_AUTO, mbufprofile, CTLTYPE_STRING\|CTLFLAG_RD,
	- NULL, 0, mbprof_handler, "A", "mbuf profiling statistics");
	-
	-SYSCTL_PROC(_kern_ipc, OID_AUTO, mbufprofileclr, CTLTYPE_INT\|CTLFLAG_RW,
	- NULL, 0, mbprof_clr_handler, "I", "clear mbuf profiling statistics");
	+SYSCTL_PROC(_kern_ipc, OID_AUTO, mbufprofile,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, mbprof_handler, "A",
	+ "mbuf profiling statistics");
	+
	+SYSCTL_PROC(_kern_ipc, OID_AUTO, mbufprofileclr,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, mbprof_clr_handler, "I",
	+ "clear mbuf profiling statistics");
	#endif

	Index: sys/kern/uipc_sockbuf.c
	===================================================================
	--- sys/kern/uipc_sockbuf.c
	+++ sys/kern/uipc_sockbuf.c
	@@ -1523,7 +1523,9 @@
	/* This takes the place of kern.maxsockbuf, which moved to kern.ipc. */
	static int dummy;
	SYSCTL_INT(_kern, KERN_DUMMY, dummy, CTLFLAG_RW \| CTLFLAG_SKIP, &dummy, 0, "");
	-SYSCTL_OID(_kern_ipc, KIPC_MAXSOCKBUF, maxsockbuf, CTLTYPE_ULONG\|CTLFLAG_RW,
	- &sb_max, 0, sysctl_handle_sb_max, "LU", "Maximum socket buffer size");
	+SYSCTL_OID(_kern_ipc, KIPC_MAXSOCKBUF, maxsockbuf,
	+ CTLTYPE_ULONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &sb_max, 0, sysctl_handle_sb_max, "LU",
	+ "Maximum socket buffer size");
	SYSCTL_ULONG(_kern_ipc, KIPC_SOCKBUF_WASTE, sockbuf_waste_factor, CTLFLAG_RW,
	&sb_efficiency, 0, "Socket buffer size waste factor");
	Index: sys/kern/uipc_socket.c
	===================================================================
	--- sys/kern/uipc_socket.c
	+++ sys/kern/uipc_socket.c
	@@ -235,11 +235,12 @@
	somaxconn = val;
	return (0);
	}
	-SYSCTL_PROC(_kern_ipc, OID_AUTO, soacceptqueue, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_kern_ipc, OID_AUTO, soacceptqueue,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, sizeof(int), sysctl_somaxconn, "I",
	"Maximum listen socket pending connection accept queue size");
	SYSCTL_PROC(_kern_ipc, KIPC_SOMAXCONN, somaxconn,
	- CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_SKIP,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_SKIP \| CTLFLAG_NEEDGIANT,
	0, sizeof(int), sysctl_somaxconn, "I",
	"Maximum listen socket pending connection accept queue size (compat)");

	@@ -369,7 +370,8 @@
	}
	return (error);
	}
	-SYSCTL_PROC(_kern_ipc, OID_AUTO, maxsockets, CTLTYPE_INT\|CTLFLAG_RW,
	+SYSCTL_PROC(_kern_ipc, OID_AUTO, maxsockets,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&maxsockets, 0, sysctl_maxsockets, "IU",
	"Maximum number of sockets available");

	Index: sys/kern/uipc_usrreq.c
	===================================================================
	--- sys/kern/uipc_usrreq.c
	+++ sys/kern/uipc_usrreq.c
	@@ -1900,14 +1900,16 @@
	return (error);
	}

	-SYSCTL_PROC(_net_local_dgram, OID_AUTO, pcblist, CTLTYPE_OPAQUE \| CTLFLAG_RD,
	+SYSCTL_PROC(_net_local_dgram, OID_AUTO, pcblist,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	(void *)(intptr_t)SOCK_DGRAM, 0, unp_pcblist, "S,xunpcb",
	"List of active local datagram sockets");
	-SYSCTL_PROC(_net_local_stream, OID_AUTO, pcblist, CTLTYPE_OPAQUE \| CTLFLAG_RD,
	+SYSCTL_PROC(_net_local_stream, OID_AUTO, pcblist,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	(void *)(intptr_t)SOCK_STREAM, 0, unp_pcblist, "S,xunpcb",
	"List of active local stream sockets");
	SYSCTL_PROC(_net_local_seqpacket, OID_AUTO, pcblist,
	- CTLTYPE_OPAQUE \| CTLFLAG_RD,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	(void *)(intptr_t)SOCK_SEQPACKET, 0, unp_pcblist, "S,xunpcb",
	"List of active local seqpacket sockets");

	Index: sys/libkern/iconv.c
	===================================================================
	--- sys/libkern/iconv.c
	+++ sys/libkern/iconv.c
	@@ -348,8 +348,10 @@
	return error;
	}

	-SYSCTL_PROC(_kern_iconv, OID_AUTO, drvlist, CTLFLAG_RD \| CTLTYPE_OPAQUE,
	- NULL, 0, iconv_sysctl_drvlist, "S,xlat", "registered converters");
	+SYSCTL_PROC(_kern_iconv, OID_AUTO, drvlist,
	+ CTLFLAG_RD \| CTLTYPE_OPAQUE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, iconv_sysctl_drvlist, "S,xlat",
	+ "registered converters");

	/*
	* List all available charset pairs.
	@@ -379,8 +381,10 @@
	return error;
	}

	-SYSCTL_PROC(_kern_iconv, OID_AUTO, cslist, CTLFLAG_RD \| CTLTYPE_OPAQUE,
	- NULL, 0, iconv_sysctl_cslist, "S,xlat", "registered charset pairs");
	+SYSCTL_PROC(_kern_iconv, OID_AUTO, cslist,
	+ CTLFLAG_RD \| CTLTYPE_OPAQUE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, iconv_sysctl_cslist, "S,xlat",
	+ "registered charset pairs");

	int
	iconv_add(const char converter, const char to, const char *from)
	@@ -446,8 +450,10 @@
	return error;
	}

	-SYSCTL_PROC(_kern_iconv, OID_AUTO, add, CTLFLAG_RW \| CTLTYPE_OPAQUE,
	- NULL, 0, iconv_sysctl_add, "S,xlat", "register charset pair");
	+SYSCTL_PROC(_kern_iconv, OID_AUTO, add,
	+ CTLFLAG_RW \| CTLTYPE_OPAQUE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, iconv_sysctl_add, "S,xlat",
	+ "register charset pair");

	/*
	* Default stubs for converters
	Index: sys/mips/cavium/octe/mv88e61xxphy.c
	===================================================================
	--- sys/mips/cavium/octe/mv88e61xxphy.c
	+++ sys/mips/cavium/octe/mv88e61xxphy.c
	@@ -185,37 +185,37 @@
	portN_tree = SYSCTL_CHILDREN(portN_node);

	SYSCTL_ADD_PROC(ctx, portN_tree, OID_AUTO, "duplex",
	- CTLFLAG_RD \| CTLTYPE_INT, psc,
	+ CTLFLAG_RD \| CTLTYPE_INT \| CTLFLAG_NEEDGIANT, psc,
	MV88E61XXPHY_LINK_SYSCTL_DUPLEX,
	mv88e61xxphy_sysctl_link_proc, "IU",
	"Media duplex status (0 = half duplex; 1 = full duplex)");

	SYSCTL_ADD_PROC(ctx, portN_tree, OID_AUTO, "link",
	- CTLFLAG_RD \| CTLTYPE_INT, psc,
	+ CTLFLAG_RD \| CTLTYPE_INT \| CTLFLAG_NEEDGIANT, psc,
	MV88E61XXPHY_LINK_SYSCTL_LINK,
	mv88e61xxphy_sysctl_link_proc, "IU",
	"Link status (0 = down; 1 = up)");

	SYSCTL_ADD_PROC(ctx, portN_tree, OID_AUTO, "media",
	- CTLFLAG_RD \| CTLTYPE_INT, psc,
	+ CTLFLAG_RD \| CTLTYPE_INT \| CTLFLAG_NEEDGIANT, psc,
	MV88E61XXPHY_LINK_SYSCTL_MEDIA,
	mv88e61xxphy_sysctl_link_proc, "IU",
	"Media speed (0 = unknown; 10 = 10Mbps; 100 = 100Mbps; 1000 = 1Gbps)");

	SYSCTL_ADD_PROC(ctx, portN_tree, OID_AUTO, "domain",
	- CTLFLAG_RW \| CTLTYPE_INT, psc,
	+ CTLFLAG_RW \| CTLTYPE_INT \| CTLFLAG_NEEDGIANT, psc,
	MV88E61XXPHY_PORT_SYSCTL_DOMAIN,
	mv88e61xxphy_sysctl_port_proc, "IU",
	"Broadcast domain (ports can only talk to other ports in the same domain)");

	SYSCTL_ADD_PROC(ctx, portN_tree, OID_AUTO, "vlan",
	- CTLFLAG_RW \| CTLTYPE_INT, psc,
	+ CTLFLAG_RW \| CTLTYPE_INT \| CTLFLAG_NEEDGIANT, psc,
	MV88E61XXPHY_PORT_SYSCTL_VLAN,
	mv88e61xxphy_sysctl_port_proc, "IU",
	"Tag packets from/for this port with a given VLAN.");

	SYSCTL_ADD_PROC(ctx, portN_tree, OID_AUTO, "priority",
	- CTLFLAG_RW \| CTLTYPE_INT, psc,
	+ CTLFLAG_RW \| CTLTYPE_INT \| CTLFLAG_NEEDGIANT, psc,
	MV88E61XXPHY_PORT_SYSCTL_PRIORITY,
	mv88e61xxphy_sysctl_port_proc, "IU",
	"Default packet priority for this port.");
	Index: sys/mips/cavium/octeon_machdep.c
	===================================================================
	--- sys/mips/cavium/octeon_machdep.c
	+++ sys/mips/cavium/octeon_machdep.c
	@@ -446,7 +446,8 @@
	return (0);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, led_display, CTLTYPE_STRING \| CTLFLAG_WR,
	+SYSCTL_PROC(_machdep, OID_AUTO, led_display,
	+ CTLTYPE_STRING \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT,
	NULL, 0, sysctl_machdep_led_display, "A",
	"String to display on LED display");

	Index: sys/mips/ingenic/jz4780_aic.c
	===================================================================
	--- sys/mips/ingenic/jz4780_aic.c
	+++ sys/mips/ingenic/jz4780_aic.c
	@@ -769,7 +769,8 @@
	/* Create device sysctl node. */
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
	- OID_AUTO, "internal_codec", CTLTYPE_INT \| CTLFLAG_RW,
	+ OID_AUTO, "internal_codec",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	scp, 0, sysctl_hw_pcm_internal_codec, "I",
	"use internal audio codec");

	Index: sys/mips/mips/tick.c
	===================================================================
	--- sys/mips/mips/tick.c
	+++ sys/mips/mips/tick.c
	@@ -178,7 +178,8 @@
	return (error);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, counter_freq, CTLTYPE_U64 \| CTLFLAG_RW,
	+SYSCTL_PROC(_machdep, OID_AUTO, counter_freq,
	+ CTLTYPE_U64 \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	NULL, 0, sysctl_machdep_counter_freq, "QU",
	"Timecounter frequency in Hz");

	Index: sys/mips/nlm/dev/net/xlpge.c
	===================================================================
	--- sys/mips/nlm/dev/net/xlpge.c
	+++ sys/mips/nlm/dev/net/xlpge.c
	@@ -1161,8 +1161,8 @@

	#define XLPGE_STAT(name, offset, desc) \
	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, name, \
	- CTLTYPE_UINT \| CTLFLAG_RD, sc, offset, \
	- xlpge_stats_sysctl, "IU", desc)
	+ CTLTYPE_UINT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, \
	+ sc, offset, xlpge_stats_sysctl, "IU", desc)

	XLPGE_STAT("tr127", nlm_sgmii_stats_tr127, "TxRx 64 - 127 Bytes");
	XLPGE_STAT("tr255", nlm_sgmii_stats_tr255, "TxRx 128 - 255 Bytes");
	Index: sys/mips/nlm/tick.c
	===================================================================
	--- sys/mips/nlm/tick.c
	+++ sys/mips/nlm/tick.c
	@@ -179,7 +179,8 @@
	return (error);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, counter_freq, CTLTYPE_U64 \| CTLFLAG_RW,
	+SYSCTL_PROC(_machdep, OID_AUTO, counter_freq,
	+ CTLTYPE_U64 \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	NULL, 0, sysctl_machdep_counter_freq, "QU",
	"Timecounter frequency in Hz");

	Index: sys/net/if_bridge.c
	===================================================================
	--- sys/net/if_bridge.c
	+++ sys/net/if_bridge.c
	@@ -614,7 +614,7 @@
	return (error);
	}
	SYSCTL_PROC(_net_link_bridge, OID_AUTO, ipfw,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_VNET,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_VNET \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(pfil_ipfw), 0, &sysctl_pfil_ipfw, "I",
	"Layer2 filter with IPFW");

	Index: sys/net/if_epair.c
	===================================================================
	--- sys/net/if_epair.c
	+++ sys/net/if_epair.c
	@@ -132,7 +132,8 @@
	return (EINVAL);
	return (netisr_setqlimit(&epair_nh, qlimit));
	}
	-SYSCTL_PROC(_net_link_epair, OID_AUTO, netisr_maxqlen, CTLTYPE_INT\|CTLFLAG_RW,
	+SYSCTL_PROC(_net_link_epair, OID_AUTO, netisr_maxqlen,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_epair_netisr_maxqlen, "I",
	"Maximum if_epair(4) netisr \"hw\" queue length");

	Index: sys/net/iflib.c
	===================================================================
	--- sys/net/iflib.c
	+++ sys/net/iflib.c
	@@ -6252,7 +6252,8 @@
	info->iidi_value = value;
	SYSCTL_ADD_PROC(device_get_sysctl_ctx(ctx->ifc_dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(ctx->ifc_dev)),
	- OID_AUTO, name, CTLTYPE_INT\|CTLFLAG_RW,
	+ OID_AUTO, name,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	info, 0, iflib_sysctl_int_delay, "I", description);
	}

	@@ -6549,11 +6550,13 @@

	/* XXX change for per-queue sizes */
	SYSCTL_ADD_PROC(ctx_list, oid_list, OID_AUTO, "override_ntxds",
	- CTLTYPE_STRING\|CTLFLAG_RWTUN, ctx, IFLIB_NTXD_HANDLER,
	+ CTLTYPE_STRING \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ ctx, IFLIB_NTXD_HANDLER,
	mp_ndesc_handler, "A",
	"list of # of TX descriptors to use, 0 = use default #");
	SYSCTL_ADD_PROC(ctx_list, oid_list, OID_AUTO, "override_nrxds",
	- CTLTYPE_STRING\|CTLFLAG_RWTUN, ctx, IFLIB_NRXD_HANDLER,
	+ CTLTYPE_STRING \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	+ ctx, IFLIB_NRXD_HANDLER,
	mp_ndesc_handler, "A",
	"list of # of RX descriptors to use, 0 = use default #");
	}
	@@ -6638,7 +6641,8 @@
	CTLFLAG_RD,
	&txq->ift_cleaned, "total cleaned");
	SYSCTL_ADD_PROC(ctx_list, queue_list, OID_AUTO, "ring_state",
	- CTLTYPE_STRING \| CTLFLAG_RD, __DEVOLATILE(uint64_t *, &txq->ift_br->state),
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ __DEVOLATILE(uint64_t *, &txq->ift_br->state),
	0, mp_ring_state_handler, "A", "soft ring state");
	SYSCTL_ADD_COUNTER_U64(ctx_list, queue_list, OID_AUTO, "r_enqueues",
	CTLFLAG_RD, &txq->ift_br->enqueues,
	Index: sys/net/netisr.c
	===================================================================
	--- sys/net/netisr.c
	+++ sys/net/netisr.c
	@@ -152,7 +152,8 @@
	#define NETISR_DISPATCH_POLICY_MAXSTR 20 /* Used for temporary buffers. */
	static u_int netisr_dispatch_policy = NETISR_DISPATCH_POLICY_DEFAULT;
	static int sysctl_netisr_dispatch_policy(SYSCTL_HANDLER_ARGS);
	-SYSCTL_PROC(_net_isr, OID_AUTO, dispatch, CTLTYPE_STRING \| CTLFLAG_RWTUN,
	+SYSCTL_PROC(_net_isr, OID_AUTO, dispatch,
	+ CTLTYPE_STRING \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_netisr_dispatch_policy, "A",
	"netisr dispatch policy");

	Index: sys/net/route.c
	===================================================================
	--- sys/net/route.c
	+++ sys/net/route.c
	@@ -179,8 +179,10 @@
	return (error);
	}

	-SYSCTL_PROC(_net, OID_AUTO, my_fibnum, CTLTYPE_INT\|CTLFLAG_RD,
	- NULL, 0, &sysctl_my_fibnum, "I", "default FIB of caller");
	+SYSCTL_PROC(_net, OID_AUTO, my_fibnum,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, &sysctl_my_fibnum, "I",
	+ "default FIB of caller");

	static __inline struct rib_head **
	rt_tables_get_rnh_ptr(int table, int fam)
	Index: sys/net/rss_config.c
	===================================================================
	--- sys/net/rss_config.c
	+++ sys/net/rss_config.c
	@@ -549,5 +549,6 @@
	return (error);
	}
	SYSCTL_PROC(_net_inet_rss, OID_AUTO, bucket_mapping,
	- CTLTYPE_STRING \| CTLFLAG_RD, NULL, 0,
	- sysctl_rss_bucket_mapping, "", "RSS bucket -> CPU mapping");
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_rss_bucket_mapping, "",
	+ "RSS bucket -> CPU mapping");
	Index: sys/net/rtsock.c
	===================================================================
	--- sys/net/rtsock.c
	+++ sys/net/rtsock.c
	@@ -211,7 +211,8 @@
	return (EINVAL);
	return (netisr_setqlimit(&rtsock_nh, qlimit));
	}
	-SYSCTL_PROC(_net_route, OID_AUTO, netisr_maxqlen, CTLTYPE_INT\|CTLFLAG_RW,
	+SYSCTL_PROC(_net_route, OID_AUTO, netisr_maxqlen,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_route_netisr_maxqlen, "I",
	"maximum routing socket dispatch queue length");

	Index: sys/net/vnet.h
	===================================================================
	--- sys/net/vnet.h
	+++ sys/net/vnet.h
	@@ -141,7 +141,8 @@
	sizeof(type) / sizeof(uint64_t)); \
	return (SYSCTL_OUT(req, &s, sizeof(type))); \
	} \
	-SYSCTL_PROC(parent, nbr, name, CTLFLAG_VNET \| CTLTYPE_OPAQUE \| CTLFLAG_RW, \
	+SYSCTL_PROC(parent, nbr, name, \
	+ CTLFLAG_VNET \| CTLTYPE_OPAQUE \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, \
	NULL, 0, array ## _sysctl, "I", desc)
	#endif /* SYSCTL_OID */

	Index: sys/net80211/ieee80211_alq.c
	===================================================================
	--- sys/net80211/ieee80211_alq.c
	+++ sys/net80211/ieee80211_alq.c
	@@ -111,8 +111,10 @@
	return (ieee80211_alq_setlogging(enable));
	}

	-SYSCTL_PROC(_net_wlan, OID_AUTO, alq, CTLTYPE_INT\|CTLFLAG_RW,
	- 0, 0, sysctl_ieee80211_alq_log, "I", "Enable net80211 alq logging");
	+SYSCTL_PROC(_net_wlan, OID_AUTO, alq,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_ieee80211_alq_log, "I",
	+ "Enable net80211 alq logging");
	SYSCTL_INT(_net_wlan, OID_AUTO, alq_size, CTLFLAG_RW,
	&ieee80211_alq_qsize, 0, "In-memory log size (bytes)");
	SYSCTL_INT(_net_wlan, OID_AUTO, alq_lost, CTLFLAG_RW,
	Index: sys/net80211/ieee80211_amrr.c
	===================================================================
	--- sys/net80211/ieee80211_amrr.c
	+++ sys/net80211/ieee80211_amrr.c
	@@ -465,14 +465,16 @@
	return;

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "amrr_rate_interval", CTLTYPE_INT \| CTLFLAG_RW, vap,
	+ "amrr_rate_interval",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ vap,
	0, amrr_sysctl_interval, "I", "amrr operation interval (ms)");
	/* XXX bounds check values */
	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "amrr_max_sucess_threshold", CTLFLAG_RW,
	+ "amrr_max_sucess_threshold", CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&amrr->amrr_max_success_threshold, 0, "");
	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "amrr_min_sucess_threshold", CTLFLAG_RW,
	+ "amrr_min_sucess_threshold", CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&amrr->amrr_min_success_threshold, 0, "");
	}

	Index: sys/net80211/ieee80211_freebsd.c
	===================================================================
	--- sys/net80211/ieee80211_freebsd.c
	+++ sys/net80211/ieee80211_freebsd.c
	@@ -229,7 +229,8 @@
	oid = SYSCTL_ADD_NODE(ctx, &SYSCTL_NODE_CHILDREN(_net, wlan),
	OID_AUTO, num, CTLFLAG_RD, NULL, "");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "%parent", CTLTYPE_STRING \| CTLFLAG_RD, vap->iv_ic, 0,
	+ "%parent", CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ vap->iv_ic, 0,
	ieee80211_sysctl_parent, "A", "parent device");
	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	"driver_caps", CTLFLAG_RW, &vap->iv_caps, 0,
	@@ -245,19 +246,23 @@
	"consecutive beacon misses before scanning");
	/* XXX inherit from tunables */
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "inact_run", CTLTYPE_INT \| CTLFLAG_RW, &vap->iv_inact_run, 0,
	+ "inact_run", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &vap->iv_inact_run, 0,
	ieee80211_sysctl_inact, "I",
	"station inactivity timeout (sec)");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "inact_probe", CTLTYPE_INT \| CTLFLAG_RW, &vap->iv_inact_probe, 0,
	+ "inact_probe", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &vap->iv_inact_probe, 0,
	ieee80211_sysctl_inact, "I",
	"station inactivity probe timeout (sec)");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "inact_auth", CTLTYPE_INT \| CTLFLAG_RW, &vap->iv_inact_auth, 0,
	+ "inact_auth", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &vap->iv_inact_auth, 0,
	ieee80211_sysctl_inact, "I",
	"station authentication timeout (sec)");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "inact_init", CTLTYPE_INT \| CTLFLAG_RW, &vap->iv_inact_init, 0,
	+ "inact_init", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &vap->iv_inact_init, 0,
	ieee80211_sysctl_inact, "I",
	"station initial state timeout (sec)");
	if (vap->iv_htcaps & IEEE80211_HTC_HT) {
	@@ -280,13 +285,16 @@
	}

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "force_restart", CTLTYPE_INT \| CTLFLAG_RW, vap, 0,
	+ "force_restart",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, vap, 0,
	ieee80211_sysctl_vap_restart, "I",
	"force a VAP restart");

	if (vap->iv_caps & IEEE80211_C_DFS) {
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "radar", CTLTYPE_INT \| CTLFLAG_RW, vap->iv_ic, 0,
	+ "radar",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ vap->iv_ic, 0,
	ieee80211_sysctl_radar, "I", "simulate radar event");
	}
	vap->iv_sysctl = ctx;
	Index: sys/net80211/ieee80211_ht.c
	===================================================================
	--- sys/net80211/ieee80211_ht.c
	+++ sys/net80211/ieee80211_ht.c
	@@ -139,22 +139,25 @@
	};

	static int ieee80211_ampdu_age = -1; /* threshold for ampdu reorder q (ms) */
	-SYSCTL_PROC(_net_wlan, OID_AUTO, ampdu_age, CTLTYPE_INT \| CTLFLAG_RW,
	- &ieee80211_ampdu_age, 0, ieee80211_sysctl_msecs_ticks, "I",
	- "AMPDU max reorder age (ms)");
	+SYSCTL_PROC(_net_wlan, OID_AUTO, ampdu_age,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &ieee80211_ampdu_age, 0, ieee80211_sysctl_msecs_ticks, "I",
	+ "AMPDU max reorder age (ms)");

	static int ieee80211_recv_bar_ena = 1;
	SYSCTL_INT(_net_wlan, OID_AUTO, recv_bar, CTLFLAG_RW, &ieee80211_recv_bar_ena,
	0, "BAR frame processing (ena/dis)");

	static int ieee80211_addba_timeout = -1;/* timeout for ADDBA response */
	-SYSCTL_PROC(_net_wlan, OID_AUTO, addba_timeout, CTLTYPE_INT \| CTLFLAG_RW,
	- &ieee80211_addba_timeout, 0, ieee80211_sysctl_msecs_ticks, "I",
	- "ADDBA request timeout (ms)");
	+SYSCTL_PROC(_net_wlan, OID_AUTO, addba_timeout,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &ieee80211_addba_timeout, 0, ieee80211_sysctl_msecs_ticks, "I",
	+ "ADDBA request timeout (ms)");
	static int ieee80211_addba_backoff = -1;/* backoff after max ADDBA requests */
	-SYSCTL_PROC(_net_wlan, OID_AUTO, addba_backoff, CTLTYPE_INT \| CTLFLAG_RW,
	- &ieee80211_addba_backoff, 0, ieee80211_sysctl_msecs_ticks, "I",
	- "ADDBA request backoff (ms)");
	+SYSCTL_PROC(_net_wlan, OID_AUTO, addba_backoff,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &ieee80211_addba_backoff, 0, ieee80211_sysctl_msecs_ticks, "I",
	+ "ADDBA request backoff (ms)");
	static int ieee80211_addba_maxtries = 3;/* max ADDBA requests before backoff */
	SYSCTL_INT(_net_wlan, OID_AUTO, addba_maxtries, CTLFLAG_RW,
	&ieee80211_addba_maxtries, 0, "max ADDBA requests sent before backoff");
	Index: sys/net80211/ieee80211_hwmp.c
	===================================================================
	--- sys/net80211/ieee80211_hwmp.c
	+++ sys/net80211/ieee80211_hwmp.c
	@@ -160,33 +160,40 @@
	SYSCTL_INT(_net_wlan_hwmp, OID_AUTO, targetonly, CTLFLAG_RW,
	&ieee80211_hwmp_targetonly, 0, "Set TO bit on generated PREQs");
	static int ieee80211_hwmp_pathtimeout = -1;
	-SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, pathlifetime, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, pathlifetime,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ieee80211_hwmp_pathtimeout, 0, ieee80211_sysctl_msecs_ticks, "I",
	"path entry lifetime (ms)");
	static int ieee80211_hwmp_maxpreq_retries = -1;
	-SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, maxpreq_retries, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, maxpreq_retries,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ieee80211_hwmp_maxpreq_retries, 0, ieee80211_sysctl_msecs_ticks, "I",
	"maximum number of preq retries");
	static int ieee80211_hwmp_net_diameter_traversaltime = -1;
	SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, net_diameter_traversal_time,
	- CTLTYPE_INT \| CTLFLAG_RW, &ieee80211_hwmp_net_diameter_traversaltime, 0,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &ieee80211_hwmp_net_diameter_traversaltime, 0,
	ieee80211_sysctl_msecs_ticks, "I",
	"estimate travelse time across the MBSS (ms)");
	static int ieee80211_hwmp_roottimeout = -1;
	-SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, roottimeout, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, roottimeout,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ieee80211_hwmp_roottimeout, 0, ieee80211_sysctl_msecs_ticks, "I",
	"root PREQ timeout (ms)");
	static int ieee80211_hwmp_rootint = -1;
	-SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, rootint, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, rootint,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ieee80211_hwmp_rootint, 0, ieee80211_sysctl_msecs_ticks, "I",
	"root interval (ms)");
	static int ieee80211_hwmp_rannint = -1;
	-SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, rannint, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, rannint,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ieee80211_hwmp_rannint, 0, ieee80211_sysctl_msecs_ticks, "I",
	"root announcement interval (ms)");
	static struct timeval ieee80211_hwmp_rootconfint = { 0, 0 };
	static int ieee80211_hwmp_rootconfint_internal = -1;
	-SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, rootconfint, CTLTYPE_INT \| CTLFLAG_RD,
	+SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, rootconfint,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	&ieee80211_hwmp_rootconfint_internal, 0, ieee80211_sysctl_msecs_ticks, "I",
	"root confirmation interval (ms) (read-only)");

	@@ -205,9 +212,10 @@
	.mpp_newstate = hwmp_newstate,
	.mpp_privlen = sizeof(struct ieee80211_hwmp_route),
	};
	-SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, inact, CTLTYPE_INT \| CTLFLAG_RW,
	- &mesh_proto_hwmp.mpp_inact, 0, ieee80211_sysctl_msecs_ticks, "I",
	- "mesh route inactivity timeout (ms)");
	+SYSCTL_PROC(_net_wlan_hwmp, OID_AUTO, inact,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &mesh_proto_hwmp.mpp_inact, 0, ieee80211_sysctl_msecs_ticks, "I",
	+ "mesh route inactivity timeout (ms)");


	static void
	Index: sys/net80211/ieee80211_mesh.c
	===================================================================
	--- sys/net80211/ieee80211_mesh.c
	+++ sys/net80211/ieee80211_mesh.c
	@@ -109,24 +109,29 @@
	static SYSCTL_NODE(_net_wlan, OID_AUTO, mesh, CTLFLAG_RD, 0,
	"IEEE 802.11s parameters");
	static int ieee80211_mesh_gateint = -1;
	-SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, gateint, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, gateint,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ieee80211_mesh_gateint, 0, ieee80211_sysctl_msecs_ticks, "I",
	"mesh gate interval (ms)");
	static int ieee80211_mesh_retrytimeout = -1;
	-SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, retrytimeout, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, retrytimeout,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ieee80211_mesh_retrytimeout, 0, ieee80211_sysctl_msecs_ticks, "I",
	"Retry timeout (msec)");
	static int ieee80211_mesh_holdingtimeout = -1;

	-SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, holdingtimeout, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, holdingtimeout,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ieee80211_mesh_holdingtimeout, 0, ieee80211_sysctl_msecs_ticks, "I",
	"Holding state timeout (msec)");
	static int ieee80211_mesh_confirmtimeout = -1;
	-SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, confirmtimeout, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, confirmtimeout,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ieee80211_mesh_confirmtimeout, 0, ieee80211_sysctl_msecs_ticks, "I",
	"Confirm state timeout (msec)");
	static int ieee80211_mesh_backofftimeout = -1;
	-SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, backofftimeout, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, backofftimeout,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&ieee80211_mesh_backofftimeout, 0, ieee80211_sysctl_msecs_ticks, "I",
	"Backoff timeout (msec). This is to throutles peering forever when "
	"not receiving answer or is rejected by a neighbor");
	Index: sys/net80211/ieee80211_rssadapt.c
	===================================================================
	--- sys/net80211/ieee80211_rssadapt.c
	+++ sys/net80211/ieee80211_rssadapt.c
	@@ -381,6 +381,7 @@
	{

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "rssadapt_rate_interval", CTLTYPE_INT \| CTLFLAG_RW, vap,
	+ "rssadapt_rate_interval",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, vap,
	0, rssadapt_sysctl_interval, "I", "rssadapt operation interval (ms)");
	}
	Index: sys/net80211/ieee80211_superg.c
	===================================================================
	--- sys/net80211/ieee80211_superg.c
	+++ sys/net80211/ieee80211_superg.c
	@@ -92,9 +92,10 @@
	SYSCTL_INT(_net_wlan, OID_AUTO, ffppsmin, CTLFLAG_RW,
	&ieee80211_ffppsmin, 0, "min packet rate before fast-frame staging");
	static int ieee80211_ffagemax = -1; /* max time frames held on stage q */
	-SYSCTL_PROC(_net_wlan, OID_AUTO, ffagemax, CTLTYPE_INT \| CTLFLAG_RW,
	- &ieee80211_ffagemax, 0, ieee80211_sysctl_msecs_ticks, "I",
	- "max hold time for fast-frame staging (ms)");
	+SYSCTL_PROC(_net_wlan, OID_AUTO, ffagemax,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &ieee80211_ffagemax, 0, ieee80211_sysctl_msecs_ticks, "I",
	+ "max hold time for fast-frame staging (ms)");

	static void
	ff_age_all(void *arg, int npending)
	Index: sys/netgraph/bluetooth/common/ng_bluetooth.c
	===================================================================
	--- sys/netgraph/bluetooth/common/ng_bluetooth.c
	+++ sys/netgraph/bluetooth/common/ng_bluetooth.c
	@@ -87,7 +87,7 @@
	} /* bluetooth_set_hci_command_timeout_value */

	SYSCTL_PROC(_net_bluetooth_hci, OID_AUTO, command_timeout,
	- CTLTYPE_INT \| CTLFLAG_RW,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&bluetooth_hci_command_timeout_value, 5,
	bluetooth_set_hci_command_timeout_value,
	"I", "HCI command timeout (sec)");
	@@ -111,7 +111,7 @@
	} /* bluetooth_set_hci_connect_timeout_value */

	SYSCTL_PROC(_net_bluetooth_hci, OID_AUTO, connection_timeout,
	- CTLTYPE_INT \| CTLFLAG_RW,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&bluetooth_hci_connect_timeout_value, 60,
	bluetooth_set_hci_connect_timeout_value,
	"I", "HCI connect timeout (sec)");
	@@ -147,7 +147,7 @@
	} /* bluetooth_set_l2cap_rtx_timeout_value */

	SYSCTL_PROC(_net_bluetooth_l2cap, OID_AUTO, rtx_timeout,
	- CTLTYPE_INT \| CTLFLAG_RW,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&bluetooth_l2cap_rtx_timeout_value, 60,
	bluetooth_set_l2cap_rtx_timeout_value,
	"I", "L2CAP RTX timeout (sec)");
	@@ -171,7 +171,7 @@
	} /* bluetooth_set_l2cap_ertx_timeout_value */

	SYSCTL_PROC(_net_bluetooth_l2cap, OID_AUTO, ertx_timeout,
	- CTLTYPE_INT \| CTLFLAG_RW,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&bluetooth_l2cap_ertx_timeout_value, 300,
	bluetooth_set_l2cap_ertx_timeout_value,
	"I", "L2CAP ERTX timeout (sec)");
	@@ -249,7 +249,7 @@
	} /* bluetooth_set_sco_rtx_timeout_value */

	SYSCTL_PROC(_net_bluetooth_sco, OID_AUTO, rtx_timeout,
	- CTLTYPE_INT \| CTLFLAG_RW,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&bluetooth_sco_rtx_timeout_value, 60,
	bluetooth_set_sco_rtx_timeout_value,
	"I", "SCO RTX timeout (sec)");
	Index: sys/netgraph/ng_base.c
	===================================================================
	--- sys/netgraph/ng_base.c
	+++ sys/netgraph/ng_base.c
	@@ -3384,8 +3384,10 @@
	return (0);
	}

	-SYSCTL_PROC(_debug, OID_AUTO, ng_dump_items, CTLTYPE_INT \| CTLFLAG_RW,
	- 0, sizeof(int), sysctl_debug_ng_dump_items, "I", "Number of allocated items");
	+SYSCTL_PROC(_debug, OID_AUTO, ng_dump_items,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, sizeof(int), sysctl_debug_ng_dump_items, "I",
	+ "Number of allocated items");
	#endif /* NETGRAPH_DEBUG */

	/***********************************************************************
	Index: sys/netinet/cc/cc.c
	===================================================================
	--- sys/netinet/cc/cc.c
	+++ sys/netinet/cc/cc.c
	@@ -321,10 +321,11 @@
	"Congestion control related settings");

	SYSCTL_PROC(_net_inet_tcp_cc, OID_AUTO, algorithm,
	- CTLFLAG_VNET \| CTLTYPE_STRING \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	NULL, 0, cc_default_algo, "A", "Default congestion control algorithm");

	-SYSCTL_PROC(_net_inet_tcp_cc, OID_AUTO, available, CTLTYPE_STRING\|CTLFLAG_RD,
	+SYSCTL_PROC(_net_inet_tcp_cc, OID_AUTO, available,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	NULL, 0, cc_list_available, "A",
	"List available congestion control algorithms");

	Index: sys/netinet/cc/cc_cdg.c
	===================================================================
	--- sys/netinet/cc/cc_cdg.c
	+++ sys/netinet/cc/cc_cdg.c
	@@ -683,19 +683,19 @@
	"alpha_inc RTTs during congestion avoidance mode.");

	SYSCTL_PROC(_net_inet_tcp_cc_cdg, OID_AUTO, beta_delay,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW, &VNET_NAME(cdg_beta_delay), 70,
	- &cdg_beta_handler, "IU",
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(cdg_beta_delay), 70, &cdg_beta_handler, "IU",
	"Delay-based window decrease factor as a percentage "
	"(on delay-based backoff, w = w * beta_delay / 100)");

	SYSCTL_PROC(_net_inet_tcp_cc_cdg, OID_AUTO, beta_loss,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW, &VNET_NAME(cdg_beta_loss), 50,
	- &cdg_beta_handler, "IU",
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(cdg_beta_loss), 50, &cdg_beta_handler, "IU",
	"Loss-based window decrease factor as a percentage "
	"(on loss-based backoff, w = w * beta_loss / 100)");

	SYSCTL_PROC(_net_inet_tcp_cc_cdg, OID_AUTO, exp_backoff_scale,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(cdg_exp_backoff_scale), 2, &cdg_exp_backoff_scale_handler, "IU",
	"Scaling parameter for the probabilistic exponential backoff");

	Index: sys/netinet/cc/cc_chd.c
	===================================================================
	--- sys/netinet/cc/cc_chd.c
	+++ sys/netinet/cc/cc_chd.c
	@@ -469,17 +469,17 @@
	"CAIA Hamilton delay-based congestion control related settings");

	SYSCTL_PROC(_net_inet_tcp_cc_chd, OID_AUTO, loss_fair,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(chd_loss_fair), 1, &chd_loss_fair_handler,
	"IU", "Flag to enable shadow window functionality.");

	SYSCTL_PROC(_net_inet_tcp_cc_chd, OID_AUTO, pmax,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(chd_pmax), 5, &chd_pmax_handler,
	"IU", "Per RTT maximum backoff probability as a percentage");

	SYSCTL_PROC(_net_inet_tcp_cc_chd, OID_AUTO, queue_threshold,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(chd_qthresh), 20, &chd_qthresh_handler,
	"IU", "Queueing congestion threshold in ticks");

	Index: sys/netinet/cc/cc_dctcp.c
	===================================================================
	--- sys/netinet/cc/cc_dctcp.c
	+++ sys/netinet/cc/cc_dctcp.c
	@@ -451,18 +451,18 @@
	"dctcp congestion control related settings");

	SYSCTL_PROC(_net_inet_tcp_cc_dctcp, OID_AUTO, alpha,
	- CTLFLAG_VNET\|CTLTYPE_UINT\|CTLFLAG_RW, &VNET_NAME(dctcp_alpha), 0,
	- &dctcp_alpha_handler,
	- "IU", "dctcp alpha parameter at start of session");
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(dctcp_alpha), 0, &dctcp_alpha_handler, "IU",
	+ "dctcp alpha parameter at start of session");

	SYSCTL_PROC(_net_inet_tcp_cc_dctcp, OID_AUTO, shift_g,
	- CTLFLAG_VNET\|CTLTYPE_UINT\|CTLFLAG_RW, &VNET_NAME(dctcp_shift_g), 4,
	- &dctcp_shift_g_handler,
	- "IU", "dctcp shift parameter");
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(dctcp_shift_g), 4, &dctcp_shift_g_handler, "IU",
	+ "dctcp shift parameter");

	SYSCTL_PROC(_net_inet_tcp_cc_dctcp, OID_AUTO, slowstart,
	- CTLFLAG_VNET\|CTLTYPE_UINT\|CTLFLAG_RW, &VNET_NAME(dctcp_slowstart), 0,
	- &dctcp_slowstart_handler,
	- "IU", "half CWND reduction after the first slow start");
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(dctcp_slowstart), 0, &dctcp_slowstart_handler, "IU",
	+ "half CWND reduction after the first slow start");

	DECLARE_CC_MODULE(dctcp, &dctcp_cc_algo);
	Index: sys/netinet/cc/cc_hd.c
	===================================================================
	--- sys/netinet/cc/cc_hd.c
	+++ sys/netinet/cc/cc_hd.c
	@@ -236,17 +236,19 @@
	"Hamilton delay-based congestion control related settings");

	SYSCTL_PROC(_net_inet_tcp_cc_hd, OID_AUTO, queue_threshold,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW, &VNET_NAME(hd_qthresh), 20,
	- &hd_qthresh_handler, "IU", "queueing congestion threshold (qth) in ticks");
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(hd_qthresh), 20, &hd_qthresh_handler, "IU",
	+ "queueing congestion threshold (qth) in ticks");

	SYSCTL_PROC(_net_inet_tcp_cc_hd, OID_AUTO, pmax,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW, &VNET_NAME(hd_pmax), 5,
	- &hd_pmax_handler, "IU",
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(hd_pmax), 5, &hd_pmax_handler, "IU",
	"per packet maximum backoff probability as a percentage");

	SYSCTL_PROC(_net_inet_tcp_cc_hd, OID_AUTO, queue_min,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW, &VNET_NAME(hd_qmin), 5,
	- &hd_qmin_handler, "IU", "minimum queueing delay threshold (qmin) in ticks");
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(hd_qmin), 5, &hd_qmin_handler, "IU",
	+ "minimum queueing delay threshold (qmin) in ticks");

	DECLARE_CC_MODULE(hd, &hd_cc_algo);
	MODULE_DEPEND(hd, ertt, 1, 1, 1);
	Index: sys/netinet/cc/cc_newreno.c
	===================================================================
	--- sys/netinet/cc/cc_newreno.c
	+++ sys/netinet/cc/cc_newreno.c
	@@ -385,12 +385,12 @@
	"New Reno related settings");

	SYSCTL_PROC(_net_inet_tcp_cc_newreno, OID_AUTO, beta,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(newreno_beta), 3, &newreno_beta_handler, "IU",
	"New Reno beta, specified as number between 1 and 100");

	SYSCTL_PROC(_net_inet_tcp_cc_newreno, OID_AUTO, beta_ecn,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(newreno_beta_ecn), 3, &newreno_beta_handler, "IU",
	"New Reno beta ecn, specified as number between 1 and 100");

	Index: sys/netinet/cc/cc_vegas.c
	===================================================================
	--- sys/netinet/cc/cc_vegas.c
	+++ sys/netinet/cc/cc_vegas.c
	@@ -290,12 +290,12 @@
	"Vegas related settings");

	SYSCTL_PROC(_net_inet_tcp_cc_vegas, OID_AUTO, alpha,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(vegas_alpha), 1, &vegas_alpha_handler, "IU",
	"vegas alpha, specified as number of \"buffers\" (0 < alpha < beta)");

	SYSCTL_PROC(_net_inet_tcp_cc_vegas, OID_AUTO, beta,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(vegas_beta), 3, &vegas_beta_handler, "IU",
	"vegas beta, specified as number of \"buffers\" (0 < alpha < beta)");

	Index: sys/netinet/in_pcb.c
	===================================================================
	--- sys/netinet/in_pcb.c
	+++ sys/netinet/in_pcb.c
	@@ -176,23 +176,29 @@
	"IP Ports");

	SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, lowfirst,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW,
	- &VNET_NAME(ipport_lowfirstauto), 0, &sysctl_net_ipport_check, "I", "");
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(ipport_lowfirstauto), 0, &sysctl_net_ipport_check, "I",
	+ "");
	SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, lowlast,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW,
	- &VNET_NAME(ipport_lowlastauto), 0, &sysctl_net_ipport_check, "I", "");
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(ipport_lowlastauto), 0, &sysctl_net_ipport_check, "I",
	+ "");
	SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, first,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW,
	- &VNET_NAME(ipport_firstauto), 0, &sysctl_net_ipport_check, "I", "");
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(ipport_firstauto), 0, &sysctl_net_ipport_check, "I",
	+ "");
	SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, last,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW,
	- &VNET_NAME(ipport_lastauto), 0, &sysctl_net_ipport_check, "I", "");
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(ipport_lastauto), 0, &sysctl_net_ipport_check, "I",
	+ "");
	SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hifirst,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW,
	- &VNET_NAME(ipport_hifirstauto), 0, &sysctl_net_ipport_check, "I", "");
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(ipport_hifirstauto), 0, &sysctl_net_ipport_check, "I",
	+ "");
	SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hilast,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW,
	- &VNET_NAME(ipport_hilastauto), 0, &sysctl_net_ipport_check, "I", "");
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(ipport_hilastauto), 0, &sysctl_net_ipport_check, "I",
	+ "");
	SYSCTL_INT(_net_inet_ip_portrange, OID_AUTO, reservedhigh,
	CTLFLAG_VNET \| CTLFLAG_RW \| CTLFLAG_SECURE,
	&VNET_NAME(ipport_reservedhigh), 0, "");
	Index: sys/netinet/ip_carp.c
	===================================================================
	--- sys/netinet/ip_carp.c
	+++ sys/netinet/ip_carp.c
	@@ -220,17 +220,19 @@

	SYSCTL_NODE(_net_inet, IPPROTO_CARP, carp, CTLFLAG_RW, 0, "CARP");
	SYSCTL_PROC(_net_inet_carp, OID_AUTO, allow,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW, 0, 0, carp_allow_sysctl, "I",
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, carp_allow_sysctl, "I",
	"Accept incoming CARP packets");
	SYSCTL_PROC(_net_inet_carp, OID_AUTO, dscp,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW, 0, 0, carp_dscp_sysctl, "I",
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, carp_dscp_sysctl, "I",
	"DSCP value for carp packets");
	SYSCTL_INT(_net_inet_carp, OID_AUTO, preempt, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(carp_preempt), 0, "High-priority backup preemption mode");
	SYSCTL_INT(_net_inet_carp, OID_AUTO, log, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(carp_log), 0, "CARP log level");
	SYSCTL_PROC(_net_inet_carp, OID_AUTO, demotion,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, 0, carp_demote_adj_sysctl, "I",
	"Adjust demotion factor (skew of advskew)");
	SYSCTL_INT(_net_inet_carp, OID_AUTO, senderr_demotion_factor,
	Index: sys/netinet/ip_divert.c
	===================================================================
	--- sys/netinet/ip_divert.c
	+++ sys/netinet/ip_divert.c
	@@ -694,8 +694,10 @@
	#ifdef SYSCTL_NODE
	static SYSCTL_NODE(_net_inet, IPPROTO_DIVERT, divert, CTLFLAG_RW, 0,
	"IPDIVERT");
	-SYSCTL_PROC(_net_inet_divert, OID_AUTO, pcblist, CTLTYPE_OPAQUE \| CTLFLAG_RD,
	- NULL, 0, div_pcblist, "S,xinpcb", "List of active divert sockets");
	+SYSCTL_PROC(_net_inet_divert, OID_AUTO, pcblist,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, div_pcblist, "S,xinpcb",
	+ "List of active divert sockets");
	#endif

	struct pr_usrreqs div_usrreqs = {
	Index: sys/netinet/ip_id.c
	===================================================================
	--- sys/netinet/ip_id.c
	+++ sys/netinet/ip_id.c
	@@ -137,14 +137,14 @@

	SYSCTL_DECL(_net_inet_ip);
	SYSCTL_PROC(_net_inet_ip, OID_AUTO, random_id,
	- CTLTYPE_INT \| CTLFLAG_VNET \| CTLFLAG_RW,
	+ CTLTYPE_INT \| CTLFLAG_VNET \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(ip_do_randomid), 0, sysctl_ip_randomid, "IU",
	"Assign random ip_id values");
	SYSCTL_INT(_net_inet_ip, OID_AUTO, rfc6864, CTLFLAG_VNET \| CTLFLAG_RW,
	&VNET_NAME(ip_rfc6864), 0,
	"Use constant IP ID for atomic datagrams");
	SYSCTL_PROC(_net_inet_ip, OID_AUTO, random_id_period,
	- CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_VNET,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_VNET \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(array_size), 0, sysctl_ip_id_change, "IU", "IP ID Array size");
	SYSCTL_INT(_net_inet_ip, OID_AUTO, random_id_collisions,
	CTLFLAG_RD \| CTLFLAG_VNET,
	Index: sys/netinet/ip_input.c
	===================================================================
	--- sys/netinet/ip_input.c
	+++ sys/netinet/ip_input.c
	@@ -230,7 +230,8 @@
	return (netisr_setqlimit(&ip_nh, qlimit));
	}
	SYSCTL_PROC(_net_inet_ip, IPCTL_INTRQMAXLEN, intr_queue_maxlen,
	- CTLTYPE_INT\|CTLFLAG_RW, 0, 0, sysctl_netinet_intr_queue_maxlen, "I",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_netinet_intr_queue_maxlen, "I",
	"Maximum size of the IP input queue");

	static int
	@@ -251,7 +252,8 @@
	}

	SYSCTL_PROC(_net_inet_ip, IPCTL_INTRQDROPS, intr_queue_drops,
	- CTLTYPE_INT\|CTLFLAG_RD, 0, 0, sysctl_netinet_intr_queue_drops, "I",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_netinet_intr_queue_drops, "I",
	"Number of packets dropped from the IP input queue");

	#ifdef RSS
	@@ -269,7 +271,8 @@
	return (netisr_setqlimit(&ip_direct_nh, qlimit));
	}
	SYSCTL_PROC(_net_inet_ip, IPCTL_INTRDQMAXLEN, intr_direct_queue_maxlen,
	- CTLTYPE_INT\|CTLFLAG_RW, 0, 0, sysctl_netinet_intr_direct_queue_maxlen,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_netinet_intr_direct_queue_maxlen,
	"I", "Maximum size of the IP direct input queue");

	static int
	@@ -290,7 +293,8 @@
	}

	SYSCTL_PROC(_net_inet_ip, IPCTL_INTRDQDROPS, intr_direct_queue_drops,
	- CTLTYPE_INT\|CTLFLAG_RD, 0, 0, sysctl_netinet_intr_direct_queue_drops, "I",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_netinet_intr_direct_queue_drops, "I",
	"Number of packets dropped from the IP direct input queue");
	#endif /* RSS */

	Index: sys/netinet/ip_reass.c
	===================================================================
	--- sys/netinet/ip_reass.c
	+++ sys/netinet/ip_reass.c
	@@ -147,8 +147,9 @@

	VNET_DEFINE_STATIC(uma_zone_t, ipq_zone);
	#define V_ipq_zone VNET(ipq_zone)
	-SYSCTL_PROC(_net_inet_ip, OID_AUTO, maxfragpackets, CTLFLAG_VNET \|
	- CTLTYPE_INT \| CTLFLAG_RW, NULL, 0, sysctl_maxfragpackets, "I",
	+SYSCTL_PROC(_net_inet_ip, OID_AUTO, maxfragpackets,
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_maxfragpackets, "I",
	"Maximum number of IPv4 fragment reassembly queue entries");
	SYSCTL_UMA_CUR(_net_inet_ip, OID_AUTO, fragpackets, CTLFLAG_VNET,
	&VNET_NAME(ipq_zone),
	Index: sys/netinet/libalias/alias_sctp.c
	===================================================================
	--- sys/netinet/libalias/alias_sctp.c
	+++ sys/netinet/libalias/alias_sctp.c
	@@ -369,40 +369,52 @@

	static SYSCTL_NODE(_net_inet_ip_alias, OID_AUTO, sctp, CTLFLAG_RW, NULL,
	"SCTP NAT");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, log_level, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, log_level,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_log_level, 0, sysctl_chg_loglevel, "IU",
	"Level of detail (0 - default, 1 - event, 2 - info, 3 - detail, 4 - debug, 5 - max debug)");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, init_timer, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, init_timer,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_init_timer, 0, sysctl_chg_timer, "IU",
	"Timeout value (s) while waiting for (INIT-ACK\|AddIP-ACK)");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, up_timer, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, up_timer,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_up_timer, 0, sysctl_chg_timer, "IU",
	"Timeout value (s) to keep an association up with no traffic");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, shutdown_timer, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, shutdown_timer,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_shutdown_timer, 0, sysctl_chg_timer, "IU",
	"Timeout value (s) while waiting for SHUTDOWN-COMPLETE");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, holddown_timer, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, holddown_timer,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_holddown_timer, 0, sysctl_chg_timer, "IU",
	"Hold association in table for this many seconds after receiving a SHUTDOWN-COMPLETE");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, hashtable_size, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, hashtable_size,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_hashtable_size, 0, sysctl_chg_hashtable_size, "IU",
	"Size of hash tables used for NAT lookups (100 < prime_number > 1000001)");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, error_on_ootb, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, error_on_ootb,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_error_on_ootb, 0, sysctl_chg_error_on_ootb, "IU",
	"ErrorM sent on receipt of ootb packet:\n\t0 - none,\n\t1 - to local only,\n\t2 - to local and global if a partial association match,\n\t3 - to local and global (DoS risk)");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, accept_global_ootb_addip, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, accept_global_ootb_addip,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_accept_global_ootb_addip, 0, sysctl_chg_accept_global_ootb_addip, "IU",
	"NAT response to receipt of global OOTB AddIP:\n\t0 - No response,\n\t1 - NAT will accept OOTB global AddIP messages for processing (Security risk)");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, initialising_chunk_proc_limit, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, initialising_chunk_proc_limit,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_initialising_chunk_proc_limit, 0, sysctl_chg_initialising_chunk_proc_limit, "IU",
	"Number of chunks that should be processed if there is no current association found:\n\t > 0 (A high value is a DoS risk)");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, chunk_proc_limit, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, chunk_proc_limit,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_chunk_proc_limit, 0, sysctl_chg_chunk_proc_limit, "IU",
	"Number of chunks that should be processed to find key chunk:\n\t>= initialising_chunk_proc_limit (A high value is a DoS risk)");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, param_proc_limit, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, param_proc_limit,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_param_proc_limit, 0, sysctl_chg_param_proc_limit, "IU",
	"Number of parameters (in a chunk) that should be processed to find key parameters:\n\t> 1 (A high value is a DoS risk)");
	-SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, track_global_addresses, CTLTYPE_UINT \| CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_ip_alias_sctp, OID_AUTO, track_global_addresses,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&sysctl_track_global_addresses, 0, sysctl_chg_track_global_addresses, "IU",
	"Configures the global address tracking option within the NAT:\n\t0 - Global tracking is disabled,\n\t> 0 - enables tracking but limits the number of global IP addresses to this value");

	Index: sys/netinet/netdump/netdump_client.c
	===================================================================
	--- sys/netinet/netdump/netdump_client.c
	+++ sys/netinet/netdump/netdump_client.c
	@@ -138,8 +138,10 @@
	SYSCTL_INT(_net_netdump, OID_AUTO, debug, CTLFLAG_RWTUN,
	&nd_debug, 0,
	"Debug message verbosity");
	-SYSCTL_PROC(_net_netdump, OID_AUTO, enabled, CTLFLAG_RD \| CTLTYPE_INT, NULL, 0,
	- netdump_enabled_sysctl, "I", "netdump configuration status");
	+SYSCTL_PROC(_net_netdump, OID_AUTO, enabled,
	+ CTLFLAG_RD \| CTLTYPE_INT \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, netdump_enabled_sysctl, "I",
	+ "netdump configuration status");
	static char nd_path[MAXPATHLEN];
	SYSCTL_STRING(_net_netdump, OID_AUTO, path, CTLFLAG_RW,
	nd_path, sizeof(nd_path),
	Index: sys/netinet/raw_ip.c
	===================================================================
	--- sys/netinet/raw_ip.c
	+++ sys/netinet/raw_ip.c
	@@ -1132,8 +1132,9 @@
	}

	SYSCTL_PROC(_net_inet_raw, OID_AUTO/XXX/, pcblist,
	- CTLTYPE_OPAQUE \| CTLFLAG_RD, NULL, 0,
	- rip_pcblist, "S,xinpcb", "List of active raw IP sockets");
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, rip_pcblist, "S,xinpcb",
	+ "List of active raw IP sockets");

	#ifdef INET
	struct pr_usrreqs rip_usrreqs = {
	Index: sys/netinet/sctp_sysctl.c
	===================================================================
	--- sys/netinet/sctp_sysctl.c
	+++ sys/netinet/sctp_sysctl.c
	@@ -861,8 +861,8 @@
	return (error); \
	} \
	SYSCTL_PROC(_net_inet_sctp, OID_AUTO, mib_name, \
	- CTLFLAG_VNET\|CTLTYPE_UINT\|CTLFLAG_RW, NULL, 0, \
	- sctp_sysctl_handle_##mib_name, "UI", prefix##_DESC);
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, \
	+ NULL, 0, sctp_sysctl_handle_##mib_name, "UI", prefix##_DESC);

	/*
	* sysctl definitions
	@@ -873,10 +873,14 @@
	SCTP_UINT_SYSCTL(auto_asconf, sctp_auto_asconf, SCTPCTL_AUTOASCONF)
	SCTP_UINT_SYSCTL(ecn_enable, sctp_ecn_enable, SCTPCTL_ECN_ENABLE)
	SCTP_UINT_SYSCTL(pr_enable, sctp_pr_enable, SCTPCTL_PR_ENABLE)
	-SYSCTL_PROC(_net_inet_sctp, OID_AUTO, auth_enable, CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	- NULL, 0, sctp_sysctl_handle_auth, "IU", SCTPCTL_AUTH_ENABLE_DESC);
	-SYSCTL_PROC(_net_inet_sctp, OID_AUTO, asconf_enable, CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	- NULL, 0, sctp_sysctl_handle_asconf, "IU", SCTPCTL_ASCONF_ENABLE_DESC);
	+SYSCTL_PROC(_net_inet_sctp, OID_AUTO, auth_enable,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sctp_sysctl_handle_auth, "IU",
	+ SCTPCTL_AUTH_ENABLE_DESC);
	+SYSCTL_PROC(_net_inet_sctp, OID_AUTO, asconf_enable,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sctp_sysctl_handle_asconf, "IU",
	+ SCTPCTL_ASCONF_ENABLE_DESC);
	SCTP_UINT_SYSCTL(reconfig_enable, sctp_reconfig_enable, SCTPCTL_RECONFIG_ENABLE)
	SCTP_UINT_SYSCTL(nrsack_enable, sctp_nrsack_enable, SCTPCTL_NRSACK_ENABLE)
	SCTP_UINT_SYSCTL(pktdrop_enable, sctp_pktdrop_enable, SCTPCTL_PKTDROP_ENABLE)
	@@ -926,13 +930,19 @@
	SCTP_UINT_SYSCTL(mobility_base, sctp_mobility_base, SCTPCTL_MOBILITY_BASE)
	SCTP_UINT_SYSCTL(mobility_fasthandoff, sctp_mobility_fasthandoff, SCTPCTL_MOBILITY_FASTHANDOFF)
	#if defined(SCTP_LOCAL_TRACE_BUF)
	-SYSCTL_PROC(_net_inet_sctp, OID_AUTO, log, CTLFLAG_VNET \| CTLTYPE_STRUCT \| CTLFLAG_RD,
	- NULL, 0, sctp_sysctl_handle_trace_log, "S,sctplog", "SCTP logging (struct sctp_log)");
	-SYSCTL_PROC(_net_inet_sctp, OID_AUTO, clear_trace, CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	- NULL, 0, sctp_sysctl_handle_trace_log_clear, "IU", "Clear SCTP Logging buffer");
	+SYSCTL_PROC(_net_inet_sctp, OID_AUTO, log,
	+ CTLFLAG_VNET \| CTLTYPE_STRUCT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sctp_sysctl_handle_trace_log, "S,sctplog",
	+ "SCTP logging (struct sctp_log)");
	+SYSCTL_PROC(_net_inet_sctp, OID_AUTO, clear_trace,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sctp_sysctl_handle_trace_log_clear, "IU",
	+ "Clear SCTP Logging buffer");
	#endif
	-SYSCTL_PROC(_net_inet_sctp, OID_AUTO, udp_tunneling_port, CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	- NULL, 0, sctp_sysctl_handle_udp_tunneling, "IU", SCTPCTL_UDP_TUNNELING_PORT_DESC);
	+SYSCTL_PROC(_net_inet_sctp, OID_AUTO, udp_tunneling_port,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sctp_sysctl_handle_udp_tunneling, "IU",
	+ SCTPCTL_UDP_TUNNELING_PORT_DESC);
	SCTP_UINT_SYSCTL(enable_sack_immediately, sctp_enable_sack_immediately, SCTPCTL_SACK_IMMEDIATELY_ENABLE)
	SCTP_UINT_SYSCTL(nat_friendly_init, sctp_inits_include_nat_friendly, SCTPCTL_NAT_FRIENDLY_INITS)
	SCTP_UINT_SYSCTL(vtag_time_wait, sctp_vtag_time_wait, SCTPCTL_TIME_WAIT)
	@@ -952,7 +962,11 @@
	#if defined(__APPLE__) \|\| defined(SCTP_SO_LOCK_TESTING)
	SCTP_UINT_SYSCTL(output_unlocked, sctp_output_unlocked, SCTPCTL_OUTPUT_UNLOCKED)
	#endif
	-SYSCTL_PROC(_net_inet_sctp, OID_AUTO, stats, CTLFLAG_VNET \| CTLTYPE_STRUCT \| CTLFLAG_RW,
	- NULL, 0, sctp_sysctl_handle_stats, "S,sctpstat", "SCTP statistics (struct sctp_stat)");
	-SYSCTL_PROC(_net_inet_sctp, OID_AUTO, assoclist, CTLFLAG_VNET \| CTLTYPE_OPAQUE \| CTLFLAG_RD,
	- NULL, 0, sctp_sysctl_handle_assoclist, "S,xassoc", "List of active SCTP associations");
	+SYSCTL_PROC(_net_inet_sctp, OID_AUTO, stats,
	+ CTLFLAG_VNET \| CTLTYPE_STRUCT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sctp_sysctl_handle_stats, "S,sctpstat",
	+ "SCTP statistics (struct sctp_stat)");
	+SYSCTL_PROC(_net_inet_sctp, OID_AUTO, assoclist,
	+ CTLFLAG_VNET \| CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sctp_sysctl_handle_assoclist, "S,xassoc",
	+ "List of active SCTP associations");
	Index: sys/netinet/sctp_usrreq.c
	===================================================================
	--- sys/netinet/sctp_usrreq.c
	+++ sys/netinet/sctp_usrreq.c
	@@ -421,8 +421,10 @@
	return (error);
	}

	-SYSCTL_PROC(_net_inet_sctp, OID_AUTO, getcred, CTLTYPE_OPAQUE \| CTLFLAG_RW,
	- 0, 0, sctp_getcred, "S,ucred", "Get the ucred of a SCTP connection");
	+SYSCTL_PROC(_net_inet_sctp, OID_AUTO, getcred,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sctp_getcred, "S,ucred",
	+ "Get the ucred of a SCTP connection");


	#ifdef INET
	Index: sys/netinet/siftr.c
	===================================================================
	--- sys/netinet/siftr.c
	+++ sys/netinet/siftr.c
	@@ -303,11 +303,13 @@
	SYSCTL_NODE(_net_inet, OID_AUTO, siftr, CTLFLAG_RW, NULL,
	"siftr related settings");

	-SYSCTL_PROC(_net_inet_siftr, OID_AUTO, enabled, CTLTYPE_UINT\|CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_siftr, OID_AUTO, enabled,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&siftr_enabled, 0, &siftr_sysctl_enabled_handler, "IU",
	"switch siftr module operations on/off");

	-SYSCTL_PROC(_net_inet_siftr, OID_AUTO, logfile, CTLTYPE_STRING\|CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_siftr, OID_AUTO, logfile,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&siftr_logfile_shadow, sizeof(siftr_logfile_shadow), &siftr_sysctl_logfile_name_handler,
	"A", "file to save siftr log messages to");

	Index: sys/netinet/tcp_fastopen.c
	===================================================================
	--- sys/netinet/tcp_fastopen.c
	+++ sys/netinet/tcp_fastopen.c
	@@ -267,13 +267,13 @@
	#define V_tcp_fastopen_autokey VNET(tcp_fastopen_autokey)
	static int sysctl_net_inet_tcp_fastopen_autokey(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, autokey,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW, NULL, 0,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, NULL, 0,
	&sysctl_net_inet_tcp_fastopen_autokey, "IU",
	"Number of seconds between auto-generation of a new key; zero disables");

	static int sysctl_net_inet_tcp_fastopen_ccache_bucket_limit(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, ccache_bucket_limit,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RWTUN, NULL, 0,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RWTUN \| CTLFLAG_NEEDGIANT, NULL, 0,
	&sysctl_net_inet_tcp_fastopen_ccache_bucket_limit, "IU",
	"Max entries per bucket in client cookie cache");

	@@ -287,7 +287,7 @@
	VNET_DEFINE(unsigned int, tcp_fastopen_client_enable) = 1;
	static int sysctl_net_inet_tcp_fastopen_client_enable(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, client_enable,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW, NULL, 0,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, NULL, 0,
	&sysctl_net_inet_tcp_fastopen_client_enable, "IU",
	"Enable/disable TCP Fast Open client functionality");

	@@ -326,33 +326,33 @@
	#define V_tcp_fastopen_psk_enable VNET(tcp_fastopen_psk_enable)
	static int sysctl_net_inet_tcp_fastopen_psk_enable(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, psk_enable,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW, NULL, 0,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, NULL, 0,
	&sysctl_net_inet_tcp_fastopen_psk_enable, "IU",
	"Enable/disable TCP Fast Open server pre-shared key mode");

	VNET_DEFINE(unsigned int, tcp_fastopen_server_enable) = 0;
	static int sysctl_net_inet_tcp_fastopen_server_enable(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, server_enable,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW, NULL, 0,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, NULL, 0,
	&sysctl_net_inet_tcp_fastopen_server_enable, "IU",
	"Enable/disable TCP Fast Open server functionality");

	static int sysctl_net_inet_tcp_fastopen_setkey(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setkey,
	- CTLFLAG_VNET \| CTLTYPE_OPAQUE \| CTLFLAG_WR, NULL, 0,
	+ CTLFLAG_VNET \| CTLTYPE_OPAQUE \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT, NULL, 0,
	&sysctl_net_inet_tcp_fastopen_setkey, "",
	"Install a new key");

	static int sysctl_net_inet_tcp_fastopen_setpsk(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setpsk,
	- CTLFLAG_VNET \| CTLTYPE_OPAQUE \| CTLFLAG_WR, NULL, 0,
	+ CTLFLAG_VNET \| CTLTYPE_OPAQUE \| CTLFLAG_WR \| CTLFLAG_NEEDGIANT, NULL, 0,
	&sysctl_net_inet_tcp_fastopen_setpsk, "",
	"Install a new pre-shared key");

	static int sysctl_net_inet_tcp_fastopen_ccache_list(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, ccache_list,
	- CTLFLAG_VNET \| CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_SKIP, NULL, 0,
	- sysctl_net_inet_tcp_fastopen_ccache_list, "A",
	+ CTLFLAG_VNET \| CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_SKIP \|
	+ CTLFLAG_NEEDGIANT, NULL, 0, sysctl_net_inet_tcp_fastopen_ccache_list, "A",
	"List of all client cookie cache entries");

	VNET_DEFINE_STATIC(struct rmlock, tcp_fastopen_keylock);
	Index: sys/netinet/tcp_hostcache.c
	===================================================================
	--- sys/netinet/tcp_hostcache.c
	+++ sys/netinet/tcp_hostcache.c
	@@ -163,12 +163,14 @@
	"Expire all entires on next purge run");

	SYSCTL_PROC(_net_inet_tcp_hostcache, OID_AUTO, list,
	- CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_SKIP, 0, 0,
	- sysctl_tcp_hc_list, "A", "List of all hostcache entries");
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_SKIP \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_tcp_hc_list, "A",
	+ "List of all hostcache entries");

	SYSCTL_PROC(_net_inet_tcp_hostcache, OID_AUTO, purgenow,
	- CTLTYPE_INT \| CTLFLAG_RW, NULL, 0,
	- sysctl_tcp_hc_purgenow, "I", "Immediately purge all entries");
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_tcp_hc_purgenow, "I",
	+ "Immediately purge all entries");

	static MALLOC_DEFINE(M_HOSTCACHE, "hostcache", "TCP hostcache");

	Index: sys/netinet/tcp_hpts.c
	===================================================================
	--- sys/netinet/tcp_hpts.c
	+++ sys/netinet/tcp_hpts.c
	@@ -293,7 +293,7 @@
	}

	SYSCTL_PROC(_net_inet_tcp_hpts, OID_AUTO, maxsleep,
	- CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&hpts_sleep_max, 0,
	&sysctl_net_inet_tcp_hpts_max_sleep, "IU",
	"Maximum time hpts will sleep");
	Index: sys/netinet/tcp_stats.c
	===================================================================
	--- sys/netinet/tcp_stats.c
	+++ sys/netinet/tcp_stats.c
	@@ -79,7 +79,7 @@
	"Enable per-connection TCP stats gathering; 1 enables for all connections, "
	"2 enables random sampling across log id connection groups");
	SYSCTL_PROC(_net_inet_tcp, OID_AUTO, perconn_stats_sample_rates,
	- CTLTYPE_STRING \| CTLFLAG_RW, tcp_stats_tpl_sr_cb,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, tcp_stats_tpl_sr_cb,
	sizeof(struct rm_priotracker), stats_tpl_sample_rates, "A",
	"TCP stats per template random sampling rates, in CSV tpl_spec=percent "
	"key-value pairs (see stats(9) for template spec details)");
	Index: sys/netinet/tcp_subr.c
	===================================================================
	--- sys/netinet/tcp_subr.c
	+++ sys/netinet/tcp_subr.c
	@@ -209,7 +209,8 @@
	}

	SYSCTL_PROC(_net_inet_tcp, TCPCTL_MSSDFLT, mssdflt,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW, &VNET_NAME(tcp_mssdflt), 0,
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(tcp_mssdflt), 0,
	&sysctl_net_inet_tcp_mss_check, "I",
	"Default TCP Maximum Segment Size");

	@@ -231,7 +232,8 @@
	}

	SYSCTL_PROC(_net_inet_tcp, TCPCTL_V6MSSDFLT, v6mssdflt,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW, &VNET_NAME(tcp_v6mssdflt), 0,
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &VNET_NAME(tcp_v6mssdflt), 0,
	&sysctl_net_inet_tcp_mss_v6_check, "I",
	"Default TCP Maximum Segment Size for IPv6");
	#endif /* INET6 */
	@@ -311,7 +313,7 @@
	return (error);
	}
	SYSCTL_PROC(_net_inet_tcp, OID_AUTO, map_limit,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(tcp_map_entries_limit), 0,
	&sysctl_net_inet_tcp_map_limit_check, "IU",
	"Total sendmap entries limit");
	@@ -532,9 +534,9 @@
	}

	SYSCTL_PROC(_net_inet_tcp, OID_AUTO, functions_default,
	- CTLTYPE_STRING \| CTLFLAG_RW,
	- NULL, 0, sysctl_net_inet_default_tcp_functions, "A",
	- "Set/get the default TCP functions");
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_net_inet_default_tcp_functions, "A",
	+ "Set/get the default TCP functions");

	static int
	sysctl_net_inet_list_available(SYSCTL_HANDLER_ARGS)
	@@ -588,9 +590,9 @@
	}

	SYSCTL_PROC(_net_inet_tcp, OID_AUTO, functions_available,
	- CTLTYPE_STRING\|CTLFLAG_RD,
	- NULL, 0, sysctl_net_inet_list_available, "A",
	- "list available TCP Function sets");
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_net_inet_list_available, "A",
	+ "list available TCP Function sets");

	/*
	* Exports one (struct tcp_function_info) for each alias/name.
	@@ -2313,8 +2315,9 @@
	}

	SYSCTL_PROC(_net_inet_tcp, TCPCTL_PCBLIST, pcblist,
	- CTLTYPE_OPAQUE \| CTLFLAG_RD, NULL, 0,
	- tcp_pcblist, "S,xtcpcb", "List of active TCP connections");
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, tcp_pcblist, "S,xtcpcb",
	+ "List of active TCP connections");

	#ifdef INET
	static int
	@@ -2352,8 +2355,9 @@
	}

	SYSCTL_PROC(_net_inet_tcp, OID_AUTO, getcred,
	- CTLTYPE_OPAQUE\|CTLFLAG_RW\|CTLFLAG_PRISON, 0, 0,
	- tcp_getcred, "S,xucred", "Get the xucred of a TCP connection");
	+ CTLTYPE_OPAQUE \| CTLFLAG_RW \| CTLFLAG_PRISON \| CTLFLAG_NEEDGIANT,
	+ 0, 0, tcp_getcred, "S,xucred",
	+ "Get the xucred of a TCP connection");
	#endif /* INET */

	#ifdef INET6
	@@ -2419,8 +2423,9 @@
	}

	SYSCTL_PROC(_net_inet6_tcp6, OID_AUTO, getcred,
	- CTLTYPE_OPAQUE\|CTLFLAG_RW\|CTLFLAG_PRISON, 0, 0,
	- tcp6_getcred, "S,xucred", "Get the xucred of a TCP6 connection");
	+ CTLTYPE_OPAQUE \| CTLFLAG_RW \| CTLFLAG_PRISON \| CTLFLAG_NEEDGIANT,
	+ 0, 0, tcp6_getcred, "S,xucred",
	+ "Get the xucred of a TCP6 connection");
	#endif /* INET6 */


	@@ -3151,8 +3156,9 @@
	}

	SYSCTL_PROC(_net_inet_tcp, TCPCTL_DROP, drop,
	- CTLFLAG_VNET \| CTLTYPE_STRUCT \| CTLFLAG_WR \| CTLFLAG_SKIP, NULL,
	- 0, sysctl_drop, "", "Drop TCP connection");
	+ CTLFLAG_VNET \| CTLTYPE_STRUCT \| CTLFLAG_WR \| CTLFLAG_SKIP \|
	+ CTLFLAG_NEEDGIANT, NULL, 0, sysctl_drop, "",
	+ "Drop TCP connection");

	#ifdef KERN_TLS
	static int
	@@ -3261,11 +3267,13 @@
	}

	SYSCTL_PROC(_net_inet_tcp, OID_AUTO, switch_to_sw_tls,
	- CTLFLAG_VNET \| CTLTYPE_STRUCT \| CTLFLAG_WR \| CTLFLAG_SKIP, NULL,
	- 0, sysctl_switch_tls, "", "Switch TCP connection to SW TLS");
	+ CTLFLAG_VNET \| CTLTYPE_STRUCT \| CTLFLAG_WR \| CTLFLAG_SKIP \|
	+ CTLFLAG_NEEDGIANT, NULL, 0, sysctl_switch_tls, "",
	+ "Switch TCP connection to SW TLS");
	SYSCTL_PROC(_net_inet_tcp, OID_AUTO, switch_to_ifnet_tls,
	- CTLFLAG_VNET \| CTLTYPE_STRUCT \| CTLFLAG_WR \| CTLFLAG_SKIP, NULL,
	- 1, sysctl_switch_tls, "", "Switch TCP connection to ifnet TLS");
	+ CTLFLAG_VNET \| CTLTYPE_STRUCT \| CTLFLAG_WR \| CTLFLAG_SKIP \|
	+ CTLFLAG_NEEDGIANT, NULL, 1, sysctl_switch_tls, "",
	+ "Switch TCP connection to ifnet TLS");
	#endif

	/*
	Index: sys/netinet/tcp_syncache.c
	===================================================================
	--- sys/netinet/tcp_syncache.c
	+++ sys/netinet/tcp_syncache.c
	@@ -208,7 +208,7 @@
	}

	SYSCTL_PROC(_net_inet_tcp_syncache, OID_AUTO, rexmtlimit,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&VNET_NAME(tcp_syncache.rexmt_limit), 0,
	sysctl_net_inet_tcp_syncache_rexmtlimit_check, "UI",
	"Limit on SYN/ACK retransmissions");
	Index: sys/netinet/tcp_timer.c
	===================================================================
	--- sys/netinet/tcp_timer.c
	+++ sys/netinet/tcp_timer.c
	@@ -82,46 +82,62 @@
	#endif

	int tcp_persmin;
	-SYSCTL_PROC(_net_inet_tcp, OID_AUTO, persmin, CTLTYPE_INT\|CTLFLAG_RW,
	- &tcp_persmin, 0, sysctl_msec_to_ticks, "I", "minimum persistence interval");
	+SYSCTL_PROC(_net_inet_tcp, OID_AUTO, persmin,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &tcp_persmin, 0, sysctl_msec_to_ticks, "I",
	+ "minimum persistence interval");

	int tcp_persmax;
	-SYSCTL_PROC(_net_inet_tcp, OID_AUTO, persmax, CTLTYPE_INT\|CTLFLAG_RW,
	- &tcp_persmax, 0, sysctl_msec_to_ticks, "I", "maximum persistence interval");
	+SYSCTL_PROC(_net_inet_tcp, OID_AUTO, persmax,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &tcp_persmax, 0, sysctl_msec_to_ticks, "I",
	+ "maximum persistence interval");

	int tcp_keepinit;
	-SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPINIT, keepinit, CTLTYPE_INT\|CTLFLAG_RW,
	- &tcp_keepinit, 0, sysctl_msec_to_ticks, "I", "time to establish connection");
	+SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPINIT, keepinit,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &tcp_keepinit, 0, sysctl_msec_to_ticks, "I",
	+ "time to establish connection");

	int tcp_keepidle;
	-SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPIDLE, keepidle, CTLTYPE_INT\|CTLFLAG_RW,
	- &tcp_keepidle, 0, sysctl_msec_to_ticks, "I", "time before keepalive probes begin");
	+SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPIDLE, keepidle,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &tcp_keepidle, 0, sysctl_msec_to_ticks, "I",
	+ "time before keepalive probes begin");

	int tcp_keepintvl;
	-SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPINTVL, keepintvl, CTLTYPE_INT\|CTLFLAG_RW,
	- &tcp_keepintvl, 0, sysctl_msec_to_ticks, "I", "time between keepalive probes");
	+SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPINTVL, keepintvl,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &tcp_keepintvl, 0, sysctl_msec_to_ticks, "I",
	+ "time between keepalive probes");

	int tcp_delacktime;
	-SYSCTL_PROC(_net_inet_tcp, TCPCTL_DELACKTIME, delacktime, CTLTYPE_INT\|CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_tcp, TCPCTL_DELACKTIME, delacktime,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&tcp_delacktime, 0, sysctl_msec_to_ticks, "I",
	"Time before a delayed ACK is sent");

	int tcp_msl;
	-SYSCTL_PROC(_net_inet_tcp, OID_AUTO, msl, CTLTYPE_INT\|CTLFLAG_RW,
	- &tcp_msl, 0, sysctl_msec_to_ticks, "I", "Maximum segment lifetime");
	+SYSCTL_PROC(_net_inet_tcp, OID_AUTO, msl,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &tcp_msl, 0, sysctl_msec_to_ticks, "I",
	+ "Maximum segment lifetime");

	int tcp_rexmit_initial;
	-SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_initial, CTLTYPE_INT\|CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_initial,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&tcp_rexmit_initial, 0, sysctl_msec_to_ticks, "I",
	"Initial Retransmission Timeout");

	int tcp_rexmit_min;
	-SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_min, CTLTYPE_INT\|CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_min,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&tcp_rexmit_min, 0, sysctl_msec_to_ticks, "I",
	"Minimum Retransmission Timeout");

	int tcp_rexmit_slop;
	-SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_slop, CTLTYPE_INT\|CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_slop,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&tcp_rexmit_slop, 0, sysctl_msec_to_ticks, "I",
	"Retransmission Timer Slop");

	@@ -136,8 +152,10 @@
	"Recycle closed FIN_WAIT_2 connections faster");

	int tcp_finwait2_timeout;
	-SYSCTL_PROC(_net_inet_tcp, OID_AUTO, finwait2_timeout, CTLTYPE_INT\|CTLFLAG_RW,
	- &tcp_finwait2_timeout, 0, sysctl_msec_to_ticks, "I", "FIN-WAIT2 timeout");
	+SYSCTL_PROC(_net_inet_tcp, OID_AUTO, finwait2_timeout,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ &tcp_finwait2_timeout, 0, sysctl_msec_to_ticks, "I",
	+ "FIN-WAIT2 timeout");

	int tcp_keepcnt = TCPTV_KEEPCNT;
	SYSCTL_INT(_net_inet_tcp, OID_AUTO, keepcnt, CTLFLAG_RW, &tcp_keepcnt, 0,
	Index: sys/netinet/tcp_timewait.c
	===================================================================
	--- sys/netinet/tcp_timewait.c
	+++ sys/netinet/tcp_timewait.c
	@@ -169,7 +169,8 @@
	return (error);
	}

	-SYSCTL_PROC(_net_inet_tcp, OID_AUTO, maxtcptw, CTLTYPE_INT\|CTLFLAG_RW,
	+SYSCTL_PROC(_net_inet_tcp, OID_AUTO, maxtcptw,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	&maxtcptw, 0, sysctl_maxtcptw, "IU",
	"Maximum number of compressed TCP TIME_WAIT entries");

	Index: sys/netinet/udp_usrreq.c
	===================================================================
	--- sys/netinet/udp_usrreq.c
	+++ sys/netinet/udp_usrreq.c
	@@ -916,8 +916,9 @@
	}

	SYSCTL_PROC(_net_inet_udp, UDPCTL_PCBLIST, pcblist,
	- CTLTYPE_OPAQUE \| CTLFLAG_RD, NULL, 0,
	- udp_pcblist, "S,xinpcb", "List of active UDP sockets");
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, udp_pcblist, "S,xinpcb",
	+ "List of active UDP sockets");

	#ifdef INET
	static int
	@@ -957,8 +958,9 @@
	}

	SYSCTL_PROC(_net_inet_udp, OID_AUTO, getcred,
	- CTLTYPE_OPAQUE\|CTLFLAG_RW\|CTLFLAG_PRISON, 0, 0,
	- udp_getcred, "S,xucred", "Get the xucred of a UDP connection");
	+ CTLTYPE_OPAQUE \| CTLFLAG_RW \| CTLFLAG_PRISON \| CTLFLAG_NEEDGIANT,
	+ 0, 0, udp_getcred, "S,xucred",
	+ "Get the xucred of a UDP connection");
	#endif /* INET */

	int
	Index: sys/netinet6/frag6.c
	===================================================================
	--- sys/netinet6/frag6.c
	+++ sys/netinet6/frag6.c
	@@ -197,8 +197,8 @@
	return (0);
	}
	SYSCTL_PROC(_net_inet6_ip6, IPV6CTL_MAXFRAGPACKETS, maxfragpackets,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW, NULL, 0,
	- sysctl_ip6_maxfragpackets, "I",
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_ip6_maxfragpackets, "I",
	"Default maximum number of outstanding fragmented IPv6 packets. "
	"A value of 0 means no fragmented packets will be accepted, while a "
	"a value of -1 means no limit");
	Index: sys/netinet6/in6_proto.c
	===================================================================
	--- sys/netinet6/in6_proto.c
	+++ sys/netinet6/in6_proto.c
	@@ -528,13 +528,13 @@
	CTLFLAG_VNET \| CTLFLAG_RW, &VNET_NAME(ip6_use_tempaddr), 0,
	"Create RFC3041 temporary addresses for autoconfigured addresses");
	SYSCTL_PROC(_net_inet6_ip6, IPV6CTL_TEMPPLTIME, temppltime,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW,
	- NULL, 0, sysctl_ip6_temppltime, "I",
	- "Maximum preferred lifetime for temporary addresses");
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_ip6_temppltime, "I",
	+ "Maximum preferred lifetime for temporary addresses");
	SYSCTL_PROC(_net_inet6_ip6, IPV6CTL_TEMPVLTIME, tempvltime,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW,
	- NULL, 0, sysctl_ip6_tempvltime, "I",
	- "Maximum valid lifetime for temporary addresses");
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_ip6_tempvltime, "I",
	+ "Maximum valid lifetime for temporary addresses");
	SYSCTL_INT(_net_inet6_ip6, IPV6CTL_V6ONLY, v6only,
	CTLFLAG_VNET \| CTLFLAG_RW, &VNET_NAME(ip6_v6only), 0,
	"Restrict AF_INET6 sockets to IPv6 addresses only");
	Index: sys/netinet6/ip6_input.c
	===================================================================
	--- sys/netinet6/ip6_input.c
	+++ sys/netinet6/ip6_input.c
	@@ -159,7 +159,8 @@
	}
	SYSCTL_DECL(_net_inet6_ip6);
	SYSCTL_PROC(_net_inet6_ip6, IPV6CTL_INTRQMAXLEN, intr_queue_maxlen,
	- CTLTYPE_INT\|CTLFLAG_RW, 0, 0, sysctl_netinet6_intr_queue_maxlen, "I",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_netinet6_intr_queue_maxlen, "I",
	"Maximum size of the IPv6 input queue");

	#ifdef RSS
	@@ -186,7 +187,8 @@
	return (netisr_setqlimit(&ip6_direct_nh, qlimit));
	}
	SYSCTL_PROC(_net_inet6_ip6, IPV6CTL_INTRDQMAXLEN, intr_direct_queue_maxlen,
	- CTLTYPE_INT\|CTLFLAG_RW, 0, 0, sysctl_netinet6_intr_direct_queue_maxlen,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_netinet6_intr_direct_queue_maxlen,
	"I", "Maximum size of the IPv6 direct input queue");

	#endif
	Index: sys/netinet6/ip6_mroute.c
	===================================================================
	--- sys/netinet6/ip6_mroute.c
	+++ sys/netinet6/ip6_mroute.c
	@@ -222,7 +222,8 @@
	free(out, M_TEMP);
	return (error);
	}
	-SYSCTL_PROC(_net_inet6_ip6, OID_AUTO, mif6table, CTLTYPE_OPAQUE \| CTLFLAG_RD,
	+SYSCTL_PROC(_net_inet6_ip6, OID_AUTO, mif6table,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	NULL, 0, sysctl_mif6table, "S,mif6_sctl[MAXMIFS]",
	"IPv6 Multicast Interfaces (struct mif6_sctl[MAXMIFS], "
	"netinet6/ip6_mroute.h)");
	Index: sys/netinet6/sctp6_usrreq.c
	===================================================================
	--- sys/netinet6/sctp6_usrreq.c
	+++ sys/netinet6/sctp6_usrreq.c
	@@ -472,9 +472,10 @@
	return (error);
	}

	-SYSCTL_PROC(_net_inet6_sctp6, OID_AUTO, getcred, CTLTYPE_OPAQUE \| CTLFLAG_RW,
	- 0, 0,
	- sctp6_getcred, "S,ucred", "Get the ucred of a SCTP6 connection");
	+SYSCTL_PROC(_net_inet6_sctp6, OID_AUTO, getcred,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sctp6_getcred, "S,ucred",
	+ "Get the ucred of a SCTP6 connection");


	/* This is the same as the sctp_abort() could be made common */
	Index: sys/netinet6/udp6_usrreq.c
	===================================================================
	--- sys/netinet6/udp6_usrreq.c
	+++ sys/netinet6/udp6_usrreq.c
	@@ -682,8 +682,10 @@
	return (error);
	}

	-SYSCTL_PROC(_net_inet6_udp6, OID_AUTO, getcred, CTLTYPE_OPAQUE\|CTLFLAG_RW, 0,
	- 0, udp6_getcred, "S,xucred", "Get the xucred of a UDP6 connection");
	+SYSCTL_PROC(_net_inet6_udp6, OID_AUTO, getcred,
	+ CTLTYPE_OPAQUE \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, udp6_getcred, "S,xucred",
	+ "Get the xucred of a UDP6 connection");

	static int
	udp6_output(struct socket so, int flags_arg, struct mbuf m,
	Index: sys/netipsec/ipsec.c
	===================================================================
	--- sys/netipsec/ipsec.c
	+++ sys/netipsec/ipsec.c
	@@ -175,8 +175,9 @@

	/* net.inet.ipsec */
	SYSCTL_PROC(_net_inet_ipsec, IPSECCTL_DEF_POLICY, def_policy,
	- CTLTYPE_INT \| CTLFLAG_VNET \| CTLFLAG_RW, 0, 0, sysctl_def_policy, "I",
	- "IPsec default policy.");
	+ CTLTYPE_INT \| CTLFLAG_VNET \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_def_policy, "I",
	+ "IPsec default policy.");
	SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DEF_ESP_TRANSLEV, esp_trans_deflev,
	CTLFLAG_VNET \| CTLFLAG_RW, &VNET_NAME(ip4_esp_trans_deflev), 0,
	"Default ESP transport mode level");
	@@ -261,8 +262,9 @@

	/* net.inet6.ipsec6 */
	SYSCTL_PROC(_net_inet6_ipsec6, IPSECCTL_DEF_POLICY, def_policy,
	- CTLTYPE_INT \| CTLFLAG_VNET \| CTLFLAG_RW, 0, 0, sysctl_def_policy, "I",
	- "IPsec default policy.");
	+ CTLTYPE_INT \| CTLFLAG_VNET \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_def_policy, "I",
	+ "IPsec default policy.");
	SYSCTL_INT(_net_inet6_ipsec6, IPSECCTL_DEF_ESP_TRANSLEV, esp_trans_deflev,
	CTLFLAG_VNET \| CTLFLAG_RW, &VNET_NAME(ip6_esp_trans_deflev), 0,
	"Default ESP transport mode level.");
	Index: sys/netpfil/ipfw/dn_aqm_codel.c
	===================================================================
	--- sys/netpfil/ipfw/dn_aqm_codel.c
	+++ sys/netpfil/ipfw/dn_aqm_codel.c
	@@ -123,12 +123,14 @@

	#ifdef SYSCTL_NODE
	SYSCTL_PROC(_net_inet_ip_dummynet_codel, OID_AUTO, target,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,codel_sysctl_target_handler, "L",
	- "CoDel target in microsecond");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0,codel_sysctl_target_handler, "L",
	+ "CoDel target in microsecond");

	SYSCTL_PROC(_net_inet_ip_dummynet_codel, OID_AUTO, interval,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0, codel_sysctl_interval_handler, "L",
	- "CoDel interval in microsecond");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, codel_sysctl_interval_handler, "L",
	+ "CoDel interval in microsecond");
	#endif

	/* This function computes codel_interval/sqrt(count)
	Index: sys/netpfil/ipfw/dn_aqm_pie.c
	===================================================================
	--- sys/netpfil/ipfw/dn_aqm_pie.c
	+++ sys/netpfil/ipfw/dn_aqm_pie.c
	@@ -167,31 +167,31 @@

	#ifdef SYSCTL_NODE
	SYSCTL_PROC(_net_inet_ip_dummynet_pie, OID_AUTO, target,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- pie_sysctl_target_tupdate_maxb_handler, "L",
	- "queue target in microsecond");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, pie_sysctl_target_tupdate_maxb_handler, "L",
	+ "queue target in microsecond");
	SYSCTL_PROC(_net_inet_ip_dummynet_pie, OID_AUTO, tupdate,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- pie_sysctl_target_tupdate_maxb_handler, "L",
	- "the frequency of drop probability calculation in microsecond");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, pie_sysctl_target_tupdate_maxb_handler, "L",
	+ "the frequency of drop probability calculation in microsecond");
	SYSCTL_PROC(_net_inet_ip_dummynet_pie, OID_AUTO, max_burst,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- pie_sysctl_target_tupdate_maxb_handler, "L",
	- "Burst allowance interval in microsecond");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, pie_sysctl_target_tupdate_maxb_handler, "L",
	+ "Burst allowance interval in microsecond");

	SYSCTL_PROC(_net_inet_ip_dummynet_pie, OID_AUTO, max_ecnth,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- pie_sysctl_max_ecnth_handler, "L",
	- "ECN safeguard threshold scaled by 1000");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, pie_sysctl_max_ecnth_handler, "L",
	+ "ECN safeguard threshold scaled by 1000");

	SYSCTL_PROC(_net_inet_ip_dummynet_pie, OID_AUTO, alpha,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- pie_sysctl_alpha_beta_handler, "L",
	- "PIE alpha scaled by 1000");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, pie_sysctl_alpha_beta_handler, "L",
	+ "PIE alpha scaled by 1000");
	SYSCTL_PROC(_net_inet_ip_dummynet_pie, OID_AUTO, beta,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- pie_sysctl_alpha_beta_handler, "L",
	- "beta scaled by 1000");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, pie_sysctl_alpha_beta_handler, "L",
	+ "beta scaled by 1000");
	#endif


	Index: sys/netpfil/ipfw/dn_sched_fq_codel.c
	===================================================================
	--- sys/netpfil/ipfw/dn_sched_fq_codel.c
	+++ sys/netpfil/ipfw/dn_sched_fq_codel.c
	@@ -135,11 +135,13 @@
	#ifdef SYSCTL_NODE

	SYSCTL_PROC(_net_inet_ip_dummynet_fqcodel, OID_AUTO, target,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0, fqcodel_sysctl_target_handler, "L",
	- "FQ_CoDel target in microsecond");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, fqcodel_sysctl_target_handler, "L",
	+ "FQ_CoDel target in microsecond");
	SYSCTL_PROC(_net_inet_ip_dummynet_fqcodel, OID_AUTO, interval,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0, fqcodel_sysctl_interval_handler, "L",
	- "FQ_CoDel interval in microsecond");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, fqcodel_sysctl_interval_handler, "L",
	+ "FQ_CoDel interval in microsecond");

	SYSCTL_UINT(_net_inet_ip_dummynet_fqcodel, OID_AUTO, quantum,
	CTLFLAG_RW, &fq_codel_sysctl.quantum, 1514, "FQ_CoDel quantum");
	Index: sys/netpfil/ipfw/dn_sched_fq_pie.c
	===================================================================
	--- sys/netpfil/ipfw/dn_sched_fq_pie.c
	+++ sys/netpfil/ipfw/dn_sched_fq_pie.c
	@@ -243,32 +243,34 @@
	#ifdef SYSCTL_NODE

	SYSCTL_PROC(_net_inet_ip_dummynet_fqpie, OID_AUTO, target,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- fqpie_sysctl_target_tupdate_maxb_handler, "L",
	- "queue target in microsecond");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, fqpie_sysctl_target_tupdate_maxb_handler, "L",
	+ "queue target in microsecond");

	SYSCTL_PROC(_net_inet_ip_dummynet_fqpie, OID_AUTO, tupdate,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- fqpie_sysctl_target_tupdate_maxb_handler, "L",
	- "the frequency of drop probability calculation in microsecond");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, fqpie_sysctl_target_tupdate_maxb_handler, "L",
	+ "the frequency of drop probability calculation in microsecond");

	SYSCTL_PROC(_net_inet_ip_dummynet_fqpie, OID_AUTO, max_burst,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- fqpie_sysctl_target_tupdate_maxb_handler, "L",
	- "Burst allowance interval in microsecond");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, fqpie_sysctl_target_tupdate_maxb_handler, "L",
	+ "Burst allowance interval in microsecond");

	SYSCTL_PROC(_net_inet_ip_dummynet_fqpie, OID_AUTO, max_ecnth,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- fqpie_sysctl_max_ecnth_handler, "L",
	- "ECN safeguard threshold scaled by 1000");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, fqpie_sysctl_max_ecnth_handler, "L",
	+ "ECN safeguard threshold scaled by 1000");

	SYSCTL_PROC(_net_inet_ip_dummynet_fqpie, OID_AUTO, alpha,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- fqpie_sysctl_alpha_beta_handler, "L", "PIE alpha scaled by 1000");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, fqpie_sysctl_alpha_beta_handler, "L",
	+ "PIE alpha scaled by 1000");

	SYSCTL_PROC(_net_inet_ip_dummynet_fqpie, OID_AUTO, beta,
	- CTLTYPE_LONG \| CTLFLAG_RW, NULL, 0,
	- fqpie_sysctl_alpha_beta_handler, "L", "beta scaled by 1000");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, fqpie_sysctl_alpha_beta_handler, "L",
	+ "beta scaled by 1000");

	SYSCTL_UINT(_net_inet_ip_dummynet_fqpie, OID_AUTO, quantum,
	CTLFLAG_RW, &fq_pie_sysctl.quantum, 1514, "quantum for FQ_PIE");
	Index: sys/netpfil/ipfw/ip_dn_io.c
	===================================================================
	--- sys/netpfil/ipfw/ip_dn_io.c
	+++ sys/netpfil/ipfw/ip_dn_io.c
	@@ -171,16 +171,19 @@


	SYSCTL_PROC(_net_inet_ip_dummynet, OID_AUTO, hash_size,
	- CTLTYPE_INT \| CTLFLAG_RW, 0, 0, sysctl_hash_size,
	- "I", "Default hash table size");
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_hash_size, "I",
	+ "Default hash table size");


	SYSCTL_PROC(_net_inet_ip_dummynet, OID_AUTO, pipe_slot_limit,
	- CTLTYPE_LONG \| CTLFLAG_RW, 0, 1, sysctl_limits,
	- "L", "Upper limit in slots for pipe queue.");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 1, sysctl_limits, "L",
	+ "Upper limit in slots for pipe queue.");
	SYSCTL_PROC(_net_inet_ip_dummynet, OID_AUTO, pipe_byte_limit,
	- CTLTYPE_LONG \| CTLFLAG_RW, 0, 0, sysctl_limits,
	- "L", "Upper limit in bytes for pipe queue.");
	+ CTLTYPE_LONG \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_limits, "L",
	+ "Upper limit in bytes for pipe queue.");
	SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, io_fast,
	CTLFLAG_RW, DC(io_fast), 0, "Enable fast dummynet io.");
	SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, debug,
	Index: sys/netpfil/ipfw/ip_fw2.c
	===================================================================
	--- sys/netpfil/ipfw/ip_fw2.c
	+++ sys/netpfil/ipfw/ip_fw2.c
	@@ -196,10 +196,11 @@
	&dummy_def, 0,
	"The default/max possible rule number.");
	SYSCTL_PROC(_net_inet_ip_fw, OID_AUTO, tables_max,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW, 0, 0, sysctl_ipfw_table_num, "IU",
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_ipfw_table_num, "IU",
	"Maximum number of concurrently used tables");
	SYSCTL_PROC(_net_inet_ip_fw, OID_AUTO, tables_sets,
	- CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW,
	+ CTLFLAG_VNET \| CTLTYPE_UINT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, 0, sysctl_ipfw_tables_sets, "IU",
	"Use per-set namespace for tables");
	SYSCTL_INT(_net_inet_ip_fw, OID_AUTO, default_to_accept, CTLFLAG_RDTUN,
	Index: sys/netpfil/ipfw/ip_fw_dynamic.c
	===================================================================
	--- sys/netpfil/ipfw/ip_fw_dynamic.c
	+++ sys/netpfil/ipfw/ip_fw_dynamic.c
	@@ -453,14 +453,17 @@
	CTLFLAG_VNET \| CTLFLAG_RD, &VNET_NAME(curr_max_length), 0,
	"Current maximum length of states chains in hash buckets.");
	SYSCTL_PROC(_net_inet_ip_fw, OID_AUTO, dyn_buckets,
	- CTLFLAG_VNET \| CTLTYPE_U32 \| CTLFLAG_RW, 0, 0, sysctl_dyn_buckets,
	- "IU", "Max number of buckets for dynamic states hash table.");
	+ CTLFLAG_VNET \| CTLTYPE_U32 \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_dyn_buckets, "IU",
	+ "Max number of buckets for dynamic states hash table.");
	SYSCTL_PROC(_net_inet_ip_fw, OID_AUTO, dyn_max,
	- CTLFLAG_VNET \| CTLTYPE_U32 \| CTLFLAG_RW, 0, 0, sysctl_dyn_max,
	- "IU", "Max number of dynamic states.");
	+ CTLFLAG_VNET \| CTLTYPE_U32 \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_dyn_max, "IU",
	+ "Max number of dynamic states.");
	SYSCTL_PROC(_net_inet_ip_fw, OID_AUTO, dyn_parent_max,
	- CTLFLAG_VNET \| CTLTYPE_U32 \| CTLFLAG_RW, 0, 0, sysctl_dyn_parent_max,
	- "IU", "Max number of parent dynamic states.");
	+ CTLFLAG_VNET \| CTLTYPE_U32 \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_dyn_parent_max, "IU",
	+ "Max number of parent dynamic states.");
	SYSCTL_U32(_net_inet_ip_fw, OID_AUTO, dyn_ack_lifetime,
	CTLFLAG_VNET \| CTLFLAG_RW, &VNET_NAME(dyn_ack_lifetime), 0,
	"Lifetime of dynamic states for TCP ACK.");
	Index: sys/netpfil/ipfw/ip_fw_pfil.c
	===================================================================
	--- sys/netpfil/ipfw/ip_fw_pfil.c
	+++ sys/netpfil/ipfw/ip_fw_pfil.c
	@@ -93,19 +93,21 @@

	SYSCTL_DECL(_net_inet_ip_fw);
	SYSCTL_PROC(_net_inet_ip_fw, OID_AUTO, enable,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE3,
	- &VNET_NAME(fw_enable), 0, ipfw_chg_hook, "I", "Enable ipfw");
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE3 \|
	+ CTLFLAG_NEEDGIANT, &VNET_NAME(fw_enable), 0, ipfw_chg_hook, "I",
	+ "Enable ipfw");
	#ifdef INET6
	SYSCTL_DECL(_net_inet6_ip6_fw);
	SYSCTL_PROC(_net_inet6_ip6_fw, OID_AUTO, enable,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE3,
	- &VNET_NAME(fw6_enable), 0, ipfw_chg_hook, "I", "Enable ipfw+6");
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE3 \|
	+ CTLFLAG_NEEDGIANT, &VNET_NAME(fw6_enable), 0, ipfw_chg_hook, "I",
	+ "Enable ipfw+6");
	#endif /* INET6 */

	SYSCTL_DECL(_net_link_ether);
	SYSCTL_PROC(_net_link_ether, OID_AUTO, ipfw,
	- CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE3,
	- &VNET_NAME(fwlink_enable), 0, ipfw_chg_hook, "I",
	+ CTLFLAG_VNET \| CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_SECURE3 \|
	+ CTLFLAG_NEEDGIANT, &VNET_NAME(fwlink_enable), 0, ipfw_chg_hook, "I",
	"Pass ether pkts through firewall");

	SYSEND
	Index: sys/netpfil/ipfw/nat64/ip_fw_nat64.c
	===================================================================
	--- sys/netpfil/ipfw/nat64/ip_fw_nat64.c
	+++ sys/netpfil/ipfw/nat64/ip_fw_nat64.c
	@@ -72,7 +72,8 @@
	return (0);
	}
	SYSCTL_PROC(_net_inet_ip_fw, OID_AUTO, nat64_direct_output,
	- CTLFLAG_VNET \| CTLTYPE_U32 \| CTLFLAG_RW, 0, 0, sysctl_direct_output, "IU",
	+ CTLFLAG_VNET \| CTLTYPE_U32 \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_direct_output, "IU",
	"Use if_output directly instead of deffered netisr-based processing");

	static int
	Index: sys/netsmb/smb_conn.c
	===================================================================
	--- sys/netsmb/smb_conn.c
	+++ sys/netsmb/smb_conn.c
	@@ -69,8 +69,10 @@

	static int smb_sysctl_treedump(SYSCTL_HANDLER_ARGS);

	-SYSCTL_PROC(_net_smb, OID_AUTO, treedump, CTLFLAG_RD \| CTLTYPE_OPAQUE,
	- NULL, 0, smb_sysctl_treedump, "S,treedump", "Requester tree");
	+SYSCTL_PROC(_net_smb, OID_AUTO, treedump,
	+ CTLFLAG_RD \| CTLTYPE_OPAQUE \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, smb_sysctl_treedump, "S,treedump",
	+ "Requester tree");

	int
	smb_sm_init(void)
	Index: sys/nfs/nfs_fha.c
	===================================================================
	--- sys/nfs/nfs_fha.c
	+++ sys/nfs/nfs_fha.c
	@@ -98,7 +98,8 @@
	"single nfsd thread should be working on at any time");

	SYSCTL_ADD_OID(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
	- OID_AUTO, "fhe_stats", CTLTYPE_STRING \| CTLFLAG_RD, 0, 0,
	+ OID_AUTO, "fhe_stats",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, 0, 0,
	softc->callbacks.fhe_stats_sysctl, "A", "");

	}
	Index: sys/nlm/nlm_prot_impl.c
	===================================================================
	--- sys/nlm/nlm_prot_impl.c
	+++ sys/nlm/nlm_prot_impl.c
	@@ -858,10 +858,12 @@
	SYSCTL_ADD_UINT(&host->nh_sysctl, SYSCTL_CHILDREN(oid), OID_AUTO,
	"monitored", CTLFLAG_RD, &host->nh_monstate, 0, "");
	SYSCTL_ADD_PROC(&host->nh_sysctl, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "lock_count", CTLTYPE_INT \| CTLFLAG_RD, host, 0,
	+ "lock_count", CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ host, 0,
	nlm_host_lock_count_sysctl, "I", "");
	SYSCTL_ADD_PROC(&host->nh_sysctl, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "client_lock_count", CTLTYPE_INT \| CTLFLAG_RD, host, 0,
	+ "client_lock_count", CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ host, 0,
	nlm_host_client_lock_count_sysctl, "I", "");

	mtx_lock(&nlm_global_lock);
	Index: sys/ofed/drivers/infiniband/ulp/sdp/sdp_main.c
	===================================================================
	--- sys/ofed/drivers/infiniband/ulp/sdp/sdp_main.c
	+++ sys/ofed/drivers/infiniband/ulp/sdp/sdp_main.c
	@@ -1884,7 +1884,8 @@
	SYSCTL_NODE(_net_inet, -1, sdp, CTLFLAG_RW, 0, "SDP");

	SYSCTL_PROC(_net_inet_sdp, TCPCTL_PCBLIST, pcblist,
	- CTLFLAG_RD \| CTLTYPE_STRUCT, 0, 0, sdp_pcblist, "S,xtcpcb",
	+ CTLFLAG_RD \| CTLTYPE_STRUCT \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sdp_pcblist, "S,xtcpcb",
	"List of active SDP connections");

	static void
	Index: sys/powerpc/powermac/atibl.c
	===================================================================
	--- sys/powerpc/powermac/atibl.c
	+++ sys/powerpc/powermac/atibl.c
	@@ -160,7 +160,7 @@
	tree = device_get_sysctl_tree(dev);

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "level", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "level", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	atibl_sysctl, "I", "Backlight level (0-100)");

	return (0);
	Index: sys/powerpc/powermac/fcu.c
	===================================================================
	--- sys/powerpc/powermac/fcu.c
	+++ sys/powerpc/powermac/fcu.c
	@@ -632,7 +632,9 @@
	"Maximum allowed RPM");
	/* I use i to pass the fan id. */
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "rpm", CTLTYPE_INT \| CTLFLAG_RW, dev, i,
	+ "rpm",
	+ CTLTYPE_INT \| CTLFLAG_RW \|
	+ CTLFLAG_NEEDGIANT, dev, i,
	fcu_fanrpm_sysctl, "I", "Fan RPM");
	} else {
	fcu_fan_get_pwm(dev, &sc->sc_fans[i],
	@@ -654,11 +656,15 @@
	* of info I want to display/modify.
	*/
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "pwm", CTLTYPE_INT \| CTLFLAG_RW, dev,
	+ "pwm",
	+ CTLTYPE_INT \| CTLFLAG_RW \|
	+ CTLFLAG_NEEDGIANT, dev,
	FCU_PWM_SYSCTL_PWM \| i,
	fcu_fanrpm_sysctl, "I", "Fan PWM in %");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "rpm", CTLTYPE_INT \| CTLFLAG_RD, dev,
	+ "rpm",
	+ CTLTYPE_INT \| CTLFLAG_RD \|
	+ CTLFLAG_NEEDGIANT, dev,
	FCU_PWM_SYSCTL_RPM \| i,
	fcu_fanrpm_sysctl, "I", "Fan RPM");
	}
	Index: sys/powerpc/powermac/nvbl.c
	===================================================================
	--- sys/powerpc/powermac/nvbl.c
	+++ sys/powerpc/powermac/nvbl.c
	@@ -144,7 +144,8 @@
	tree = device_get_sysctl_tree(dev);

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "level", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "level",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	nvbl_sysctl, "I", "Backlight level (0-100)");

	return (0);
	Index: sys/powerpc/powermac/pmu.c
	===================================================================
	--- sys/powerpc/powermac/pmu.c
	+++ sys/powerpc/powermac/pmu.c
	@@ -433,7 +433,7 @@
	tree = device_get_sysctl_tree(dev);

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "server_mode", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "server_mode", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	pmu_server_mode, "I", "Enable reboot after power failure");

	if (sc->sc_batteries > 0) {
	@@ -443,12 +443,14 @@
	/* Only start the battery monitor if we have a battery. */
	kproc_start(&pmu_batt_kp);
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "monitor_batteries", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "monitor_batteries",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT, sc, 0,
	pmu_battmon, "I", "Post battery events to devd");


	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "acline", CTLTYPE_INT \| CTLFLAG_RD, sc, 0,
	+ "acline",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc, 0,
	pmu_acline_state, "I", "AC Line Status");

	battroot = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	@@ -463,38 +465,46 @@
	"Battery Information");

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "present", CTLTYPE_INT \| CTLFLAG_RD, sc,
	+ "present",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	PMU_BATSYSCTL_PRESENT \| i, pmu_battquery_sysctl,
	"I", "Battery present");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "charging", CTLTYPE_INT \| CTLFLAG_RD, sc,
	+ "charging",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	PMU_BATSYSCTL_CHARGING \| i, pmu_battquery_sysctl,
	"I", "Battery charging");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "charge", CTLTYPE_INT \| CTLFLAG_RD, sc,
	+ "charge",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	PMU_BATSYSCTL_CHARGE \| i, pmu_battquery_sysctl,
	"I", "Battery charge (mAh)");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "maxcharge", CTLTYPE_INT \| CTLFLAG_RD, sc,
	+ "maxcharge",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	PMU_BATSYSCTL_MAXCHARGE \| i, pmu_battquery_sysctl,
	"I", "Maximum battery capacity (mAh)");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "rate", CTLTYPE_INT \| CTLFLAG_RD, sc,
	+ "rate",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	PMU_BATSYSCTL_CURRENT \| i, pmu_battquery_sysctl,
	"I", "Battery discharge rate (mA)");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "voltage", CTLTYPE_INT \| CTLFLAG_RD, sc,
	+ "voltage",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	PMU_BATSYSCTL_VOLTAGE \| i, pmu_battquery_sysctl,
	"I", "Battery voltage (mV)");

	/* Knobs for mental compatibility with ACPI */

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "time", CTLTYPE_INT \| CTLFLAG_RD, sc,
	+ "time",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	PMU_BATSYSCTL_TIME \| i, pmu_battquery_sysctl,
	"I", "Time Remaining (minutes)");
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
	- "life", CTLTYPE_INT \| CTLFLAG_RD, sc,
	+ "life",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT, sc,
	PMU_BATSYSCTL_LIFE \| i, pmu_battquery_sysctl,
	"I", "Capacity remaining (percent)");
	}
	Index: sys/powerpc/powermac/smu.c
	===================================================================
	--- sys/powerpc/powermac/smu.c
	+++ sys/powerpc/powermac/smu.c
	@@ -379,7 +379,8 @@

	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
	SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
	- "server_mode", CTLTYPE_INT \| CTLFLAG_RW, dev, 0,
	+ "server_mode", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ dev, 0,
	smu_server_mode, "I", "Enable reboot after power failure");

	/*
	Index: sys/powerpc/powernv/opal_sensor.c
	===================================================================
	--- sys/powerpc/powernv/opal_sensor.c
	+++ sys/powerpc/powernv/opal_sensor.c
	@@ -206,7 +206,8 @@

	sc->sc_handle = sensor_id;
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "sensor", CTLTYPE_INT \| CTLFLAG_RD, sc, sensor_id,
	+ "sensor", CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ sc, sensor_id,
	opal_sensor_sysctl, (sc->sc_type == OPAL_SENSOR_TEMP) ? "IK" : "I",
	"current value");

	@@ -222,7 +223,8 @@
	&sensor_id, sizeof(sensor_id)) > 0) {
	sc->sc_min_handle = sensor_id;
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "sensor_min", CTLTYPE_INT \| CTLFLAG_RD, sc, sensor_id,
	+ "sensor_min", CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ sc, sensor_id,
	opal_sensor_sysctl,
	(sc->sc_type == OPAL_SENSOR_TEMP) ? "IK" : "I",
	"minimum value");
	@@ -232,7 +234,9 @@
	&sensor_id, sizeof(sensor_id)) > 0) {
	sc->sc_max_handle = sensor_id;
	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "sensor_max", CTLTYPE_INT \| CTLFLAG_RD, sc, sensor_id,
	+ "sensor_max",
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ sc, sensor_id,
	opal_sensor_sysctl,
	(sc->sc_type == OPAL_SENSOR_TEMP) ? "IK" : "I",
	"maximum value");
	Index: sys/powerpc/ps3/ps3disk.c
	===================================================================
	--- sys/powerpc/ps3/ps3disk.c
	+++ sys/powerpc/ps3/ps3disk.c
	@@ -681,7 +681,8 @@
	sc->sc_debug = ps3disk_debug;

	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
	- "debug", CTLTYPE_INT \| CTLFLAG_RW, sc, 0,
	+ "debug", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ sc, 0,
	ps3disk_sysctl_debug, "I", "control debugging printfs");
	#endif
	}
	Index: sys/rpc/svc.c
	===================================================================
	--- sys/rpc/svc.c
	+++ sys/rpc/svc.c
	@@ -128,15 +128,15 @@
	sysctl_ctx_init(&pool->sp_sysctl);
	if (sysctl_base) {
	SYSCTL_ADD_PROC(&pool->sp_sysctl, sysctl_base, OID_AUTO,
	- "minthreads", CTLTYPE_INT \| CTLFLAG_RW,
	+ "minthreads", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pool, 0, svcpool_minthread_sysctl, "I",
	"Minimal number of threads");
	SYSCTL_ADD_PROC(&pool->sp_sysctl, sysctl_base, OID_AUTO,
	- "maxthreads", CTLTYPE_INT \| CTLFLAG_RW,
	+ "maxthreads", CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	pool, 0, svcpool_maxthread_sysctl, "I",
	"Maximal number of threads");
	SYSCTL_ADD_PROC(&pool->sp_sysctl, sysctl_base, OID_AUTO,
	- "threads", CTLTYPE_INT \| CTLFLAG_RD,
	+ "threads", CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	pool, 0, svcpool_threads_sysctl, "I",
	"Current number of threads");
	SYSCTL_ADD_INT(&pool->sp_sysctl, sysctl_base, OID_AUTO,
	Index: sys/security/mac_portacl/mac_portacl.c
	===================================================================
	--- sys/security/mac_portacl/mac_portacl.c
	+++ sys/security/mac_portacl/mac_portacl.c
	@@ -372,7 +372,9 @@
	}

	SYSCTL_PROC(_security_mac_portacl, OID_AUTO, rules,
	- CTLTYPE_STRING\|CTLFLAG_RW, 0, 0, sysctl_rules, "A", "Rules");
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_rules, "A",
	+ "Rules");

	static int
	rules_check(struct ucred *cred, int family, int type, u_int16_t port)
	Index: sys/security/mac_veriexec/mac_veriexec.c
	===================================================================
	--- sys/security/mac_veriexec/mac_veriexec.c
	+++ sys/security/mac_veriexec/mac_veriexec.c
	@@ -85,11 +85,13 @@

	static int mac_veriexec_state;
	SYSCTL_PROC(_security_mac_veriexec, OID_AUTO, state,
	- CTLTYPE_STRING \| CTLFLAG_RD, 0, 0, sysctl_mac_veriexec_state, "A",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_mac_veriexec_state, "A",
	"Verified execution subsystem state");

	SYSCTL_PROC(_security_mac_veriexec, OID_AUTO, db,
	- CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_SKIP, 0, 0, sysctl_mac_veriexec_db,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_SKIP \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_mac_veriexec_db,
	"A", "Verified execution fingerprint database");

	static int mac_veriexec_slot;
	Index: sys/security/mac_veriexec/veriexec_fingerprint.c
	===================================================================
	--- sys/security/mac_veriexec/veriexec_fingerprint.c
	+++ sys/security/mac_veriexec/veriexec_fingerprint.c
	@@ -64,7 +64,8 @@
	static int sysctl_mac_veriexec_algorithms(SYSCTL_HANDLER_ARGS);

	SYSCTL_PROC(_security_mac_veriexec, OID_AUTO, algorithms,
	- CTLTYPE_STRING \| CTLFLAG_RD, 0, 0, sysctl_mac_veriexec_algorithms, "A",
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_mac_veriexec_algorithms, "A",
	"Verified execution supported hashing algorithms");

	static int
	Index: sys/sys/sysctl.h
	===================================================================
	--- sys/sys/sysctl.h
	+++ sys/sys/sysctl.h
	@@ -38,6 +38,10 @@
	#ifndef _SYS_SYSCTL_H_
	#define _SYS_SYSCTL_H_

	+#ifndef static_assert
	+#define static_assert _Static_assert
	+#endif
	+
	#ifdef _KERNEL
	#include <sys/queue.h>
	#endif
	@@ -105,6 +109,7 @@
	#define CTLFLAG_STATS 0x00002000 /* Statistics, not a tuneable */
	#define CTLFLAG_NOFETCH 0x00001000 /* Don't fetch tunable from getenv() */
	#define CTLFLAG_CAPRW (CTLFLAG_CAPRD\|CTLFLAG_CAPWR)
	+#define CTLFLAG_NEEDGIANT 0x00000800 /* Handler require Giant */

	/*
	* Secure level. Note that CTLFLAG_SECURE == CTLFLAG_SECURE1.
	@@ -263,6 +268,13 @@
	#define __DESCR(d) ""
	#endif

	+#define SYSCTL_ENFORCE_FLAGS(x) \
	+ static_assert(((CTLFLAG_MPSAFE ^ CTLFLAG_NEEDGIANT) & (x)), \
	+ "Has to be either CTLFLAG_MPSAFE or CTLFLAG_NEEDGIANT")
	+
	+#define SYSCTL_MAYBE_ADD_MPSAFE(x) \
	+ ((x)\|(((x) & CTLFLAG_NEEDGIANT) ? 0 : CTLFLAG_MPSAFE))
	+
	/* This macro is only for internal use */
	#define SYSCTL_OID_RAW(id, parent_child_head, nbr, name, kind, a1, a2, handler, fmt, descr, label) \
	struct sysctl_oid id = { \
	@@ -278,7 +290,9 @@
	.oid_descr = __DESCR(descr), \
	.oid_label = (label), \
	}; \
	- DATA_SET(sysctl_set, id)
	+ DATA_SET(sysctl_set, id); \
	+ SYSCTL_ENFORCE_FLAGS(kind)
	+

	/* This constructs a static "raw" MIB oid. */
	#define SYSCTL_OID(parent, nbr, name, kind, a1, a2, handler, fmt, descr) \
	@@ -297,13 +311,17 @@
	nbr, #name, kind, a1, a2, handler, fmt, descr, label)

	#define SYSCTL_ADD_OID(ctx, parent, nbr, name, kind, a1, a2, handler, fmt, descr) \
	- sysctl_add_oid(ctx, parent, nbr, name, kind, a1, a2, handler, fmt, __DESCR(descr), NULL)
	+({ \
	+ SYSCTL_ENFORCE_FLAGS(kind); \
	+ sysctl_add_oid(ctx, parent, nbr, name, kind, a1, a2, handler, fmt, __DESCR(descr), NULL); \
	+})

	/* This constructs a root node from which other nodes can hang. */
	#define SYSCTL_ROOT_NODE(nbr, name, access, handler, descr) \
	SYSCTL_OID_RAW(sysctl___##name, &sysctl__children, \
	- nbr, #name, CTLTYPE_NODE\|(access), NULL, 0, \
	- handler, "N", descr, NULL); \
	+ nbr, #name, \
	+ CTLTYPE_NODE\|SYSCTL_MAYBE_ADD_MPSAFE(access), \
	+ NULL, 0, handler, "N", descr, NULL); \
	CTASSERT(((access) & CTLTYPE) == 0 \|\| \
	((access) & SYSCTL_CT_ASSERT_MASK) == CTLTYPE_NODE)

	@@ -312,20 +330,23 @@
	SYSCTL_NODE_WITH_LABEL(parent, nbr, name, access, handler, descr, NULL)

	#define SYSCTL_NODE_WITH_LABEL(parent, nbr, name, access, handler, descr, label) \
	- SYSCTL_OID_GLOBAL(parent, nbr, name, CTLTYPE_NODE\|(access), \
	+ SYSCTL_OID_GLOBAL(parent, nbr, name, \
	+ CTLTYPE_NODE\|SYSCTL_MAYBE_ADD_MPSAFE(access), \
	NULL, 0, handler, "N", descr, label); \
	CTASSERT(((access) & CTLTYPE) == 0 \|\| \
	((access) & SYSCTL_CT_ASSERT_MASK) == CTLTYPE_NODE)

	#define SYSCTL_ADD_NODE(ctx, parent, nbr, name, access, handler, descr) \
	- SYSCTL_ADD_NODE_WITH_LABEL(ctx, parent, nbr, name, access, \
	+ SYSCTL_ADD_NODE_WITH_LABEL(ctx, parent, nbr, name, access, \
	handler, descr, NULL)

	#define SYSCTL_ADD_NODE_WITH_LABEL(ctx, parent, nbr, name, access, handler, descr, label) \
	({ \
	CTASSERT(((access) & CTLTYPE) == 0 \|\| \
	((access) & SYSCTL_CT_ASSERT_MASK) == CTLTYPE_NODE); \
	- sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_NODE\|(access), \
	+ SYSCTL_ENFORCE_FLAGS(SYSCTL_MAYBE_ADD_MPSAFE(access)); \
	+ sysctl_add_oid(ctx, parent, nbr, name, \
	+ CTLTYPE_NODE\|SYSCTL_MAYBE_ADD_MPSAFE(access), \
	NULL, 0, handler, "N", __DESCR(descr), label); \
	})

	@@ -333,14 +354,16 @@
	({ \
	CTASSERT(((access) & CTLTYPE) == 0 \|\| \
	((access) & SYSCTL_CT_ASSERT_MASK) == CTLTYPE_NODE); \
	+ SYSCTL_ENFORCE_FLAGS(SYSCTL_MAYBE_ADD_MPSAFE(access)); \
	sysctl_add_oid(ctx, &sysctl__children, nbr, name, \
	- CTLTYPE_NODE\|(access), \
	+ CTLTYPE_NODE\|SYSCTL_MAYBE_ADD_MPSAFE(access), \
	NULL, 0, handler, "N", __DESCR(descr), NULL); \
	})

	/* Oid for a string. len can be 0 to indicate '\0' termination. */
	#define SYSCTL_STRING(parent, nbr, name, access, arg, len, descr) \
	- SYSCTL_OID(parent, nbr, name, CTLTYPE_STRING\|(access), \
	+ SYSCTL_OID(parent, nbr, name, \
	+ CTLTYPE_STRING \| CTLFLAG_MPSAFE \| (access), \
	arg, len, sysctl_handle_string, "A", descr); \
	CTASSERT(((access) & CTLTYPE) == 0 \|\| \
	((access) & SYSCTL_CT_ASSERT_MASK) == CTLTYPE_STRING)
	@@ -350,7 +373,8 @@
	char *__arg = (arg); \
	CTASSERT(((access) & CTLTYPE) == 0 \|\| \
	((access) & SYSCTL_CT_ASSERT_MASK) == CTLTYPE_STRING); \
	- sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_STRING\|(access), \
	+ sysctl_add_oid(ctx, parent, nbr, name, \
	+ CTLTYPE_STRING \| CTLFLAG_MPSAFE \| (access), \
	__arg, len, sysctl_handle_string, "A", __DESCR(descr), \
	NULL); \
	})
	@@ -741,7 +765,8 @@

	/* Oid for an opaque object. Specified by a pointer and a length. */
	#define SYSCTL_OPAQUE(parent, nbr, name, access, ptr, len, fmt, descr) \
	- SYSCTL_OID(parent, nbr, name, CTLTYPE_OPAQUE\|(access), \
	+ SYSCTL_OID(parent, nbr, name, \
	+ CTLTYPE_OPAQUE \| CTLFLAG_MPSAFE \| (access), \
	ptr, len, sysctl_handle_opaque, fmt, descr); \
	CTASSERT(((access) & CTLTYPE) == 0 \|\| \
	((access) & SYSCTL_CT_ASSERT_MASK) == CTLTYPE_OPAQUE)
	@@ -750,13 +775,15 @@
	({ \
	CTASSERT(((access) & CTLTYPE) == 0 \|\| \
	((access) & SYSCTL_CT_ASSERT_MASK) == CTLTYPE_OPAQUE); \
	- sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_OPAQUE\|(access), \
	+ sysctl_add_oid(ctx, parent, nbr, name, \
	+ CTLTYPE_OPAQUE \| CTLFLAG_MPSAFE \| (access), \
	ptr, len, sysctl_handle_opaque, fmt, __DESCR(descr), NULL); \
	})

	/* Oid for a struct. Specified by a pointer and a type. */
	#define SYSCTL_STRUCT(parent, nbr, name, access, ptr, type, descr) \
	- SYSCTL_OID(parent, nbr, name, CTLTYPE_OPAQUE\|(access), \
	+ SYSCTL_OID(parent, nbr, name, \
	+ CTLTYPE_OPAQUE \| CTLFLAG_MPSAFE \| (access), \
	ptr, sizeof(struct type), sysctl_handle_opaque, \
	"S," #type, descr); \
	CTASSERT(((access) & CTLTYPE) == 0 \|\| \
	@@ -766,7 +793,8 @@
	({ \
	CTASSERT(((access) & CTLTYPE) == 0 \|\| \
	((access) & SYSCTL_CT_ASSERT_MASK) == CTLTYPE_OPAQUE); \
	- sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_OPAQUE\|(access), \
	+ sysctl_add_oid(ctx, parent, nbr, name, \
	+ CTLTYPE_OPAQUE \| CTLFLAG_MPSAFE \| (access), \
	(ptr), sizeof(struct type), \
	sysctl_handle_opaque, "S," #type, __DESCR(descr), NULL); \
	})
	@@ -780,6 +808,7 @@
	#define SYSCTL_ADD_PROC(ctx, parent, nbr, name, access, ptr, arg, handler, fmt, descr) \
	({ \
	CTASSERT(((access) & CTLTYPE) != 0); \
	+ SYSCTL_ENFORCE_FLAGS(access); \
	sysctl_add_oid(ctx, parent, nbr, name, (access), \
	(ptr), (arg), (handler), (fmt), __DESCR(descr), NULL); \
	})
	Index: sys/tests/epoch/epoch_test.c
	===================================================================
	--- sys/tests/epoch/epoch_test.c
	+++ sys/tests/epoch/epoch_test.c
	@@ -186,8 +186,10 @@
	}

	SYSCTL_NODE(_kern, OID_AUTO, epochtest, CTLFLAG_RW, 0, "Epoch Test Framework");
	-SYSCTL_PROC(_kern_epochtest, OID_AUTO, runtest, (CTLTYPE_INT \| CTLFLAG_RW),
	- 0, 0, epochtest_execute, "I", "Execute an epoch test");
	+SYSCTL_PROC(_kern_epochtest, OID_AUTO, runtest,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, epochtest_execute, "I",
	+ "Execute an epoch test");

	static int
	epoch_test_module_event_handler(module_t mod, int what, void *arg __unused)
	Index: sys/tests/framework/kern_testfrwk.c
	===================================================================
	--- sys/tests/framework/kern_testfrwk.c
	+++ sys/tests/framework/kern_testfrwk.c
	@@ -167,8 +167,10 @@
	static int kerntest_execute(SYSCTL_HANDLER_ARGS);

	SYSCTL_NODE(_kern, OID_AUTO, testfrwk, CTLFLAG_RW, 0, "Kernel Test Framework");
	-SYSCTL_PROC(_kern_testfrwk, OID_AUTO, runtest, (CTLTYPE_STRUCT \| CTLFLAG_RW),
	- 0, 0, kerntest_execute, "IU", "Execute a kernel test");
	+SYSCTL_PROC(_kern_testfrwk, OID_AUTO, runtest,
	+ CTLTYPE_STRUCT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, kerntest_execute, "IU",
	+ "Execute a kernel test");

	int
	kerntest_execute(SYSCTL_HANDLER_ARGS)
	Index: sys/ufs/ffs/ffs_alloc.c
	===================================================================
	--- sys/ufs/ffs/ffs_alloc.c
	+++ sys/ufs/ffs/ffs_alloc.c
	@@ -3101,8 +3101,10 @@

	static int sysctl_ffs_fsck(SYSCTL_HANDLER_ARGS);

	-SYSCTL_PROC(_vfs_ffs, FFS_ADJ_REFCNT, adjrefcnt, CTLFLAG_WR\|CTLTYPE_STRUCT,
	- 0, 0, sysctl_ffs_fsck, "S,fsck", "Adjust Inode Reference Count");
	+SYSCTL_PROC(_vfs_ffs, FFS_ADJ_REFCNT, adjrefcnt,
	+ CTLFLAG_WR \| CTLTYPE_STRUCT \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_ffs_fsck, "S,fsck",
	+ "Adjust Inode Reference Count");

	static SYSCTL_NODE(_vfs_ffs, FFS_ADJ_BLKCNT, adjblkcnt, CTLFLAG_WR,
	sysctl_ffs_fsck, "Adjust Inode Used Blocks Count");
	Index: sys/ufs/ufs/ufs_dirhash.c
	===================================================================
	--- sys/ufs/ufs/ufs_dirhash.c
	+++ sys/ufs/ufs/ufs_dirhash.c
	@@ -90,7 +90,8 @@
	static int ufs_dirhashreclaimpercent = 10;
	static int ufsdirhash_set_reclaimpercent(SYSCTL_HANDLER_ARGS);
	SYSCTL_PROC(_vfs_ufs, OID_AUTO, dirhash_reclaimpercent,
	- CTLTYPE_INT \| CTLFLAG_RW, 0, 0, ufsdirhash_set_reclaimpercent, "I",
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, ufsdirhash_set_reclaimpercent, "I",
	"set percentage of dirhash cache to be removed in low VM events");


	Index: sys/vm/vm_phys.c
	===================================================================
	--- sys/vm/vm_phys.c
	+++ sys/vm/vm_phys.c
	@@ -148,17 +148,23 @@
	#endif

	static int sysctl_vm_phys_free(SYSCTL_HANDLER_ARGS);
	-SYSCTL_OID(_vm, OID_AUTO, phys_free, CTLTYPE_STRING \| CTLFLAG_RD,
	- NULL, 0, sysctl_vm_phys_free, "A", "Phys Free Info");
	+SYSCTL_OID(_vm, OID_AUTO, phys_free,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_vm_phys_free, "A",
	+ "Phys Free Info");

	static int sysctl_vm_phys_segs(SYSCTL_HANDLER_ARGS);
	-SYSCTL_OID(_vm, OID_AUTO, phys_segs, CTLTYPE_STRING \| CTLFLAG_RD,
	- NULL, 0, sysctl_vm_phys_segs, "A", "Phys Seg Info");
	+SYSCTL_OID(_vm, OID_AUTO, phys_segs,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_vm_phys_segs, "A",
	+ "Phys Seg Info");

	#ifdef NUMA
	static int sysctl_vm_phys_locality(SYSCTL_HANDLER_ARGS);
	-SYSCTL_OID(_vm, OID_AUTO, phys_locality, CTLTYPE_STRING \| CTLFLAG_RD,
	- NULL, 0, sysctl_vm_phys_locality, "A", "Phys Locality Info");
	+SYSCTL_OID(_vm, OID_AUTO, phys_locality,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_vm_phys_locality, "A",
	+ "Phys Locality Info");
	#endif

	SYSCTL_INT(_vm, OID_AUTO, ndomains, CTLFLAG_RD,
	Index: sys/vm/vm_reserv.c
	===================================================================
	--- sys/vm/vm_reserv.c
	+++ sys/vm/vm_reserv.c
	@@ -278,8 +278,10 @@

	static int sysctl_vm_reserv_partpopq(SYSCTL_HANDLER_ARGS);

	-SYSCTL_OID(_vm_reserv, OID_AUTO, partpopq, CTLTYPE_STRING \| CTLFLAG_RD, NULL, 0,
	- sysctl_vm_reserv_partpopq, "A", "Partially populated reservation queues");
	+SYSCTL_OID(_vm_reserv, OID_AUTO, partpopq,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ NULL, 0, sysctl_vm_reserv_partpopq, "A",
	+ "Partially populated reservation queues");

	static counter_u64_t vm_reserv_reclaimed = EARLY_COUNTER;
	SYSCTL_COUNTER_U64(_vm_reserv, OID_AUTO, reclaimed, CTLFLAG_RD,
	Index: sys/x86/isa/clock.c
	===================================================================
	--- sys/x86/isa/clock.c
	+++ sys/x86/isa/clock.c
	@@ -473,7 +473,8 @@
	return (error);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, i8254_freq, CTLTYPE_INT \| CTLFLAG_RW,
	+SYSCTL_PROC(_machdep, OID_AUTO, i8254_freq,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	0, sizeof(u_int), sysctl_machdep_i8254_freq, "IU",
	"i8254 timer frequency");

	Index: sys/x86/x86/cpu_machdep.c
	===================================================================
	--- sys/x86/x86/cpu_machdep.c
	+++ sys/x86/x86/cpu_machdep.c
	@@ -741,8 +741,10 @@
	return (error);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, idle_available, CTLTYPE_STRING \| CTLFLAG_RD,
	- 0, 0, idle_sysctl_available, "A", "list of available idle functions");
	+SYSCTL_PROC(_machdep, OID_AUTO, idle_available,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, idle_sysctl_available, "A",
	+ "list of available idle functions");

	static bool
	cpu_idle_selector(const char *new_idle_name)
	@@ -786,8 +788,10 @@
	return (cpu_idle_selector(buf) ? 0 : EINVAL);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, idle, CTLTYPE_STRING \| CTLFLAG_RW, 0, 0,
	- cpu_idle_sysctl, "A", "currently selected idle function");
	+SYSCTL_PROC(_machdep, OID_AUTO, idle,
	+ CTLTYPE_STRING \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, cpu_idle_sysctl, "A",
	+ "currently selected idle function");

	static void
	cpu_idle_tun(void *unused __unused)
	Index: sys/x86/x86/intr_machdep.c
	===================================================================
	--- sys/x86/x86/intr_machdep.c
	+++ sys/x86/x86/intr_machdep.c
	@@ -750,8 +750,10 @@
	sbuf_delete(&sbuf);
	return (error);
	}
	-SYSCTL_PROC(_hw, OID_AUTO, intrs, CTLTYPE_STRING \| CTLFLAG_RD,
	- 0, 0, sysctl_hw_intrs, "A", "interrupt:number @cpu: count");
	+SYSCTL_PROC(_hw, OID_AUTO, intrs,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_hw_intrs, "A",
	+ "interrupt:number @cpu: count");

	/*
	* Compare two, possibly NULL, entries in the interrupt source array
	Index: sys/x86/x86/mp_watchdog.c
	===================================================================
	--- sys/x86/x86/mp_watchdog.c
	+++ sys/x86/x86/mp_watchdog.c
	@@ -149,8 +149,10 @@
	watchdog_change(temp);
	return (0);
	}
	-SYSCTL_PROC(_debug, OID_AUTO, watchdog, CTLTYPE_INT\|CTLFLAG_RW, 0, 0,
	- sysctl_watchdog, "I", "");
	+SYSCTL_PROC(_debug, OID_AUTO, watchdog,
	+ CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_watchdog, "I",
	+ "");

	/*
	* Drop into the debugger by sending an IPI NMI to the boot processor.
	Index: sys/x86/x86/tsc.c
	===================================================================
	--- sys/x86/x86/tsc.c
	+++ sys/x86/x86/tsc.c
	@@ -751,8 +751,10 @@
	return (error);
	}

	-SYSCTL_PROC(_machdep, OID_AUTO, tsc_freq, CTLTYPE_U64 \| CTLFLAG_RW,
	- 0, 0, sysctl_machdep_tsc_freq, "QU", "Time Stamp Counter frequency");
	+SYSCTL_PROC(_machdep, OID_AUTO, tsc_freq,
	+ CTLTYPE_U64 \| CTLFLAG_RW \| CTLFLAG_NEEDGIANT,
	+ 0, 0, sysctl_machdep_tsc_freq, "QU",
	+ "Time Stamp Counter frequency");

	static u_int
	tsc_get_timecount(struct timecounter *tc __unused)
	Index: sys/xen/xenbus/xenbusb.c
	===================================================================
	--- sys/xen/xenbus/xenbusb.c
	+++ sys/xen/xenbus/xenbusb.c
	@@ -351,7 +351,7 @@
	SYSCTL_CHILDREN(tree),
	OID_AUTO,
	"xenstore_path",
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev,
	XENBUS_IVAR_NODE,
	xenbusb_device_sysctl_handler,
	@@ -362,7 +362,7 @@
	SYSCTL_CHILDREN(tree),
	OID_AUTO,
	"xenbus_dev_type",
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev,
	XENBUS_IVAR_TYPE,
	xenbusb_device_sysctl_handler,
	@@ -373,7 +373,7 @@
	SYSCTL_CHILDREN(tree),
	OID_AUTO,
	"xenbus_connection_state",
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev,
	XENBUS_IVAR_STATE,
	xenbusb_device_sysctl_handler,
	@@ -384,7 +384,7 @@
	SYSCTL_CHILDREN(tree),
	OID_AUTO,
	"xenbus_peer_domid",
	- CTLTYPE_INT \| CTLFLAG_RD,
	+ CTLTYPE_INT \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev,
	XENBUS_IVAR_OTHEREND_ID,
	xenbusb_device_sysctl_handler,
	@@ -395,7 +395,7 @@
	SYSCTL_CHILDREN(tree),
	OID_AUTO,
	"xenstore_peer_path",
	- CTLTYPE_STRING \| CTLFLAG_RD,
	+ CTLTYPE_STRING \| CTLFLAG_RD \| CTLFLAG_NEEDGIANT,
	dev,
	XENBUS_IVAR_OTHEREND_PATH,
	xenbusb_device_sysctl_handler,

File Metadata

Mime Type: text/plain
Expires: Thu, Sep 17, 4:09 PM (18 h, 32 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 29736148
Default Alt Text: D23110.1789661378.diff (459 KB)

D23110.1789661378.diffNo OneTemporaryActions

D23110.1789661378.diffView Options

File Metadata

Event Timeline

D23110.1789661378.diff
No OneTemporary
Actions

D23110.1789661378.diff
View Options