Fix multiple incorrect SYSCTL arguments in the kernel:

- Wrong integer type was specified.

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

- Logical OR where binary OR was expected.

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

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

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

- Updated "EXAMPLES" section in SYSCTL manual page.

MFC after:	3 days
Sponsored by:	Mellanox Technologies
This commit is contained in:
Hans Petter Selasky 2014-10-21 07:31:21 +00:00
parent 7eb884645c
commit f0188618f2
69 changed files with 612 additions and 548 deletions

View File

@ -1499,6 +1499,7 @@ MLINKS+=sysctl.9 SYSCTL_DECL.9 \
sysctl.9 SYSCTL_ADD_ROOT_NODE.9 \ sysctl.9 SYSCTL_ADD_ROOT_NODE.9 \
sysctl.9 SYSCTL_ADD_STRING.9 \ sysctl.9 SYSCTL_ADD_STRING.9 \
sysctl.9 SYSCTL_ADD_STRUCT.9 \ sysctl.9 SYSCTL_ADD_STRUCT.9 \
sysctl.9 SYSCTL_ADD_UAUTO.9 \
sysctl.9 SYSCTL_ADD_UINT.9 \ sysctl.9 SYSCTL_ADD_UINT.9 \
sysctl.9 SYSCTL_ADD_ULONG.9 \ sysctl.9 SYSCTL_ADD_ULONG.9 \
sysctl.9 SYSCTL_ADD_UQUAD.9 \ sysctl.9 SYSCTL_ADD_UQUAD.9 \

View File

@ -25,7 +25,7 @@
.\" .\"
.\" $FreeBSD$ .\" $FreeBSD$
.\" .\"
.Dd September 15, 2014 .Dd October 20, 2014
.Dt SYSCTL 9 .Dt SYSCTL 9
.Os .Os
.Sh NAME .Sh NAME
@ -39,6 +39,7 @@
.Nm SYSCTL_ADD_ROOT_NODE , .Nm SYSCTL_ADD_ROOT_NODE ,
.Nm SYSCTL_ADD_STRING , .Nm SYSCTL_ADD_STRING ,
.Nm SYSCTL_ADD_STRUCT , .Nm SYSCTL_ADD_STRUCT ,
.Nm SYSCTL_ADD_UAUTO ,
.Nm SYSCTL_ADD_UINT , .Nm SYSCTL_ADD_UINT ,
.Nm SYSCTL_ADD_ULONG , .Nm SYSCTL_ADD_ULONG ,
.Nm SYSCTL_ADD_UQUAD , .Nm SYSCTL_ADD_UQUAD ,
@ -82,7 +83,6 @@
.Fa "const char *name" .Fa "const char *name"
.Fa "int ctlflags" .Fa "int ctlflags"
.Fa "long *ptr" .Fa "long *ptr"
.Fa "intptr_t val"
.Fa "const char *descr" .Fa "const char *descr"
.Fc .Fc
.Ft struct sysctl_oid * .Ft struct sysctl_oid *
@ -128,7 +128,6 @@
.Fa "const char *name" .Fa "const char *name"
.Fa "int ctlflags" .Fa "int ctlflags"
.Fa "quad_t *ptr" .Fa "quad_t *ptr"
.Fa "intptr_t val"
.Fa "const char *descr" .Fa "const char *descr"
.Fc .Fc
.Ft struct sysctl_oid * .Ft struct sysctl_oid *
@ -181,7 +180,6 @@
.Fa "const char *name" .Fa "const char *name"
.Fa "int ctlflags" .Fa "int ctlflags"
.Fa "unsigned long *ptr" .Fa "unsigned long *ptr"
.Fa "intptr_t val"
.Fa "const char *descr" .Fa "const char *descr"
.Fc .Fc
.Ft struct sysctl_oid * .Ft struct sysctl_oid *
@ -192,7 +190,16 @@
.Fa "const char *name" .Fa "const char *name"
.Fa "int ctlflags" .Fa "int ctlflags"
.Fa "u_quad_t *ptr" .Fa "u_quad_t *ptr"
.Fa "intptr_t val" .Fa "const char *descr"
.Fc
.Ft struct sysctl_oid *
.Fo SYSCTL_ADD_UAUTO
.Fa "struct sysctl_ctx_list *ctx"
.Fa "struct sysctl_oid_list *parent"
.Fa "int number"
.Fa "const char *name"
.Fa "int ctlflags"
.Fa "void *ptr"
.Fa "const char *descr" .Fa "const char *descr"
.Fc .Fc
.Ft struct sysctl_oid_list * .Ft struct sysctl_oid_list *
@ -283,13 +290,13 @@ For string type OIDs a length of zero means that
will be used to get the length of the string at each access to the OID. will be used to get the length of the string at each access to the OID.
.It Fa ptr .It Fa ptr
Pointer to sysctl variable or string data. Pointer to sysctl variable or string data.
For sysctl values the pointer can be NULL which means the OID is read-only and the returned value should be taken from the For sysctl values the pointer can be SYSCTL_NULL_XXX_PTR which means the OID is read-only and the returned value should be taken from the
.Fa val .Fa val
argument. argument.
.It Fa val .It Fa val
If the If the
.Fa ptr .Fa ptr
argument is NULL, gives the constant value returned by this OID. argument is SYSCTL_NULL_XXX_PTR, gives the constant value returned by this OID.
Else this argument is not used. Else this argument is not used.
.It Fa struct_type .It Fa struct_type
Name of structure type. Name of structure type.
@ -424,8 +431,9 @@ Dynamic nodes are created using one of the
.Fn SYSCTL_ADD_ROOT_NODE , .Fn SYSCTL_ADD_ROOT_NODE ,
.Fn SYSCTL_ADD_STRING , .Fn SYSCTL_ADD_STRING ,
.Fn SYSCTL_ADD_STRUCT , .Fn SYSCTL_ADD_STRUCT ,
.Fn SYSCTL_ADD_UAUTO ,
.Fn SYSCTL_ADD_UINT , .Fn SYSCTL_ADD_UINT ,
.Fn SYSCTL_ADD_ULONG .Fn SYSCTL_ADD_ULONG ,
or or
.Fn SYSCTL_UQUAD .Fn SYSCTL_UQUAD
functions. functions.
@ -521,10 +529,10 @@ Examples of integer, opaque, string, and procedure sysctls follow:
.Bd -literal -offset indent .Bd -literal -offset indent
/* /*
* Example of a constant integer value. Notice that the control * Example of a constant integer value. Notice that the control
* flags are CTLFLAG_RD, the variable pointer is NULL, and the * flags are CTLFLAG_RD, the variable pointer is SYSCTL_NULL_INT_PTR,
* value is declared. * and the value is declared.
*/ */
SYSCTL_INT(_debug_sizeof, OID_AUTO, bio, CTLFLAG_RD, NULL, SYSCTL_INT(_debug_sizeof, OID_AUTO, bio, CTLFLAG_RD, SYSCTL_NULL_INT_PTR,
sizeof(struct bio), "sizeof(struct bio)"); sizeof(struct bio), "sizeof(struct bio)");
/* /*

View File

@ -130,7 +130,7 @@ CTASSERT(sizeof(struct pcb) % XSAVE_AREA_ALIGN == 0);
static void fpu_clean_state(void); static void fpu_clean_state(void);
SYSCTL_INT(_hw, HW_FLOATINGPT, floatingpoint, CTLFLAG_RD, SYSCTL_INT(_hw, HW_FLOATINGPT, floatingpoint, CTLFLAG_RD,
NULL, 1, "Floating point instructions executed in hardware"); SYSCTL_NULL_INT_PTR, 1, "Floating point instructions executed in hardware");
int use_xsave; /* non-static for cpu_switch.S */ int use_xsave; /* non-static for cpu_switch.S */
uint64_t xsave_mask; /* the same */ uint64_t xsave_mask; /* the same */

View File

@ -1525,9 +1525,9 @@ alloc_bounce_zone(bus_dma_tag_t dmat)
SYSCTL_ADD_STRING(busdma_sysctl_tree(bz), SYSCTL_ADD_STRING(busdma_sysctl_tree(bz),
SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO, SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO,
"lowaddr", CTLFLAG_RD, bz->lowaddrid, 0, ""); "lowaddr", CTLFLAG_RD, bz->lowaddrid, 0, "");
SYSCTL_ADD_INT(busdma_sysctl_tree(bz), SYSCTL_ADD_ULONG(busdma_sysctl_tree(bz),
SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO, SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO,
"alignment", CTLFLAG_RD, &bz->alignment, 0, ""); "alignment", CTLFLAG_RD, &bz->alignment, "");
return (0); return (0);
} }

View File

@ -1346,9 +1346,9 @@ alloc_bounce_zone(bus_dma_tag_t dmat)
SYSCTL_ADD_STRING(busdma_sysctl_tree(bz), SYSCTL_ADD_STRING(busdma_sysctl_tree(bz),
SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO, SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO,
"lowaddr", CTLFLAG_RD, bz->lowaddrid, 0, ""); "lowaddr", CTLFLAG_RD, bz->lowaddrid, 0, "");
SYSCTL_ADD_INT(busdma_sysctl_tree(bz), SYSCTL_ADD_ULONG(busdma_sysctl_tree(bz),
SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO, SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO,
"alignment", CTLFLAG_RD, &bz->alignment, 0, ""); "alignment", CTLFLAG_RD, &bz->alignment, "");
return (0); return (0);
} }

View File

@ -1487,13 +1487,13 @@ sasysctlinit(void *context, int pending)
goto bailout; goto bailout;
SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree), SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
OID_AUTO, "allow_io_split", CTLTYPE_INT | CTLFLAG_RDTUN | CTLFLAG_NOFETCH, OID_AUTO, "allow_io_split", CTLFLAG_RDTUN | CTLFLAG_NOFETCH,
&softc->allow_io_split, 0, "Allow Splitting I/O"); &softc->allow_io_split, 0, "Allow Splitting I/O");
SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree), SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
OID_AUTO, "maxio", CTLTYPE_INT | CTLFLAG_RD, OID_AUTO, "maxio", CTLFLAG_RD,
&softc->maxio, 0, "Maximum I/O size"); &softc->maxio, 0, "Maximum I/O size");
SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree), SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
OID_AUTO, "cpi_maxio", CTLTYPE_INT | CTLFLAG_RD, OID_AUTO, "cpi_maxio", CTLFLAG_RD,
&softc->cpi_maxio, 0, "Maximum Controller I/O size"); &softc->cpi_maxio, 0, "Maximum Controller I/O size");
bailout: bailout:

View File

@ -67,8 +67,8 @@
#include "zfs_comutil.h" #include "zfs_comutil.h"
/* Used by fstat(1). */ /* Used by fstat(1). */
SYSCTL_INT(_debug_sizeof, OID_AUTO, znode, CTLFLAG_RD, 0, sizeof(znode_t), SYSCTL_INT(_debug_sizeof, OID_AUTO, znode, CTLFLAG_RD,
"sizeof(znode_t)"); SYSCTL_NULL_INT_PTR, sizeof(znode_t), "sizeof(znode_t)");
/* /*
* Define ZNODE_STATS to turn on statistic gathering. By default, it is only * Define ZNODE_STATS to turn on statistic gathering. By default, it is only

View File

@ -86,8 +86,8 @@ SYSCTL_NODE(_kern, OID_AUTO, dtrace, CTLFLAG_RD, 0, "DTrace parameters");
SYSCTL_INT(_kern_dtrace, OID_AUTO, memstr_max, CTLFLAG_RW, &dtrace_memstr_max, SYSCTL_INT(_kern_dtrace, OID_AUTO, memstr_max, CTLFLAG_RW, &dtrace_memstr_max,
0, "largest allowed argument to memstr(), 0 indicates no limit"); 0, "largest allowed argument to memstr(), 0 indicates no limit");
SYSCTL_LONG(_kern_dtrace, OID_AUTO, dof_maxsize, CTLFLAG_RW, SYSCTL_QUAD(_kern_dtrace, OID_AUTO, dof_maxsize, CTLFLAG_RW,
&dtrace_dof_maxsize, 0, "largest allowed DOF table"); &dtrace_dof_maxsize, 0, "largest allowed DOF table");
SYSCTL_LONG(_kern_dtrace, OID_AUTO, helper_actions_max, CTLFLAG_RW, SYSCTL_QUAD(_kern_dtrace, OID_AUTO, helper_actions_max, CTLFLAG_RW,
&dtrace_helper_actions_max, 0, "maximum number of allowed helper actions"); &dtrace_helper_actions_max, 0, "maximum number of allowed helper actions");

View File

@ -79,6 +79,7 @@ __FBSDID("$FreeBSD$");
#include <dev/if_ndis/if_ndisvar.h> #include <dev/if_ndis/if_ndisvar.h>
#define NDIS_DUMMY_PATH "\\\\some\\bogus\\path" #define NDIS_DUMMY_PATH "\\\\some\\bogus\\path"
#define NDIS_FLAG_RDONLY 1
static void ndis_status_func(ndis_handle, ndis_status, void *, uint32_t); static void ndis_status_func(ndis_handle, ndis_status, void *, uint32_t);
static void ndis_statusdone_func(ndis_handle); static void ndis_statusdone_func(ndis_handle);
@ -326,48 +327,48 @@ ndis_create_sysctls(arg)
* We qualify as the latter. * We qualify as the latter.
*/ */
ndis_add_sysctl(sc, "Environment", ndis_add_sysctl(sc, "Environment",
"Windows environment", "1", CTLFLAG_RD); "Windows environment", "1", NDIS_FLAG_RDONLY);
/* NDIS version should be 5.1. */ /* NDIS version should be 5.1. */
ndis_add_sysctl(sc, "NdisVersion", ndis_add_sysctl(sc, "NdisVersion",
"NDIS API Version", "0x00050001", CTLFLAG_RD); "NDIS API Version", "0x00050001", NDIS_FLAG_RDONLY);
/* /*
* Some miniport drivers rely on the existence of the SlotNumber, * Some miniport drivers rely on the existence of the SlotNumber,
* NetCfgInstanceId and DriverDesc keys. * NetCfgInstanceId and DriverDesc keys.
*/ */
ndis_add_sysctl(sc, "SlotNumber", "Slot Numer", "01", CTLFLAG_RD); ndis_add_sysctl(sc, "SlotNumber", "Slot Numer", "01", NDIS_FLAG_RDONLY);
ndis_add_sysctl(sc, "NetCfgInstanceId", "NetCfgInstanceId", ndis_add_sysctl(sc, "NetCfgInstanceId", "NetCfgInstanceId",
"{12345678-1234-5678-CAFE0-123456789ABC}", CTLFLAG_RD); "{12345678-1234-5678-CAFE0-123456789ABC}", NDIS_FLAG_RDONLY);
ndis_add_sysctl(sc, "DriverDesc", "Driver Description", ndis_add_sysctl(sc, "DriverDesc", "Driver Description",
"NDIS Network Adapter", CTLFLAG_RD); "NDIS Network Adapter", NDIS_FLAG_RDONLY);
/* Bus type (PCI, PCMCIA, etc...) */ /* Bus type (PCI, PCMCIA, etc...) */
sprintf(buf, "%d", (int)sc->ndis_iftype); sprintf(buf, "%d", (int)sc->ndis_iftype);
ndis_add_sysctl(sc, "BusType", "Bus Type", buf, CTLFLAG_RD); ndis_add_sysctl(sc, "BusType", "Bus Type", buf, NDIS_FLAG_RDONLY);
if (sc->ndis_res_io != NULL) { if (sc->ndis_res_io != NULL) {
sprintf(buf, "0x%lx", rman_get_start(sc->ndis_res_io)); sprintf(buf, "0x%lx", rman_get_start(sc->ndis_res_io));
ndis_add_sysctl(sc, "IOBaseAddress", ndis_add_sysctl(sc, "IOBaseAddress",
"Base I/O Address", buf, CTLFLAG_RD); "Base I/O Address", buf, NDIS_FLAG_RDONLY);
} }
if (sc->ndis_irq != NULL) { if (sc->ndis_irq != NULL) {
sprintf(buf, "%lu", rman_get_start(sc->ndis_irq)); sprintf(buf, "%lu", rman_get_start(sc->ndis_irq));
ndis_add_sysctl(sc, "InterruptNumber", ndis_add_sysctl(sc, "InterruptNumber",
"Interrupt Number", buf, CTLFLAG_RD); "Interrupt Number", buf, NDIS_FLAG_RDONLY);
} }
return (0); return (0);
} }
int int
ndis_add_sysctl(arg, key, desc, val, flag) ndis_add_sysctl(arg, key, desc, val, flag_rdonly)
void *arg; void *arg;
char *key; char *key;
char *desc; char *desc;
char *val; char *val;
int flag; int flag_rdonly;
{ {
struct ndis_softc *sc; struct ndis_softc *sc;
struct ndis_cfglist *cfg; struct ndis_cfglist *cfg;
@ -392,13 +393,21 @@ ndis_add_sysctl(arg, key, desc, val, flag)
TAILQ_INSERT_TAIL(&sc->ndis_cfglist_head, cfg, link); TAILQ_INSERT_TAIL(&sc->ndis_cfglist_head, cfg, link);
cfg->ndis_oid = if (flag_rdonly != 0) {
SYSCTL_ADD_STRING(device_get_sysctl_ctx(sc->ndis_dev), cfg->ndis_oid =
SYSCTL_CHILDREN(device_get_sysctl_tree(sc->ndis_dev)), SYSCTL_ADD_STRING(device_get_sysctl_ctx(sc->ndis_dev),
OID_AUTO, cfg->ndis_cfg.nc_cfgkey, flag, SYSCTL_CHILDREN(device_get_sysctl_tree(sc->ndis_dev)),
cfg->ndis_cfg.nc_val, sizeof(cfg->ndis_cfg.nc_val), OID_AUTO, cfg->ndis_cfg.nc_cfgkey, CTLFLAG_RD,
cfg->ndis_cfg.nc_cfgdesc); cfg->ndis_cfg.nc_val, sizeof(cfg->ndis_cfg.nc_val),
cfg->ndis_cfg.nc_cfgdesc);
} else {
cfg->ndis_oid =
SYSCTL_ADD_STRING(device_get_sysctl_ctx(sc->ndis_dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(sc->ndis_dev)),
OID_AUTO, cfg->ndis_cfg.nc_cfgkey, CTLFLAG_RW,
cfg->ndis_cfg.nc_val, sizeof(cfg->ndis_cfg.nc_val),
cfg->ndis_cfg.nc_cfgdesc);
}
return (0); return (0);
} }

View File

@ -465,43 +465,39 @@ static struct {
char *name; char *name;
char *description; char *description;
int method; int method;
int flags; int flag_anybody;
} acpi_asus_sysctls[] = { } acpi_asus_sysctls[] = {
{ {
.name = "lcd_backlight", .name = "lcd_backlight",
.method = ACPI_ASUS_METHOD_LCD, .method = ACPI_ASUS_METHOD_LCD,
.description = "state of the lcd backlight", .description = "state of the lcd backlight",
.flags = CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY .flag_anybody = 1
}, },
{ {
.name = "lcd_brightness", .name = "lcd_brightness",
.method = ACPI_ASUS_METHOD_BRN, .method = ACPI_ASUS_METHOD_BRN,
.description = "brightness of the lcd panel", .description = "brightness of the lcd panel",
.flags = CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY .flag_anybody = 1
}, },
{ {
.name = "video_output", .name = "video_output",
.method = ACPI_ASUS_METHOD_DISP, .method = ACPI_ASUS_METHOD_DISP,
.description = "display output state", .description = "display output state",
.flags = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "camera", .name = "camera",
.method = ACPI_ASUS_METHOD_CAMERA, .method = ACPI_ASUS_METHOD_CAMERA,
.description = "internal camera state", .description = "internal camera state",
.flags = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "cardreader", .name = "cardreader",
.method = ACPI_ASUS_METHOD_CARDRD, .method = ACPI_ASUS_METHOD_CARDRD,
.description = "internal card reader state", .description = "internal card reader state",
.flags = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wlan", .name = "wlan",
.method = ACPI_ASUS_METHOD_WLAN, .method = ACPI_ASUS_METHOD_WLAN,
.description = "wireless lan state", .description = "wireless lan state",
.flags = CTLTYPE_INT | CTLFLAG_RW
}, },
{ .name = NULL } { .name = NULL }
@ -741,12 +737,21 @@ acpi_asus_attach(device_t dev)
if (!acpi_asus_sysctl_init(sc, acpi_asus_sysctls[i].method)) if (!acpi_asus_sysctl_init(sc, acpi_asus_sysctls[i].method))
continue; continue;
SYSCTL_ADD_PROC(&sc->sysctl_ctx, if (acpi_asus_sysctls[i].flag_anybody != 0) {
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, SYSCTL_ADD_PROC(&sc->sysctl_ctx,
acpi_asus_sysctls[i].name, SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
acpi_asus_sysctls[i].flags, acpi_asus_sysctls[i].name,
sc, i, acpi_asus_sysctl, "I", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
acpi_asus_sysctls[i].description); sc, i, acpi_asus_sysctl, "I",
acpi_asus_sysctls[i].description);
} else {
SYSCTL_ADD_PROC(&sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
acpi_asus_sysctls[i].name,
CTLTYPE_INT | CTLFLAG_RW,
sc, i, acpi_asus_sysctl, "I",
acpi_asus_sysctls[i].description);
}
} }
/* Attach leds */ /* Attach leds */

View File

@ -119,163 +119,139 @@ static struct {
char *name; char *name;
int dev_id; int dev_id;
char *description; char *description;
int access; int flag_rdonly;
} acpi_asus_wmi_sysctls[] = { } acpi_asus_wmi_sysctls[] = {
{ {
.name = "hw_switch", .name = "hw_switch",
.dev_id = ASUS_WMI_DEVID_HW_SWITCH, .dev_id = ASUS_WMI_DEVID_HW_SWITCH,
.description = "hw_switch", .description = "hw_switch",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wireless_led", .name = "wireless_led",
.dev_id = ASUS_WMI_DEVID_WIRELESS_LED, .dev_id = ASUS_WMI_DEVID_WIRELESS_LED,
.description = "Wireless LED control", .description = "Wireless LED control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "cwap", .name = "cwap",
.dev_id = ASUS_WMI_DEVID_CWAP, .dev_id = ASUS_WMI_DEVID_CWAP,
.description = "Alt+F2 function", .description = "Alt+F2 function",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wlan", .name = "wlan",
.dev_id = ASUS_WMI_DEVID_WLAN, .dev_id = ASUS_WMI_DEVID_WLAN,
.description = "WLAN power control", .description = "WLAN power control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "bluetooth", .name = "bluetooth",
.dev_id = ASUS_WMI_DEVID_BLUETOOTH, .dev_id = ASUS_WMI_DEVID_BLUETOOTH,
.description = "Bluetooth power control", .description = "Bluetooth power control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "gps", .name = "gps",
.dev_id = ASUS_WMI_DEVID_GPS, .dev_id = ASUS_WMI_DEVID_GPS,
.description = "GPS power control", .description = "GPS power control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wimax", .name = "wimax",
.dev_id = ASUS_WMI_DEVID_WIMAX, .dev_id = ASUS_WMI_DEVID_WIMAX,
.description = "WiMAX power control", .description = "WiMAX power control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wwan3g", .name = "wwan3g",
.dev_id = ASUS_WMI_DEVID_WWAN3G, .dev_id = ASUS_WMI_DEVID_WWAN3G,
.description = "WWAN-3G power control", .description = "WWAN-3G power control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "uwb", .name = "uwb",
.dev_id = ASUS_WMI_DEVID_UWB, .dev_id = ASUS_WMI_DEVID_UWB,
.description = "UWB power control", .description = "UWB power control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "led1", .name = "led1",
.dev_id = ASUS_WMI_DEVID_LED1, .dev_id = ASUS_WMI_DEVID_LED1,
.description = "LED1 control", .description = "LED1 control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "led2", .name = "led2",
.dev_id = ASUS_WMI_DEVID_LED2, .dev_id = ASUS_WMI_DEVID_LED2,
.description = "LED2 control", .description = "LED2 control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "led3", .name = "led3",
.dev_id = ASUS_WMI_DEVID_LED3, .dev_id = ASUS_WMI_DEVID_LED3,
.description = "LED3 control", .description = "LED3 control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "led4", .name = "led4",
.dev_id = ASUS_WMI_DEVID_LED4, .dev_id = ASUS_WMI_DEVID_LED4,
.description = "LED4 control", .description = "LED4 control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "led5", .name = "led5",
.dev_id = ASUS_WMI_DEVID_LED5, .dev_id = ASUS_WMI_DEVID_LED5,
.description = "LED5 control", .description = "LED5 control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "led6", .name = "led6",
.dev_id = ASUS_WMI_DEVID_LED6, .dev_id = ASUS_WMI_DEVID_LED6,
.description = "LED6 control", .description = "LED6 control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "backlight", .name = "backlight",
.dev_id = ASUS_WMI_DEVID_BACKLIGHT, .dev_id = ASUS_WMI_DEVID_BACKLIGHT,
.description = "LCD backlight on/off control", .description = "LCD backlight on/off control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "brightness", .name = "brightness",
.dev_id = ASUS_WMI_DEVID_BRIGHTNESS, .dev_id = ASUS_WMI_DEVID_BRIGHTNESS,
.description = "LCD backlight brightness control", .description = "LCD backlight brightness control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "kbd_backlight", .name = "kbd_backlight",
.dev_id = ASUS_WMI_DEVID_KBD_BACKLIGHT, .dev_id = ASUS_WMI_DEVID_KBD_BACKLIGHT,
.description = "Keyboard backlight brightness control", .description = "Keyboard backlight brightness control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "light_sensor", .name = "light_sensor",
.dev_id = ASUS_WMI_DEVID_LIGHT_SENSOR, .dev_id = ASUS_WMI_DEVID_LIGHT_SENSOR,
.description = "Ambient light sensor", .description = "Ambient light sensor",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "camera", .name = "camera",
.dev_id = ASUS_WMI_DEVID_CAMERA, .dev_id = ASUS_WMI_DEVID_CAMERA,
.description = "Camera power control", .description = "Camera power control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "cardreader", .name = "cardreader",
.dev_id = ASUS_WMI_DEVID_CARDREADER, .dev_id = ASUS_WMI_DEVID_CARDREADER,
.description = "Cardreader power control", .description = "Cardreader power control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "touchpad", .name = "touchpad",
.dev_id = ASUS_WMI_DEVID_TOUCHPAD, .dev_id = ASUS_WMI_DEVID_TOUCHPAD,
.description = "Touchpad control", .description = "Touchpad control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "touchpad_led", .name = "touchpad_led",
.dev_id = ASUS_WMI_DEVID_TOUCHPAD_LED, .dev_id = ASUS_WMI_DEVID_TOUCHPAD_LED,
.description = "Touchpad LED control", .description = "Touchpad LED control",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "themperature", .name = "themperature",
.dev_id = ASUS_WMI_DEVID_THERMAL_CTRL, .dev_id = ASUS_WMI_DEVID_THERMAL_CTRL,
.description = "Temperature (C)", .description = "Temperature (C)",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "fan_speed", .name = "fan_speed",
.dev_id = ASUS_WMI_DEVID_FAN_CTRL, .dev_id = ASUS_WMI_DEVID_FAN_CTRL,
.description = "Fan speed (0-3)", .description = "Fan speed (0-3)",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "processor_state", .name = "processor_state",
.dev_id = ASUS_WMI_DEVID_PROCESSOR_STATE, .dev_id = ASUS_WMI_DEVID_PROCESSOR_STATE,
.description = "Processor state", .flag_rdonly = 1
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ NULL, 0, NULL, 0 } { NULL, 0, NULL, 0 }
}; };
@ -449,12 +425,21 @@ next:
break; break;
} }
SYSCTL_ADD_PROC(sc->sysctl_ctx, if (acpi_asus_wmi_sysctls[i].flag_rdonly != 0) {
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, SYSCTL_ADD_PROC(sc->sysctl_ctx,
acpi_asus_wmi_sysctls[i].name, SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
acpi_asus_wmi_sysctls[i].access, acpi_asus_wmi_sysctls[i].name,
sc, i, acpi_asus_wmi_sysctl, "I", CTLTYPE_INT | CTLFLAG_RD,
acpi_asus_wmi_sysctls[i].description); sc, i, acpi_asus_wmi_sysctl, "I",
acpi_asus_wmi_sysctls[i].description);
} else {
SYSCTL_ADD_PROC(sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
acpi_asus_wmi_sysctls[i].name,
CTLTYPE_INT | CTLFLAG_RW,
sc, i, acpi_asus_wmi_sysctl, "I",
acpi_asus_wmi_sysctls[i].description);
}
} }
ACPI_SERIAL_END(asus_wmi); ACPI_SERIAL_END(asus_wmi);

View File

@ -152,135 +152,123 @@ static struct {
char *name; char *name;
int method; int method;
char *description; char *description;
int access; int flag_rdonly;
} acpi_hp_sysctls[] = { } acpi_hp_sysctls[] = {
{ {
.name = "wlan_enabled", .name = "wlan_enabled",
.method = ACPI_HP_METHOD_WLAN_ENABLED, .method = ACPI_HP_METHOD_WLAN_ENABLED,
.description = "Enable/Disable WLAN (WiFi)", .description = "Enable/Disable WLAN (WiFi)",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wlan_radio", .name = "wlan_radio",
.method = ACPI_HP_METHOD_WLAN_RADIO, .method = ACPI_HP_METHOD_WLAN_RADIO,
.description = "WLAN radio status", .description = "WLAN radio status",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "wlan_on_air", .name = "wlan_on_air",
.method = ACPI_HP_METHOD_WLAN_ON_AIR, .method = ACPI_HP_METHOD_WLAN_ON_AIR,
.description = "WLAN radio ready to use (enabled and radio)", .description = "WLAN radio ready to use (enabled and radio)",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "wlan_enable_if_radio_on", .name = "wlan_enable_if_radio_on",
.method = ACPI_HP_METHOD_WLAN_ENABLE_IF_RADIO_ON, .method = ACPI_HP_METHOD_WLAN_ENABLE_IF_RADIO_ON,
.description = "Enable WLAN if radio is turned on", .description = "Enable WLAN if radio is turned on",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wlan_disable_if_radio_off", .name = "wlan_disable_if_radio_off",
.method = ACPI_HP_METHOD_WLAN_DISABLE_IF_RADIO_OFF, .method = ACPI_HP_METHOD_WLAN_DISABLE_IF_RADIO_OFF,
.description = "Disable WLAN if radio is turned off", .description = "Disable WLAN if radio is turned off",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "bt_enabled", .name = "bt_enabled",
.method = ACPI_HP_METHOD_BLUETOOTH_ENABLED, .method = ACPI_HP_METHOD_BLUETOOTH_ENABLED,
.description = "Enable/Disable Bluetooth", .description = "Enable/Disable Bluetooth",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "bt_radio", .name = "bt_radio",
.method = ACPI_HP_METHOD_BLUETOOTH_RADIO, .method = ACPI_HP_METHOD_BLUETOOTH_RADIO,
.description = "Bluetooth radio status", .description = "Bluetooth radio status",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "bt_on_air", .name = "bt_on_air",
.method = ACPI_HP_METHOD_BLUETOOTH_ON_AIR, .method = ACPI_HP_METHOD_BLUETOOTH_ON_AIR,
.description = "Bluetooth radio ready to use" .description = "Bluetooth radio ready to use"
" (enabled and radio)", " (enabled and radio)",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "bt_enable_if_radio_on", .name = "bt_enable_if_radio_on",
.method = ACPI_HP_METHOD_BLUETOOTH_ENABLE_IF_RADIO_ON, .method = ACPI_HP_METHOD_BLUETOOTH_ENABLE_IF_RADIO_ON,
.description = "Enable bluetooth if radio is turned on", .description = "Enable bluetooth if radio is turned on",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "bt_disable_if_radio_off", .name = "bt_disable_if_radio_off",
.method = ACPI_HP_METHOD_BLUETOOTH_DISABLE_IF_RADIO_OFF, .method = ACPI_HP_METHOD_BLUETOOTH_DISABLE_IF_RADIO_OFF,
.description = "Disable bluetooth if radio is turned off", .description = "Disable bluetooth if radio is turned off",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wwan_enabled", .name = "wwan_enabled",
.method = ACPI_HP_METHOD_WWAN_ENABLED, .method = ACPI_HP_METHOD_WWAN_ENABLED,
.description = "Enable/Disable WWAN (UMTS)", .description = "Enable/Disable WWAN (UMTS)",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wwan_radio", .name = "wwan_radio",
.method = ACPI_HP_METHOD_WWAN_RADIO, .method = ACPI_HP_METHOD_WWAN_RADIO,
.description = "WWAN radio status", .description = "WWAN radio status",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "wwan_on_air", .name = "wwan_on_air",
.method = ACPI_HP_METHOD_WWAN_ON_AIR, .method = ACPI_HP_METHOD_WWAN_ON_AIR,
.description = "WWAN radio ready to use (enabled and radio)", .description = "WWAN radio ready to use (enabled and radio)",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "wwan_enable_if_radio_on", .name = "wwan_enable_if_radio_on",
.method = ACPI_HP_METHOD_WWAN_ENABLE_IF_RADIO_ON, .method = ACPI_HP_METHOD_WWAN_ENABLE_IF_RADIO_ON,
.description = "Enable WWAN if radio is turned on", .description = "Enable WWAN if radio is turned on",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wwan_disable_if_radio_off", .name = "wwan_disable_if_radio_off",
.method = ACPI_HP_METHOD_WWAN_DISABLE_IF_RADIO_OFF, .method = ACPI_HP_METHOD_WWAN_DISABLE_IF_RADIO_OFF,
.description = "Disable WWAN if radio is turned off", .description = "Disable WWAN if radio is turned off",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "als_enabled", .name = "als_enabled",
.method = ACPI_HP_METHOD_ALS, .method = ACPI_HP_METHOD_ALS,
.description = "Enable/Disable ALS (Ambient light sensor)", .description = "Enable/Disable ALS (Ambient light sensor)",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "display", .name = "display",
.method = ACPI_HP_METHOD_DISPLAY, .method = ACPI_HP_METHOD_DISPLAY,
.description = "Display status", .description = "Display status",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "hdd_temperature", .name = "hdd_temperature",
.method = ACPI_HP_METHOD_HDDTEMP, .method = ACPI_HP_METHOD_HDDTEMP,
.description = "HDD temperature", .description = "HDD temperature",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "is_docked", .name = "is_docked",
.method = ACPI_HP_METHOD_DOCK, .method = ACPI_HP_METHOD_DOCK,
.description = "Docking station status", .description = "Docking station status",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "cmi_detail", .name = "cmi_detail",
.method = ACPI_HP_METHOD_CMI_DETAIL, .method = ACPI_HP_METHOD_CMI_DETAIL,
.description = "Details shown in CMI output " .description = "Details shown in CMI output "
"(cat /dev/hpcmi)", "(cat /dev/hpcmi)",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "verbose", .name = "verbose",
.method = ACPI_HP_METHOD_VERBOSE, .method = ACPI_HP_METHOD_VERBOSE,
.description = "Verbosity level", .description = "Verbosity level",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ NULL, 0, NULL, 0 } { NULL, 0, NULL, 0 }
@ -560,11 +548,19 @@ acpi_hp_attach(device_t dev)
sc->was_wwan_on_air = arg; sc->was_wwan_on_air = arg;
} }
SYSCTL_ADD_PROC(sc->sysctl_ctx, if (acpi_hp_sysctls[i].flag_rdonly != 0) {
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, SYSCTL_ADD_PROC(sc->sysctl_ctx,
acpi_hp_sysctls[i].name, acpi_hp_sysctls[i].access, SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
sc, i, acpi_hp_sysctl, "I", acpi_hp_sysctls[i].name, CTLTYPE_INT | CTLFLAG_RD,
acpi_hp_sysctls[i].description); sc, i, acpi_hp_sysctl, "I",
acpi_hp_sysctls[i].description);
} else {
SYSCTL_ADD_PROC(sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
acpi_hp_sysctls[i].name, CTLTYPE_INT | CTLFLAG_RW,
sc, i, acpi_hp_sysctl, "I",
acpi_hp_sysctls[i].description);
}
} }
ACPI_SERIAL_END(hp); ACPI_SERIAL_END(hp);

View File

@ -192,79 +192,70 @@ static struct {
char *name; char *name;
int method; int method;
char *description; char *description;
int access; int flag_rdonly;
} acpi_ibm_sysctls[] = { } acpi_ibm_sysctls[] = {
{ {
.name = "events", .name = "events",
.method = ACPI_IBM_METHOD_EVENTS, .method = ACPI_IBM_METHOD_EVENTS,
.description = "ACPI events enable", .description = "ACPI events enable",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "eventmask", .name = "eventmask",
.method = ACPI_IBM_METHOD_EVENTMASK, .method = ACPI_IBM_METHOD_EVENTMASK,
.description = "ACPI eventmask", .description = "ACPI eventmask",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "hotkey", .name = "hotkey",
.method = ACPI_IBM_METHOD_HOTKEY, .method = ACPI_IBM_METHOD_HOTKEY,
.description = "Key Status", .description = "Key Status",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "lcd_brightness", .name = "lcd_brightness",
.method = ACPI_IBM_METHOD_BRIGHTNESS, .method = ACPI_IBM_METHOD_BRIGHTNESS,
.description = "LCD Brightness", .description = "LCD Brightness",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "volume", .name = "volume",
.method = ACPI_IBM_METHOD_VOLUME, .method = ACPI_IBM_METHOD_VOLUME,
.description = "Volume", .description = "Volume",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "mute", .name = "mute",
.method = ACPI_IBM_METHOD_MUTE, .method = ACPI_IBM_METHOD_MUTE,
.description = "Mute", .description = "Mute",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "thinklight", .name = "thinklight",
.method = ACPI_IBM_METHOD_THINKLIGHT, .method = ACPI_IBM_METHOD_THINKLIGHT,
.description = "Thinklight enable", .description = "Thinklight enable",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "bluetooth", .name = "bluetooth",
.method = ACPI_IBM_METHOD_BLUETOOTH, .method = ACPI_IBM_METHOD_BLUETOOTH,
.description = "Bluetooth enable", .description = "Bluetooth enable",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "wlan", .name = "wlan",
.method = ACPI_IBM_METHOD_WLAN, .method = ACPI_IBM_METHOD_WLAN,
.description = "WLAN enable", .description = "WLAN enable",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "fan_speed", .name = "fan_speed",
.method = ACPI_IBM_METHOD_FANSPEED, .method = ACPI_IBM_METHOD_FANSPEED,
.description = "Fan speed", .description = "Fan speed",
.access = CTLTYPE_INT | CTLFLAG_RD .flag_rdonly = 1
}, },
{ {
.name = "fan_level", .name = "fan_level",
.method = ACPI_IBM_METHOD_FANLEVEL, .method = ACPI_IBM_METHOD_FANLEVEL,
.description = "Fan level", .description = "Fan level",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ {
.name = "fan", .name = "fan",
.method = ACPI_IBM_METHOD_FANSTATUS, .method = ACPI_IBM_METHOD_FANSTATUS,
.description = "Fan enable", .description = "Fan enable",
.access = CTLTYPE_INT | CTLFLAG_RW
}, },
{ NULL, 0, NULL, 0 } { NULL, 0, NULL, 0 }
@ -415,11 +406,19 @@ acpi_ibm_attach(device_t dev)
if (!acpi_ibm_sysctl_init(sc, acpi_ibm_sysctls[i].method)) if (!acpi_ibm_sysctl_init(sc, acpi_ibm_sysctls[i].method))
continue; continue;
SYSCTL_ADD_PROC(sc->sysctl_ctx, if (acpi_ibm_sysctls[i].flag_rdonly != 0) {
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, SYSCTL_ADD_PROC(sc->sysctl_ctx,
acpi_ibm_sysctls[i].name, acpi_ibm_sysctls[i].access, SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
sc, i, acpi_ibm_sysctl, "I", acpi_ibm_sysctls[i].name, CTLTYPE_INT | CTLFLAG_RD,
acpi_ibm_sysctls[i].description); sc, i, acpi_ibm_sysctl, "I",
acpi_ibm_sysctls[i].description);
} else {
SYSCTL_ADD_PROC(sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
acpi_ibm_sysctls[i].name, CTLTYPE_INT | CTLFLAG_RW,
sc, i, acpi_ibm_sysctl, "I",
acpi_ibm_sysctls[i].description);
}
} }
/* Hook up thermal node */ /* Hook up thermal node */
@ -483,15 +482,10 @@ acpi_ibm_resume(device_t dev)
for (int i = 0; acpi_ibm_sysctls[i].name != NULL; i++) { for (int i = 0; acpi_ibm_sysctls[i].name != NULL; i++) {
int val; int val;
if ((acpi_ibm_sysctls[i].access & CTLFLAG_RD) == 0) {
continue;
}
val = acpi_ibm_sysctl_get(sc, i); val = acpi_ibm_sysctl_get(sc, i);
if ((acpi_ibm_sysctls[i].access & CTLFLAG_WR) == 0) { if (acpi_ibm_sysctls[i].flag_rdonly != 0)
continue; continue;
}
acpi_ibm_sysctl_set(sc, i, val); acpi_ibm_sysctl_set(sc, i, val);
} }

View File

@ -84,12 +84,21 @@ acpi_rapidstart_attach(device_t dev)
sc->sysctl_ctx = device_get_sysctl_ctx(dev); sc->sysctl_ctx = device_get_sysctl_ctx(dev);
sc->sysctl_tree = device_get_sysctl_tree(dev); sc->sysctl_tree = device_get_sysctl_tree(dev);
for (i = 0 ; acpi_rapidstart_oids[i].nodename != NULL; i++){ for (i = 0 ; acpi_rapidstart_oids[i].nodename != NULL; i++){
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), if (acpi_rapidstart_oids[i].setmethod != NULL) {
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
i, acpi_rapidstart_oids[i].nodename , CTLTYPE_INT | SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
((acpi_rapidstart_oids[i].setmethod)? CTLFLAG_RW: CTLFLAG_RD), i, acpi_rapidstart_oids[i].nodename,
dev, i, sysctl_acpi_rapidstart_gen_handler, "I", CTLTYPE_INT | CTLFLAG_RW,
acpi_rapidstart_oids[i].comment); dev, i, sysctl_acpi_rapidstart_gen_handler, "I",
acpi_rapidstart_oids[i].comment);
} else {
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
i, acpi_rapidstart_oids[i].nodename,
CTLTYPE_INT | CTLFLAG_RD,
dev, i, sysctl_acpi_rapidstart_gen_handler, "I",
acpi_rapidstart_oids[i].comment);
}
} }
return (0); return (0);
} }

View File

@ -132,13 +132,22 @@ acpi_sony_attach(device_t dev)
sc = device_get_softc(dev); sc = device_get_softc(dev);
acpi_GetInteger(acpi_get_handle(dev), ACPI_SONY_GET_PID, &sc->pid); acpi_GetInteger(acpi_get_handle(dev), ACPI_SONY_GET_PID, &sc->pid);
device_printf(dev, "PID %x\n", sc->pid); device_printf(dev, "PID %x\n", sc->pid);
for (i = 0 ; acpi_sony_oids[i].nodename != NULL; i++){ for (i = 0 ; acpi_sony_oids[i].nodename != NULL; i++) {
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), if (acpi_sony_oids[i].setmethod != NULL) {
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
i, acpi_sony_oids[i].nodename , CTLTYPE_INT | SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
((acpi_sony_oids[i].setmethod)? CTLFLAG_RW: CTLFLAG_RD), i, acpi_sony_oids[i].nodename ,
dev, i, sysctl_acpi_sony_gen_handler, "I", CTLTYPE_INT | CTLFLAG_RW,
acpi_sony_oids[i].comment); dev, i, sysctl_acpi_sony_gen_handler, "I",
acpi_sony_oids[i].comment);
} else {
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
i, acpi_sony_oids[i].nodename ,
CTLTYPE_INT | CTLFLAG_RD,
dev, i, sysctl_acpi_sony_gen_handler, "I",
acpi_sony_oids[i].comment);
}
} }
return (0); return (0);
} }

View File

@ -16216,7 +16216,7 @@ bxe_add_sysctls(struct bxe_softc *sc)
"version"); "version");
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "bc_version", SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "bc_version",
CTLFLAG_RD, &sc->devinfo.bc_ver_str, 0, CTLFLAG_RD, sc->devinfo.bc_ver_str, 0,
"bootcode version"); "bootcode version");
snprintf(sc->fw_ver_str, sizeof(sc->fw_ver_str), "%d.%d.%d.%d", snprintf(sc->fw_ver_str, sizeof(sc->fw_ver_str), "%d.%d.%d.%d",
@ -16225,7 +16225,7 @@ bxe_add_sysctls(struct bxe_softc *sc)
BCM_5710_FW_REVISION_VERSION, BCM_5710_FW_REVISION_VERSION,
BCM_5710_FW_ENGINEERING_VERSION); BCM_5710_FW_ENGINEERING_VERSION);
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "fw_version", SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "fw_version",
CTLFLAG_RD, &sc->fw_ver_str, 0, CTLFLAG_RD, sc->fw_ver_str, 0,
"firmware version"); "firmware version");
snprintf(sc->mf_mode_str, sizeof(sc->mf_mode_str), "%s", snprintf(sc->mf_mode_str, sizeof(sc->mf_mode_str), "%s",
@ -16235,7 +16235,7 @@ bxe_add_sysctls(struct bxe_softc *sc)
(sc->devinfo.mf_info.mf_mode == MULTI_FUNCTION_AFEX) ? "MF-AFEX" : (sc->devinfo.mf_info.mf_mode == MULTI_FUNCTION_AFEX) ? "MF-AFEX" :
"Unknown")); "Unknown"));
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "mf_mode", SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "mf_mode",
CTLFLAG_RD, &sc->mf_mode_str, 0, CTLFLAG_RD, sc->mf_mode_str, 0,
"multifunction mode"); "multifunction mode");
SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "mf_vnics", SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "mf_vnics",
@ -16243,7 +16243,7 @@ bxe_add_sysctls(struct bxe_softc *sc)
"multifunction vnics per port"); "multifunction vnics per port");
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "mac_addr", SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "mac_addr",
CTLFLAG_RD, &sc->mac_addr_str, 0, CTLFLAG_RD, sc->mac_addr_str, 0,
"mac address"); "mac address");
snprintf(sc->pci_link_str, sizeof(sc->pci_link_str), "%s x%d", snprintf(sc->pci_link_str, sizeof(sc->pci_link_str), "%s x%d",
@ -16253,12 +16253,12 @@ bxe_add_sysctls(struct bxe_softc *sc)
"???GT/s"), "???GT/s"),
sc->devinfo.pcie_link_width); sc->devinfo.pcie_link_width);
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "pci_link", SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "pci_link",
CTLFLAG_RD, &sc->pci_link_str, 0, CTLFLAG_RD, sc->pci_link_str, 0,
"pci link status"); "pci link status");
sc->debug = bxe_debug; sc->debug = bxe_debug;
SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "debug", SYSCTL_ADD_ULONG(ctx, children, OID_AUTO, "debug",
CTLFLAG_RW, &sc->debug, 0, CTLFLAG_RW, &sc->debug,
"debug logging mode"); "debug logging mode");
sc->rx_budget = bxe_rx_budget; sc->rx_budget = bxe_rx_budget;

View File

@ -3365,7 +3365,7 @@ t3_add_attach_sysctls(adapter_t *sc)
/* random information */ /* random information */
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
"firmware_version", "firmware_version",
CTLFLAG_RD, &sc->fw_version, CTLFLAG_RD, sc->fw_version,
0, "firmware version"); 0, "firmware version");
SYSCTL_ADD_UINT(ctx, children, OID_AUTO, SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
"hw_revision", "hw_revision",
@ -3373,7 +3373,7 @@ t3_add_attach_sysctls(adapter_t *sc)
0, "chip model"); 0, "chip model");
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
"port_types", "port_types",
CTLFLAG_RD, &sc->port_types, CTLFLAG_RD, sc->port_types,
0, "type of ports"); 0, "type of ports");
SYSCTL_ADD_INT(ctx, children, OID_AUTO, SYSCTL_ADD_INT(ctx, children, OID_AUTO,
"enable_debug", "enable_debug",
@ -3502,7 +3502,7 @@ t3_add_configured_sysctls(adapter_t *sc)
SYSCTL_ADD_UINT(ctx, rspqpoidlist, OID_AUTO, "starved", SYSCTL_ADD_UINT(ctx, rspqpoidlist, OID_AUTO, "starved",
CTLFLAG_RD, &qs->rspq.starved, CTLFLAG_RD, &qs->rspq.starved,
0, "#times starved"); 0, "#times starved");
SYSCTL_ADD_ULONG(ctx, rspqpoidlist, OID_AUTO, "phys_addr", SYSCTL_ADD_UAUTO(ctx, rspqpoidlist, OID_AUTO, "phys_addr",
CTLFLAG_RD, &qs->rspq.phys_addr, CTLFLAG_RD, &qs->rspq.phys_addr,
"physical_address_of the queue"); "physical_address_of the queue");
SYSCTL_ADD_UINT(ctx, rspqpoidlist, OID_AUTO, "dump_start", SYSCTL_ADD_UINT(ctx, rspqpoidlist, OID_AUTO, "dump_start",
@ -3538,7 +3538,7 @@ t3_add_configured_sysctls(adapter_t *sc)
SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "in_use", SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "in_use",
CTLFLAG_RD, &txq->in_use, CTLFLAG_RD, &txq->in_use,
0, "#tunneled packet slots in use"); 0, "#tunneled packet slots in use");
SYSCTL_ADD_ULONG(ctx, txqpoidlist, OID_AUTO, "frees", SYSCTL_ADD_UQUAD(ctx, txqpoidlist, OID_AUTO, "frees",
CTLFLAG_RD, &txq->txq_frees, CTLFLAG_RD, &txq->txq_frees,
"#tunneled packets freed"); "#tunneled packets freed");
SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "skipped", SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "skipped",
@ -3553,7 +3553,7 @@ t3_add_configured_sysctls(adapter_t *sc)
SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "stopped_flags", SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "stopped_flags",
CTLFLAG_RD, &qs->txq_stopped, CTLFLAG_RD, &qs->txq_stopped,
0, "tx queues stopped"); 0, "tx queues stopped");
SYSCTL_ADD_ULONG(ctx, txqpoidlist, OID_AUTO, "phys_addr", SYSCTL_ADD_UAUTO(ctx, txqpoidlist, OID_AUTO, "phys_addr",
CTLFLAG_RD, &txq->phys_addr, CTLFLAG_RD, &txq->phys_addr,
"physical_address_of the queue"); "physical_address_of the queue");
SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "qgen", SYSCTL_ADD_UINT(ctx, txqpoidlist, OID_AUTO, "qgen",

View File

@ -4534,10 +4534,10 @@ t4_sysctls(struct adapter *sc)
NULL, chip_rev(sc), "chip hardware revision"); NULL, chip_rev(sc), "chip hardware revision");
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "firmware_version", SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "firmware_version",
CTLFLAG_RD, &sc->fw_version, 0, "firmware version"); CTLFLAG_RD, sc->fw_version, 0, "firmware version");
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "cf", SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "cf",
CTLFLAG_RD, &sc->cfg_file, 0, "configuration file"); CTLFLAG_RD, sc->cfg_file, 0, "configuration file");
SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "cfcsum", CTLFLAG_RD, NULL, SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "cfcsum", CTLFLAG_RD, NULL,
sc->cfcsum, "config file checksum"); sc->cfcsum, "config file checksum");

View File

@ -5644,7 +5644,7 @@ em_set_sysctl_value(struct adapter *adapter, const char *name,
*limit = value; *limit = value;
SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description); OID_AUTO, name, CTLFLAG_RW, limit, value, description);
} }

View File

@ -5823,8 +5823,8 @@ igb_add_hw_stats(struct adapter *adapter)
char namebuf[QUEUE_NAME_LEN]; char namebuf[QUEUE_NAME_LEN];
/* Driver Statistics */ /* Driver Statistics */
SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "link_irq", SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "link_irq",
CTLFLAG_RD, &adapter->link_irq, 0, CTLFLAG_RD, &adapter->link_irq,
"Link MSIX IRQ Handled"); "Link MSIX IRQ Handled");
SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "dropped", SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "dropped",
CTLFLAG_RD, &adapter->dropped_pkts, CTLFLAG_RD, &adapter->dropped_pkts,
@ -5873,17 +5873,17 @@ igb_add_hw_stats(struct adapter *adapter)
queue_list = SYSCTL_CHILDREN(queue_node); queue_list = SYSCTL_CHILDREN(queue_node);
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "interrupt_rate", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "interrupt_rate",
CTLFLAG_RD, &adapter->queues[i], CTLTYPE_UINT | CTLFLAG_RD, &adapter->queues[i],
sizeof(&adapter->queues[i]), sizeof(&adapter->queues[i]),
igb_sysctl_interrupt_rate_handler, igb_sysctl_interrupt_rate_handler,
"IU", "Interrupt Rate"); "IU", "Interrupt Rate");
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_head", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_head",
CTLFLAG_RD, adapter, E1000_TDH(txr->me), CTLTYPE_UINT | CTLFLAG_RD, adapter, E1000_TDH(txr->me),
igb_sysctl_reg_handler, "IU", igb_sysctl_reg_handler, "IU",
"Transmit Descriptor Head"); "Transmit Descriptor Head");
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_tail", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_tail",
CTLFLAG_RD, adapter, E1000_TDT(txr->me), CTLTYPE_UINT | CTLFLAG_RD, adapter, E1000_TDT(txr->me),
igb_sysctl_reg_handler, "IU", igb_sysctl_reg_handler, "IU",
"Transmit Descriptor Tail"); "Transmit Descriptor Tail");
SYSCTL_ADD_QUAD(ctx, queue_list, OID_AUTO, "no_desc_avail", SYSCTL_ADD_QUAD(ctx, queue_list, OID_AUTO, "no_desc_avail",
@ -5894,11 +5894,11 @@ igb_add_hw_stats(struct adapter *adapter)
"Queue Packets Transmitted"); "Queue Packets Transmitted");
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_head", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_head",
CTLFLAG_RD, adapter, E1000_RDH(rxr->me), CTLTYPE_UINT | CTLFLAG_RD, adapter, E1000_RDH(rxr->me),
igb_sysctl_reg_handler, "IU", igb_sysctl_reg_handler, "IU",
"Receive Descriptor Head"); "Receive Descriptor Head");
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_tail", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_tail",
CTLFLAG_RD, adapter, E1000_RDT(rxr->me), CTLTYPE_UINT | CTLFLAG_RD, adapter, E1000_RDT(rxr->me),
igb_sysctl_reg_handler, "IU", igb_sysctl_reg_handler, "IU",
"Receive Descriptor Tail"); "Receive Descriptor Tail");
SYSCTL_ADD_QUAD(ctx, queue_list, OID_AUTO, "rx_packets", SYSCTL_ADD_QUAD(ctx, queue_list, OID_AUTO, "rx_packets",
@ -6272,7 +6272,7 @@ igb_set_sysctl_value(struct adapter *adapter, const char *name,
*limit = value; *limit = value;
SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description); OID_AUTO, name, CTLFLAG_RW, limit, value, description);
} }
/* /*

View File

@ -4861,7 +4861,7 @@ lem_set_flow_cntrl(struct adapter *adapter, const char *name,
*limit = value; *limit = value;
SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description); OID_AUTO, name, CTLFLAG_RW, limit, value, description);
} }
static void static void
@ -4871,5 +4871,5 @@ lem_add_rx_process_limit(struct adapter *adapter, const char *name,
*limit = value; *limit = value;
SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description); OID_AUTO, name, CTLFLAG_RW, limit, value, description);
} }

View File

@ -1312,9 +1312,17 @@ kenv_getuint(struct hatm_softc *sc, const char *var,
*ptr = def; *ptr = def;
if (SYSCTL_ADD_UINT(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree), if (rw != 0) {
OID_AUTO, var, rw ? CTLFLAG_RW : CTLFLAG_RD, ptr, 0, "") == NULL) if (SYSCTL_ADD_UINT(&sc->sysctl_ctx,
return (ENOMEM); SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, var,
CTLFLAG_RW, ptr, 0, "") == NULL)
return (ENOMEM);
} else {
if (SYSCTL_ADD_UINT(&sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, var,
CTLFLAG_RD, ptr, 0, "") == NULL)
return (ENOMEM);
}
snprintf(full, sizeof(full), "hw.%s.%s", snprintf(full, sizeof(full), "hw.%s.%s",
device_get_nameunit(sc->dev), var); device_get_nameunit(sc->dev), var);

View File

@ -460,7 +460,7 @@ ixgbe_attach(device_t dev)
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "enable_aim", CTLTYPE_INT|CTLFLAG_RW, OID_AUTO, "enable_aim", CTLFLAG_RW,
&ixgbe_enable_aim, 1, "Interrupt Moderation"); &ixgbe_enable_aim, 1, "Interrupt Moderation");
/* /*

View File

@ -322,7 +322,7 @@ ixv_attach(device_t dev)
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "enable_aim", CTLTYPE_INT|CTLFLAG_RW, OID_AUTO, "enable_aim", CTLFLAG_RW,
&ixv_enable_aim, 1, "Interrupt Moderation"); &ixv_enable_aim, 1, "Interrupt Moderation");
/* Set up the timer callout */ /* Set up the timer callout */
@ -4001,6 +4001,6 @@ ixv_add_rx_process_limit(struct adapter *adapter, const char *name,
*limit = value; *limit = value;
SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description); OID_AUTO, name, CTLFLAG_RW, limit, value, description);
} }

View File

@ -400,22 +400,22 @@ ixl_attach(device_t dev)
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "rx_itr", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "rx_itr", CTLFLAG_RW,
&ixl_rx_itr, IXL_ITR_8K, "RX ITR"); &ixl_rx_itr, IXL_ITR_8K, "RX ITR");
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "dynamic_rx_itr", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "dynamic_rx_itr", CTLFLAG_RW,
&ixl_dynamic_rx_itr, 0, "Dynamic RX ITR"); &ixl_dynamic_rx_itr, 0, "Dynamic RX ITR");
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "tx_itr", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "tx_itr", CTLFLAG_RW,
&ixl_tx_itr, IXL_ITR_4K, "TX ITR"); &ixl_tx_itr, IXL_ITR_4K, "TX ITR");
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "dynamic_tx_itr", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "dynamic_tx_itr", CTLFLAG_RW,
&ixl_dynamic_tx_itr, 0, "Dynamic TX ITR"); &ixl_dynamic_tx_itr, 0, "Dynamic TX ITR");
#ifdef IXL_DEBUG #ifdef IXL_DEBUG

View File

@ -1447,7 +1447,7 @@ mpr_setup_sysctl(struct mpr_softc *sc)
"Disable the use of MSI interrupts"); "Disable the use of MSI interrupts");
SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
OID_AUTO, "firmware_version", CTLFLAG_RW, &sc->fw_version, OID_AUTO, "firmware_version", CTLFLAG_RW, sc->fw_version,
strlen(sc->fw_version), "firmware version"); strlen(sc->fw_version), "firmware version");
SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),

View File

@ -1424,7 +1424,7 @@ mps_setup_sysctl(struct mps_softc *sc)
"Disable the use of MSI interrupts"); "Disable the use of MSI interrupts");
SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
OID_AUTO, "firmware_version", CTLFLAG_RW, &sc->fw_version, OID_AUTO, "firmware_version", CTLFLAG_RW, sc->fw_version,
strlen(sc->fw_version), "firmware version"); strlen(sc->fw_version), "firmware version");
SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),

View File

@ -412,7 +412,7 @@ mrsas_setup_sysctl(struct mrsas_softc *sc)
SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
OID_AUTO, "fw_outstanding", CTLFLAG_RD, OID_AUTO, "fw_outstanding", CTLFLAG_RD,
&sc->fw_outstanding, 0, "FW outstanding commands"); &sc->fw_outstanding.val_rdonly, 0, "FW outstanding commands");
SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
OID_AUTO, "io_cmds_highwater", CTLFLAG_RD, OID_AUTO, "io_cmds_highwater", CTLFLAG_RD,

View File

@ -511,8 +511,9 @@ typedef union _MPI2_REPLY_DESCRIPTORS_UNION {
} MPI2_REPLY_DESCRIPTORS_UNION, MPI2_POINTER PTR_MPI2_REPLY_DESCRIPTORS_UNION, } MPI2_REPLY_DESCRIPTORS_UNION, MPI2_POINTER PTR_MPI2_REPLY_DESCRIPTORS_UNION,
Mpi2ReplyDescriptorsUnion_t, MPI2_POINTER pMpi2ReplyDescriptorsUnion_t; Mpi2ReplyDescriptorsUnion_t, MPI2_POINTER pMpi2ReplyDescriptorsUnion_t;
typedef struct { typedef union {
volatile unsigned int val; volatile unsigned int val;
unsigned int val_rdonly;
} mrsas_atomic_t; } mrsas_atomic_t;
#define mrsas_atomic_read(v) atomic_load_acq_int(&(v)->val) #define mrsas_atomic_read(v) atomic_load_acq_int(&(v)->val)
@ -2523,7 +2524,7 @@ struct mrsas_softc {
void *ctlr_info_mem; void *ctlr_info_mem;
bus_addr_t ctlr_info_phys_addr; bus_addr_t ctlr_info_phys_addr;
u_int32_t max_sectors_per_req; u_int32_t max_sectors_per_req;
u_int8_t disableOnlineCtrlReset; u_int32_t disableOnlineCtrlReset;
mrsas_atomic_t fw_outstanding; mrsas_atomic_t fw_outstanding;
u_int32_t mrsas_debug; u_int32_t mrsas_debug;
u_int32_t mrsas_io_timeout; u_int32_t mrsas_io_timeout;

View File

@ -1468,15 +1468,15 @@ mxge_add_sysctls(mxge_softc_t *sc)
/* random information */ /* random information */
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
"firmware_version", "firmware_version",
CTLFLAG_RD, &sc->fw_version, CTLFLAG_RD, sc->fw_version,
0, "firmware version"); 0, "firmware version");
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
"serial_number", "serial_number",
CTLFLAG_RD, &sc->serial_number_string, CTLFLAG_RD, sc->serial_number_string,
0, "serial number"); 0, "serial number");
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
"product_code", "product_code",
CTLFLAG_RD, &sc->product_code_string, CTLFLAG_RD, sc->product_code_string,
0, "product_code"); 0, "product_code");
SYSCTL_ADD_INT(ctx, children, OID_AUTO, SYSCTL_ADD_INT(ctx, children, OID_AUTO,
"pcie_link_width", "pcie_link_width",

View File

@ -84,21 +84,21 @@ oce_add_sysctls(POCE_SOFTC sc)
SYSCTL_ADD_STRING(ctx, child, SYSCTL_ADD_STRING(ctx, child,
OID_AUTO, "component_revision", OID_AUTO, "component_revision",
CTLTYPE_INT | CTLFLAG_RD, CTLFLAG_RD,
&component_revision, component_revision,
sizeof(component_revision), sizeof(component_revision),
"EMULEX One-Connect device driver revision"); "EMULEX One-Connect device driver revision");
SYSCTL_ADD_STRING(ctx, child, SYSCTL_ADD_STRING(ctx, child,
OID_AUTO, "firmware_version", OID_AUTO, "firmware_version",
CTLTYPE_INT | CTLFLAG_RD, CTLFLAG_RD,
&sc->fw_version, sc->fw_version,
sizeof(sc->fw_version), sizeof(sc->fw_version),
"EMULEX One-Connect Firmware Version"); "EMULEX One-Connect Firmware Version");
SYSCTL_ADD_INT(ctx, child, SYSCTL_ADD_INT(ctx, child,
OID_AUTO, "max_rsp_handled", OID_AUTO, "max_rsp_handled",
CTLTYPE_INT | CTLFLAG_RW, CTLFLAG_RW,
&oce_max_rsp_handled, &oce_max_rsp_handled,
sizeof(oce_max_rsp_handled), sizeof(oce_max_rsp_handled),
"Maximum receive frames handled per interupt"); "Maximum receive frames handled per interupt");
@ -957,11 +957,11 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_rxcp_errs", SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_rxcp_errs",
CTLFLAG_RD, &stats->rx.t_rxcp_errs, 0, CTLFLAG_RD, &stats->rx.t_rxcp_errs, 0,
"Total Receive completion errors"); "Total Receive completion errors");
SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "pause_frames", SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "pause_frames",
CTLFLAG_RD, &stats->u0.xe201.rx_pause_frames, 0, CTLFLAG_RD, &stats->u0.xe201.rx_pause_frames,
"Pause Frames"); "Pause Frames");
SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "control_frames", SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "control_frames",
CTLFLAG_RD, &stats->u0.xe201.rx_control_frames, 0, CTLFLAG_RD, &stats->u0.xe201.rx_control_frames,
"Control Frames"); "Control Frames");
for (i = 0; i < sc->nrqs; i++) { for (i = 0; i < sc->nrqs; i++) {
@ -1001,11 +1001,11 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
NULL, "Receive Error Stats"); NULL, "Receive Error Stats");
rx_stat_list = SYSCTL_CHILDREN(rx_stats_node); rx_stat_list = SYSCTL_CHILDREN(rx_stats_node);
SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "crc_errs", SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "crc_errs",
CTLFLAG_RD, &stats->u0.xe201.rx_crc_errors, 0, CTLFLAG_RD, &stats->u0.xe201.rx_crc_errors,
"CRC Errors"); "CRC Errors");
SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "alignment_errors", SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "alignment_errors",
CTLFLAG_RD, &stats->u0.xe201.rx_alignment_errors, 0, CTLFLAG_RD, &stats->u0.xe201.rx_alignment_errors,
"RX Alignmnet Errors"); "RX Alignmnet Errors");
SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "in_range_errors", SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "in_range_errors",
CTLFLAG_RD, &stats->u0.xe201.rx_in_range_errors, 0, CTLFLAG_RD, &stats->u0.xe201.rx_in_range_errors, 0,
@ -1013,8 +1013,8 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "out_range_errors", SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "out_range_errors",
CTLFLAG_RD, &stats->u0.xe201.rx_out_of_range_errors, 0, CTLFLAG_RD, &stats->u0.xe201.rx_out_of_range_errors, 0,
"Out Range Errors"); "Out Range Errors");
SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "frame_too_long", SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "frame_too_long",
CTLFLAG_RD, &stats->u0.xe201.rx_frames_too_long, 0, CTLFLAG_RD, &stats->u0.xe201.rx_frames_too_long,
"Frame Too Long"); "Frame Too Long");
SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "address_match_errors", SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "address_match_errors",
CTLFLAG_RD, &stats->u0.xe201.rx_address_match_errors, 0, CTLFLAG_RD, &stats->u0.xe201.rx_address_match_errors, 0,
@ -1077,11 +1077,11 @@ oce_add_stats_sysctls_xe201(POCE_SOFTC sc,
"total_ipv6_ext_hdr_tx_drop", "total_ipv6_ext_hdr_tx_drop",
CTLFLAG_RD, &stats->tx.t_ipv6_ext_hdr_tx_drop, 0, CTLFLAG_RD, &stats->tx.t_ipv6_ext_hdr_tx_drop, 0,
"Total Transmit IPV6 Drops"); "Total Transmit IPV6 Drops");
SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "pauseframes", SYSCTL_ADD_UQUAD(ctx, tx_stat_list, OID_AUTO, "pauseframes",
CTLFLAG_RD, &stats->u0.xe201.tx_pause_frames, 0, CTLFLAG_RD, &stats->u0.xe201.tx_pause_frames,
"Pause Frames"); "Pause Frames");
SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "controlframes", SYSCTL_ADD_UQUAD(ctx, tx_stat_list, OID_AUTO, "controlframes",
CTLFLAG_RD, &stats->u0.xe201.tx_control_frames, 0, CTLFLAG_RD, &stats->u0.xe201.tx_control_frames,
"Tx Control Frames"); "Tx Control Frames");
for (i = 0; i < sc->nwqs; i++) { for (i = 0; i < sc->nwqs; i++) {

View File

@ -157,7 +157,7 @@ qla_add_sysctls(qla_host_t *ha)
SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev), SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "fw_version", CTLFLAG_RD, OID_AUTO, "fw_version", CTLFLAG_RD,
&ha->fw_ver_str, 0, "firmware version"); ha->fw_ver_str, 0, "firmware version");
dbg_level = 0; dbg_level = 0;
SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev), SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev),

View File

@ -160,7 +160,7 @@ qla_add_sysctls(qla_host_t *ha)
SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev), SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "fw_version", CTLFLAG_RD, OID_AUTO, "fw_version", CTLFLAG_RD,
&ha->fw_ver_str, 0, "firmware version"); ha->fw_ver_str, 0, "firmware version");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),

View File

@ -2339,45 +2339,45 @@ rt_sysctl_attach(struct rt_softc *sc)
stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"stats", CTLFLAG_RD, 0, "statistic"); "stats", CTLFLAG_RD, 0, "statistic");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"interrupts", CTLFLAG_RD, &sc->interrupts, 0, "interrupts", CTLFLAG_RD, &sc->interrupts,
"all interrupts"); "all interrupts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_coherent_interrupts", CTLFLAG_RD, &sc->tx_coherent_interrupts, "tx_coherent_interrupts", CTLFLAG_RD, &sc->tx_coherent_interrupts,
0, "Tx coherent interrupts"); "Tx coherent interrupts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_coherent_interrupts", CTLFLAG_RD, &sc->rx_coherent_interrupts, "rx_coherent_interrupts", CTLFLAG_RD, &sc->rx_coherent_interrupts,
0, "Rx coherent interrupts"); "Rx coherent interrupts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_interrupts", CTLFLAG_RD, &sc->rx_interrupts, 0, "rx_interrupts", CTLFLAG_RD, &sc->rx_interrupts,
"Rx interrupts"); "Rx interrupts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_delay_interrupts", CTLFLAG_RD, &sc->rx_delay_interrupts, 0, "rx_delay_interrupts", CTLFLAG_RD, &sc->rx_delay_interrupts,
"Rx delay interrupts"); "Rx delay interrupts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"TXQ3_interrupts", CTLFLAG_RD, &sc->tx_interrupts[3], 0, "TXQ3_interrupts", CTLFLAG_RD, &sc->tx_interrupts[3],
"Tx AC3 interrupts"); "Tx AC3 interrupts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"TXQ2_interrupts", CTLFLAG_RD, &sc->tx_interrupts[2], 0, "TXQ2_interrupts", CTLFLAG_RD, &sc->tx_interrupts[2],
"Tx AC2 interrupts"); "Tx AC2 interrupts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"TXQ1_interrupts", CTLFLAG_RD, &sc->tx_interrupts[1], 0, "TXQ1_interrupts", CTLFLAG_RD, &sc->tx_interrupts[1],
"Tx AC1 interrupts"); "Tx AC1 interrupts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"TXQ0_interrupts", CTLFLAG_RD, &sc->tx_interrupts[0], 0, "TXQ0_interrupts", CTLFLAG_RD, &sc->tx_interrupts[0],
"Tx AC0 interrupts"); "Tx AC0 interrupts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_delay_interrupts", CTLFLAG_RD, &sc->tx_delay_interrupts, "tx_delay_interrupts", CTLFLAG_RD, &sc->tx_delay_interrupts,
0, "Tx delay interrupts"); "Tx delay interrupts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"TXQ3_desc_queued", CTLFLAG_RD, &sc->tx_ring[3].desc_queued, "TXQ3_desc_queued", CTLFLAG_RD, &sc->tx_ring[3].desc_queued,
@ -2411,93 +2411,96 @@ rt_sysctl_attach(struct rt_softc *sc)
"TXQ0_data_queued", CTLFLAG_RD, &sc->tx_ring[0].data_queued, "TXQ0_data_queued", CTLFLAG_RD, &sc->tx_ring[0].data_queued,
0, "Tx AC0 data queued"); 0, "Tx AC0 data queued");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"TXQ3_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[3], "TXQ3_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[3],
0, "Tx AC3 data queue full"); "Tx AC3 data queue full");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"TXQ2_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[2], "TXQ2_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[2],
0, "Tx AC2 data queue full"); "Tx AC2 data queue full");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"TXQ1_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[1], "TXQ1_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[1],
0, "Tx AC1 data queue full"); "Tx AC1 data queue full");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"TXQ0_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[0], "TXQ0_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[0],
0, "Tx AC0 data queue full"); "Tx AC0 data queue full");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_watchdog_timeouts", CTLFLAG_RD, &sc->tx_watchdog_timeouts, "tx_watchdog_timeouts", CTLFLAG_RD, &sc->tx_watchdog_timeouts,
0, "Tx watchdog timeouts"); "Tx watchdog timeouts");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_defrag_packets", CTLFLAG_RD, &sc->tx_defrag_packets, 0, "tx_defrag_packets", CTLFLAG_RD, &sc->tx_defrag_packets,
"Tx defragmented packets"); "Tx defragmented packets");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"no_tx_desc_avail", CTLFLAG_RD, &sc->no_tx_desc_avail, 0, "no_tx_desc_avail", CTLFLAG_RD, &sc->no_tx_desc_avail,
"no Tx descriptors available"); "no Tx descriptors available");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_mbuf_alloc_errors", CTLFLAG_RD, &sc->rx_mbuf_alloc_errors, "rx_mbuf_alloc_errors", CTLFLAG_RD, &sc->rx_mbuf_alloc_errors,
0, "Rx mbuf allocation errors"); "Rx mbuf allocation errors");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_mbuf_dmamap_errors", CTLFLAG_RD, &sc->rx_mbuf_dmamap_errors, "rx_mbuf_dmamap_errors", CTLFLAG_RD, &sc->rx_mbuf_dmamap_errors,
0, "Rx mbuf DMA mapping errors"); "Rx mbuf DMA mapping errors");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_queue_0_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[0], "tx_queue_0_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[0],
0, "Tx queue 0 not empty"); "Tx queue 0 not empty");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_queue_1_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[1], "tx_queue_1_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[1],
0, "Tx queue 1 not empty"); "Tx queue 1 not empty");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_packets", CTLFLAG_RD, &sc->rx_packets, 0, "rx_packets", CTLFLAG_RD, &sc->rx_packets,
"Rx packets"); "Rx packets");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_crc_errors", CTLFLAG_RD, &sc->rx_crc_err, 0, "rx_crc_errors", CTLFLAG_RD, &sc->rx_crc_err,
"Rx CRC errors"); "Rx CRC errors");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_phy_errors", CTLFLAG_RD, &sc->rx_phy_err, 0, "rx_phy_errors", CTLFLAG_RD, &sc->rx_phy_err,
"Rx PHY errors"); "Rx PHY errors");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_dup_packets", CTLFLAG_RD, &sc->rx_dup_packets, 0, "rx_dup_packets", CTLFLAG_RD, &sc->rx_dup_packets,
"Rx duplicate packets"); "Rx duplicate packets");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_fifo_overflows", CTLFLAG_RD, &sc->rx_fifo_overflows, 0, "rx_fifo_overflows", CTLFLAG_RD, &sc->rx_fifo_overflows,
"Rx FIFO overflows"); "Rx FIFO overflows");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_bytes", CTLFLAG_RD, &sc->rx_bytes, 0, "rx_bytes", CTLFLAG_RD, &sc->rx_bytes,
"Rx bytes"); "Rx bytes");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_long_err", CTLFLAG_RD, &sc->rx_long_err, 0, "rx_long_err", CTLFLAG_RD, &sc->rx_long_err,
"Rx too long frame errors"); "Rx too long frame errors");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"rx_short_err", CTLFLAG_RD, &sc->rx_short_err, 0, "rx_short_err", CTLFLAG_RD, &sc->rx_short_err,
"Rx too short frame errors"); "Rx too short frame errors");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_bytes", CTLFLAG_RD, &sc->tx_bytes, 0, "tx_bytes", CTLFLAG_RD, &sc->tx_bytes,
"Tx bytes"); "Tx bytes");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_packets", CTLFLAG_RD, &sc->tx_packets, 0, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_packets", CTLFLAG_RD, &sc->tx_packets,
"Tx packets"); "Tx packets");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_skip", CTLFLAG_RD, &sc->tx_skip, 0, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_skip", CTLFLAG_RD, &sc->tx_skip,
"Tx skip count for GDMA ports"); "Tx skip count for GDMA ports");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_collision", CTLFLAG_RD, &sc->tx_collision, 0, SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
"tx_collision", CTLFLAG_RD, &sc->tx_collision,
"Tx collision count for GDMA ports"); "Tx collision count for GDMA ports");
} }

View File

@ -7092,7 +7092,7 @@ hdaa_pcm_attach(device_t dev)
"rec.autosrc", &pdevinfo->autorecsrc); "rec.autosrc", &pdevinfo->autorecsrc);
SYSCTL_ADD_INT(&d->rec_sysctl_ctx, SYSCTL_ADD_INT(&d->rec_sysctl_ctx,
SYSCTL_CHILDREN(d->rec_sysctl_tree), OID_AUTO, SYSCTL_CHILDREN(d->rec_sysctl_tree), OID_AUTO,
"autosrc", CTLTYPE_INT | CTLFLAG_RW, "autosrc", CTLFLAG_RW,
&pdevinfo->autorecsrc, 0, &pdevinfo->autorecsrc, 0,
"Automatic recording source selection"); "Automatic recording source selection");
} }

View File

@ -3357,100 +3357,100 @@ vxge_device_hw_info_print(vxge_dev_t *vdev)
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Driver version", CTLFLAG_RD, OID_AUTO, "Driver version", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_DRV_VERSION], vdev->config.nic_attr[VXGE_PRINT_DRV_VERSION],
0, "Driver version"); 0, "Driver version");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Serial number", CTLFLAG_RD, OID_AUTO, "Serial number", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_SERIAL_NO], vdev->config.nic_attr[VXGE_PRINT_SERIAL_NO],
0, "Serial number"); 0, "Serial number");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Part number", CTLFLAG_RD, OID_AUTO, "Part number", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_PART_NO], vdev->config.nic_attr[VXGE_PRINT_PART_NO],
0, "Part number"); 0, "Part number");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Firmware version", CTLFLAG_RD, OID_AUTO, "Firmware version", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_FW_VERSION], vdev->config.nic_attr[VXGE_PRINT_FW_VERSION],
0, "Firmware version"); 0, "Firmware version");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Firmware date", CTLFLAG_RD, OID_AUTO, "Firmware date", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_FW_DATE], vdev->config.nic_attr[VXGE_PRINT_FW_DATE],
0, "Firmware date"); 0, "Firmware date");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Link width", CTLFLAG_RD, OID_AUTO, "Link width", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_PCIE_INFO], vdev->config.nic_attr[VXGE_PRINT_PCIE_INFO],
0, "Link width"); 0, "Link width");
if (vdev->is_privilaged) { if (vdev->is_privilaged) {
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Function mode", CTLFLAG_RD, OID_AUTO, "Function mode", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_FUNC_MODE], vdev->config.nic_attr[VXGE_PRINT_FUNC_MODE],
0, "Function mode"); 0, "Function mode");
} }
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Interrupt type", CTLFLAG_RD, OID_AUTO, "Interrupt type", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_INTR_MODE], vdev->config.nic_attr[VXGE_PRINT_INTR_MODE],
0, "Interrupt type"); 0, "Interrupt type");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "VPath(s) opened", CTLFLAG_RD, OID_AUTO, "VPath(s) opened", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_VPATH_COUNT], vdev->config.nic_attr[VXGE_PRINT_VPATH_COUNT],
0, "VPath(s) opened"); 0, "VPath(s) opened");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Adapter Type", CTLFLAG_RD, OID_AUTO, "Adapter Type", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_ADAPTER_TYPE], vdev->config.nic_attr[VXGE_PRINT_ADAPTER_TYPE],
0, "Adapter Type"); 0, "Adapter Type");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "pmd port 0", CTLFLAG_RD, OID_AUTO, "pmd port 0", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_PMD_PORTS_0], vdev->config.nic_attr[VXGE_PRINT_PMD_PORTS_0],
0, "pmd port"); 0, "pmd port");
if (hw_info->ports > 1) { if (hw_info->ports > 1) {
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "pmd port 1", CTLFLAG_RD, OID_AUTO, "pmd port 1", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_PMD_PORTS_1], vdev->config.nic_attr[VXGE_PRINT_PMD_PORTS_1],
0, "pmd port"); 0, "pmd port");
if (vdev->is_privilaged) { if (vdev->is_privilaged) {
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Port Mode", CTLFLAG_RD, OID_AUTO, "Port Mode", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_PORT_MODE], vdev->config.nic_attr[VXGE_PRINT_PORT_MODE],
0, "Port Mode"); 0, "Port Mode");
if (vdev->port_mode != VXGE_HAL_DP_NP_MODE_SINGLE_PORT) if (vdev->port_mode != VXGE_HAL_DP_NP_MODE_SINGLE_PORT)
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "Port Failure", CTLFLAG_RD, OID_AUTO, "Port Failure", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_PORT_FAILURE], vdev->config.nic_attr[VXGE_PRINT_PORT_FAILURE],
0, "Port Failure"); 0, "Port Failure");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "L2 Switch", CTLFLAG_RD, OID_AUTO, "L2 Switch", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_L2SWITCH_MODE], vdev->config.nic_attr[VXGE_PRINT_L2SWITCH_MODE],
0, "L2 Switch"); 0, "L2 Switch");
} }
} }
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "LRO mode", CTLFLAG_RD, OID_AUTO, "LRO mode", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_LRO_MODE], vdev->config.nic_attr[VXGE_PRINT_LRO_MODE],
0, "LRO mode"); 0, "LRO mode");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "RTH mode", CTLFLAG_RD, OID_AUTO, "RTH mode", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_RTH_MODE], vdev->config.nic_attr[VXGE_PRINT_RTH_MODE],
0, "RTH mode"); 0, "RTH mode");
SYSCTL_ADD_STRING(ctx, children, SYSCTL_ADD_STRING(ctx, children,
OID_AUTO, "TSO mode", CTLFLAG_RD, OID_AUTO, "TSO mode", CTLFLAG_RD,
&vdev->config.nic_attr[VXGE_PRINT_TSO_MODE], vdev->config.nic_attr[VXGE_PRINT_TSO_MODE],
0, "TSO mode"); 0, "TSO mode");
} }

View File

@ -470,7 +470,7 @@ netfront_attach(device_t dev)
#if __FreeBSD_version >= 700000 #if __FreeBSD_version >= 700000
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "enable_lro", CTLTYPE_INT|CTLFLAG_RW, OID_AUTO, "enable_lro", CTLFLAG_RW,
&xn_enable_lro, 0, "Large Receive Offload"); &xn_enable_lro, 0, "Large Receive Offload");
#endif #endif

View File

@ -109,10 +109,10 @@ SYSCTL_PROC(_kern, OID_AUTO, devname,
NULL, 0, sysctl_devname, "", "devname(3) handler"); NULL, 0, sysctl_devname, "", "devname(3) handler");
SYSCTL_INT(_debug_sizeof, OID_AUTO, cdev, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, cdev, CTLFLAG_RD,
0, sizeof(struct cdev), "sizeof(struct cdev)"); SYSCTL_NULL_INT_PTR, sizeof(struct cdev), "sizeof(struct cdev)");
SYSCTL_INT(_debug_sizeof, OID_AUTO, cdev_priv, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, cdev_priv, CTLFLAG_RD,
0, sizeof(struct cdev_priv), "sizeof(struct cdev_priv)"); SYSCTL_NULL_INT_PTR, sizeof(struct cdev_priv), "sizeof(struct cdev_priv)");
struct cdev * struct cdev *
devfs_alloc(int flags) devfs_alloc(int flags)

View File

@ -93,9 +93,9 @@ static struct vfsconf fuse_vfsconf = {
}; };
SYSCTL_INT(_vfs_fuse, OID_AUTO, kernelabi_major, CTLFLAG_RD, SYSCTL_INT(_vfs_fuse, OID_AUTO, kernelabi_major, CTLFLAG_RD,
0, FUSE_KERNEL_VERSION, "FUSE kernel abi major version"); SYSCTL_NULL_INT_PTR, FUSE_KERNEL_VERSION, "FUSE kernel abi major version");
SYSCTL_INT(_vfs_fuse, OID_AUTO, kernelabi_minor, CTLFLAG_RD, SYSCTL_INT(_vfs_fuse, OID_AUTO, kernelabi_minor, CTLFLAG_RD,
0, FUSE_KERNEL_MINOR_VERSION, "FUSE kernel abi minor version"); SYSCTL_NULL_INT_PTR, FUSE_KERNEL_MINOR_VERSION, "FUSE kernel abi minor version");
/****************************** /******************************
* *

View File

@ -114,10 +114,10 @@ struct vfsops fuse_vfsops = {
}; };
SYSCTL_INT(_vfs_fuse, OID_AUTO, init_backgrounded, CTLFLAG_RD, SYSCTL_INT(_vfs_fuse, OID_AUTO, init_backgrounded, CTLFLAG_RD,
0, 1, "indicate async handshake"); SYSCTL_NULL_INT_PTR, 1, "indicate async handshake");
static int fuse_enforce_dev_perms = 0; static int fuse_enforce_dev_perms = 0;
SYSCTL_LONG(_vfs_fuse, OID_AUTO, enforce_dev_perms, CTLFLAG_RW, SYSCTL_INT(_vfs_fuse, OID_AUTO, enforce_dev_perms, CTLFLAG_RW,
&fuse_enforce_dev_perms, 0, &fuse_enforce_dev_perms, 0,
"enforce fuse device permissions for secondary mounts"); "enforce fuse device permissions for secondary mounts");
static unsigned sync_unmount = 1; static unsigned sync_unmount = 1;

View File

@ -223,12 +223,12 @@ SYSCTL_INT(_kern_geom, OID_AUTO, collectstats, CTLFLAG_RW,
"Control statistics collection on GEOM providers and consumers"); "Control statistics collection on GEOM providers and consumers");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_class, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, g_class, CTLFLAG_RD,
0, sizeof(struct g_class), "sizeof(struct g_class)"); SYSCTL_NULL_INT_PTR, sizeof(struct g_class), "sizeof(struct g_class)");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_geom, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, g_geom, CTLFLAG_RD,
0, sizeof(struct g_geom), "sizeof(struct g_geom)"); SYSCTL_NULL_INT_PTR, sizeof(struct g_geom), "sizeof(struct g_geom)");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_provider, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, g_provider, CTLFLAG_RD,
0, sizeof(struct g_provider), "sizeof(struct g_provider)"); SYSCTL_NULL_INT_PTR, sizeof(struct g_provider), "sizeof(struct g_provider)");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_consumer, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, g_consumer, CTLFLAG_RD,
0, sizeof(struct g_consumer), "sizeof(struct g_consumer)"); SYSCTL_NULL_INT_PTR, sizeof(struct g_consumer), "sizeof(struct g_consumer)");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_bioq, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, g_bioq, CTLFLAG_RD,
0, sizeof(struct g_bioq), "sizeof(struct g_bioq)"); SYSCTL_NULL_INT_PTR, sizeof(struct g_bioq), "sizeof(struct g_bioq)");

View File

@ -110,7 +110,7 @@ static struct cpuset *cpuset_zero, *cpuset_default;
/* Return the size of cpuset_t at the kernel level */ /* Return the size of cpuset_t at the kernel level */
SYSCTL_INT(_kern_sched, OID_AUTO, cpusetsize, CTLFLAG_RD, SYSCTL_INT(_kern_sched, OID_AUTO, cpusetsize, CTLFLAG_RD,
0, sizeof(cpuset_t), "sizeof(cpuset_t)"); SYSCTL_NULL_INT_PTR, sizeof(cpuset_t), "sizeof(cpuset_t)");
cpuset_t *cpuset_root; cpuset_t *cpuset_root;

View File

@ -3342,7 +3342,7 @@ sysctl_kern_proc_ofiledesc(SYSCTL_HANDLER_ARGS)
} }
static SYSCTL_NODE(_kern_proc, KERN_PROC_OFILEDESC, ofiledesc, static SYSCTL_NODE(_kern_proc, KERN_PROC_OFILEDESC, ofiledesc,
CTLFLAG_RD||CTLFLAG_MPSAFE, sysctl_kern_proc_ofiledesc, CTLFLAG_RD|CTLFLAG_MPSAFE, sysctl_kern_proc_ofiledesc,
"Process ofiledesc entries"); "Process ofiledesc entries");
#endif /* COMPAT_FREEBSD7 */ #endif /* COMPAT_FREEBSD7 */

View File

@ -94,7 +94,7 @@ SYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease, CTLFLAG_RD|CTLFLAG_MPSAFE|
CTLFLAG_CAPRD, osrelease, 0, "Operating system release"); CTLFLAG_CAPRD, osrelease, 0, "Operating system release");
SYSCTL_INT(_kern, KERN_OSREV, osrevision, CTLFLAG_RD|CTLFLAG_CAPRD, SYSCTL_INT(_kern, KERN_OSREV, osrevision, CTLFLAG_RD|CTLFLAG_CAPRD,
0, BSD, "Operating system revision"); SYSCTL_NULL_INT_PTR, BSD, "Operating system revision");
SYSCTL_STRING(_kern, KERN_VERSION, version, CTLFLAG_RD|CTLFLAG_MPSAFE, SYSCTL_STRING(_kern, KERN_VERSION, version, CTLFLAG_RD|CTLFLAG_MPSAFE,
version, 0, "Kernel version"); version, 0, "Kernel version");
@ -122,24 +122,24 @@ SYSCTL_INT(_kern, OID_AUTO, maxusers, CTLFLAG_RDTUN | CTLFLAG_NOFETCH,
&maxusers, 0, "Hint for kernel tuning"); &maxusers, 0, "Hint for kernel tuning");
SYSCTL_INT(_kern, KERN_ARGMAX, argmax, CTLFLAG_RD|CTLFLAG_CAPRD, SYSCTL_INT(_kern, KERN_ARGMAX, argmax, CTLFLAG_RD|CTLFLAG_CAPRD,
0, ARG_MAX, "Maximum bytes of argument to execve(2)"); SYSCTL_NULL_INT_PTR, ARG_MAX, "Maximum bytes of argument to execve(2)");
SYSCTL_INT(_kern, KERN_POSIX1, posix1version, CTLFLAG_RD|CTLFLAG_CAPRD, SYSCTL_INT(_kern, KERN_POSIX1, posix1version, CTLFLAG_RD|CTLFLAG_CAPRD,
0, _POSIX_VERSION, "Version of POSIX attempting to comply to"); SYSCTL_NULL_INT_PTR, _POSIX_VERSION, "Version of POSIX attempting to comply to");
SYSCTL_INT(_kern, KERN_NGROUPS, ngroups, CTLFLAG_RDTUN | SYSCTL_INT(_kern, KERN_NGROUPS, ngroups, CTLFLAG_RDTUN |
CTLFLAG_NOFETCH | CTLFLAG_CAPRD, &ngroups_max, 0, CTLFLAG_NOFETCH | CTLFLAG_CAPRD, &ngroups_max, 0,
"Maximum number of supplemental groups a user can belong to"); "Maximum number of supplemental groups a user can belong to");
SYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control, CTLFLAG_RD|CTLFLAG_CAPRD, SYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control, CTLFLAG_RD|CTLFLAG_CAPRD,
0, 1, "Whether job control is available"); SYSCTL_NULL_INT_PTR, 1, "Whether job control is available");
#ifdef _POSIX_SAVED_IDS #ifdef _POSIX_SAVED_IDS
SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD|CTLFLAG_CAPRD, SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD|CTLFLAG_CAPRD,
0, 1, "Whether saved set-group/user ID is available"); SYSCTL_NULL_INT_PTR, 1, "Whether saved set-group/user ID is available");
#else #else
SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD|CTLFLAG_CAPRD, SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD|CTLFLAG_CAPRD,
0, 0, "Whether saved set-group/user ID is available"); SYSCTL_NULL_INT_PTR, 0, "Whether saved set-group/user ID is available");
#endif #endif
char kernelname[MAXPATHLEN] = "/kernel"; /* XXX bloat */ char kernelname[MAXPATHLEN] = "/kernel"; /* XXX bloat */
@ -151,10 +151,10 @@ SYSCTL_INT(_hw, HW_NCPU, ncpu, CTLFLAG_RD|CTLFLAG_CAPRD,
&mp_ncpus, 0, "Number of active CPUs"); &mp_ncpus, 0, "Number of active CPUs");
SYSCTL_INT(_hw, HW_BYTEORDER, byteorder, CTLFLAG_RD|CTLFLAG_CAPRD, SYSCTL_INT(_hw, HW_BYTEORDER, byteorder, CTLFLAG_RD|CTLFLAG_CAPRD,
0, BYTE_ORDER, "System byte order"); SYSCTL_NULL_INT_PTR, BYTE_ORDER, "System byte order");
SYSCTL_INT(_hw, HW_PAGESIZE, pagesize, CTLFLAG_RD|CTLFLAG_CAPRD, SYSCTL_INT(_hw, HW_PAGESIZE, pagesize, CTLFLAG_RD|CTLFLAG_CAPRD,
0, PAGE_SIZE, "System memory page size"); SYSCTL_NULL_INT_PTR, PAGE_SIZE, "System memory page size");
static int static int
sysctl_kern_arnd(SYSCTL_HANDLER_ARGS) sysctl_kern_arnd(SYSCTL_HANDLER_ARGS)
@ -457,50 +457,51 @@ FEATURE(compat_freebsd7, "Compatible with FreeBSD 7");
SYSCTL_STRING(_user, USER_CS_PATH, cs_path, CTLFLAG_RD, SYSCTL_STRING(_user, USER_CS_PATH, cs_path, CTLFLAG_RD,
"", 0, "PATH that finds all the standard utilities"); "", 0, "PATH that finds all the standard utilities");
SYSCTL_INT(_user, USER_BC_BASE_MAX, bc_base_max, CTLFLAG_RD, SYSCTL_INT(_user, USER_BC_BASE_MAX, bc_base_max, CTLFLAG_RD,
0, 0, "Max ibase/obase values in bc(1)"); SYSCTL_NULL_INT_PTR, 0, "Max ibase/obase values in bc(1)");
SYSCTL_INT(_user, USER_BC_DIM_MAX, bc_dim_max, CTLFLAG_RD, SYSCTL_INT(_user, USER_BC_DIM_MAX, bc_dim_max, CTLFLAG_RD,
0, 0, "Max array size in bc(1)"); SYSCTL_NULL_INT_PTR, 0, "Max array size in bc(1)");
SYSCTL_INT(_user, USER_BC_SCALE_MAX, bc_scale_max, CTLFLAG_RD, SYSCTL_INT(_user, USER_BC_SCALE_MAX, bc_scale_max, CTLFLAG_RD,
0, 0, "Max scale value in bc(1)"); SYSCTL_NULL_INT_PTR, 0, "Max scale value in bc(1)");
SYSCTL_INT(_user, USER_BC_STRING_MAX, bc_string_max, CTLFLAG_RD, SYSCTL_INT(_user, USER_BC_STRING_MAX, bc_string_max, CTLFLAG_RD,
0, 0, "Max string length in bc(1)"); SYSCTL_NULL_INT_PTR, 0, "Max string length in bc(1)");
SYSCTL_INT(_user, USER_COLL_WEIGHTS_MAX, coll_weights_max, CTLFLAG_RD, SYSCTL_INT(_user, USER_COLL_WEIGHTS_MAX, coll_weights_max, CTLFLAG_RD,
0, 0, "Maximum number of weights assigned to an LC_COLLATE locale entry"); SYSCTL_NULL_INT_PTR, 0, "Maximum number of weights assigned to an LC_COLLATE locale entry");
SYSCTL_INT(_user, USER_EXPR_NEST_MAX, expr_nest_max, CTLFLAG_RD, 0, 0, ""); SYSCTL_INT(_user, USER_EXPR_NEST_MAX, expr_nest_max, CTLFLAG_RD,
SYSCTL_NULL_INT_PTR, 0, "");
SYSCTL_INT(_user, USER_LINE_MAX, line_max, CTLFLAG_RD, SYSCTL_INT(_user, USER_LINE_MAX, line_max, CTLFLAG_RD,
0, 0, "Max length (bytes) of a text-processing utility's input line"); SYSCTL_NULL_INT_PTR, 0, "Max length (bytes) of a text-processing utility's input line");
SYSCTL_INT(_user, USER_RE_DUP_MAX, re_dup_max, CTLFLAG_RD, SYSCTL_INT(_user, USER_RE_DUP_MAX, re_dup_max, CTLFLAG_RD,
0, 0, "Maximum number of repeats of a regexp permitted"); SYSCTL_NULL_INT_PTR, 0, "Maximum number of repeats of a regexp permitted");
SYSCTL_INT(_user, USER_POSIX2_VERSION, posix2_version, CTLFLAG_RD, SYSCTL_INT(_user, USER_POSIX2_VERSION, posix2_version, CTLFLAG_RD,
0, 0, SYSCTL_NULL_INT_PTR, 0,
"The version of POSIX 1003.2 with which the system attempts to comply"); "The version of POSIX 1003.2 with which the system attempts to comply");
SYSCTL_INT(_user, USER_POSIX2_C_BIND, posix2_c_bind, CTLFLAG_RD, SYSCTL_INT(_user, USER_POSIX2_C_BIND, posix2_c_bind, CTLFLAG_RD,
0, 0, "Whether C development supports the C bindings option"); SYSCTL_NULL_INT_PTR, 0, "Whether C development supports the C bindings option");
SYSCTL_INT(_user, USER_POSIX2_C_DEV, posix2_c_dev, CTLFLAG_RD, SYSCTL_INT(_user, USER_POSIX2_C_DEV, posix2_c_dev, CTLFLAG_RD,
0, 0, "Whether system supports the C development utilities option"); SYSCTL_NULL_INT_PTR, 0, "Whether system supports the C development utilities option");
SYSCTL_INT(_user, USER_POSIX2_CHAR_TERM, posix2_char_term, CTLFLAG_RD, SYSCTL_INT(_user, USER_POSIX2_CHAR_TERM, posix2_char_term, CTLFLAG_RD,
0, 0, ""); SYSCTL_NULL_INT_PTR, 0, "");
SYSCTL_INT(_user, USER_POSIX2_FORT_DEV, posix2_fort_dev, CTLFLAG_RD, SYSCTL_INT(_user, USER_POSIX2_FORT_DEV, posix2_fort_dev, CTLFLAG_RD,
0, 0, "Whether system supports FORTRAN development utilities"); SYSCTL_NULL_INT_PTR, 0, "Whether system supports FORTRAN development utilities");
SYSCTL_INT(_user, USER_POSIX2_FORT_RUN, posix2_fort_run, CTLFLAG_RD, SYSCTL_INT(_user, USER_POSIX2_FORT_RUN, posix2_fort_run, CTLFLAG_RD,
0, 0, "Whether system supports FORTRAN runtime utilities"); SYSCTL_NULL_INT_PTR, 0, "Whether system supports FORTRAN runtime utilities");
SYSCTL_INT(_user, USER_POSIX2_LOCALEDEF, posix2_localedef, CTLFLAG_RD, SYSCTL_INT(_user, USER_POSIX2_LOCALEDEF, posix2_localedef, CTLFLAG_RD,
0, 0, "Whether system supports creation of locales"); SYSCTL_NULL_INT_PTR, 0, "Whether system supports creation of locales");
SYSCTL_INT(_user, USER_POSIX2_SW_DEV, posix2_sw_dev, CTLFLAG_RD, SYSCTL_INT(_user, USER_POSIX2_SW_DEV, posix2_sw_dev, CTLFLAG_RD,
0, 0, "Whether system supports software development utilities"); SYSCTL_NULL_INT_PTR, 0, "Whether system supports software development utilities");
SYSCTL_INT(_user, USER_POSIX2_UPE, posix2_upe, CTLFLAG_RD, SYSCTL_INT(_user, USER_POSIX2_UPE, posix2_upe, CTLFLAG_RD,
0, 0, "Whether system supports the user portability utilities"); SYSCTL_NULL_INT_PTR, 0, "Whether system supports the user portability utilities");
SYSCTL_INT(_user, USER_STREAM_MAX, stream_max, CTLFLAG_RD, SYSCTL_INT(_user, USER_STREAM_MAX, stream_max, CTLFLAG_RD,
0, 0, "Min Maximum number of streams a process may have open at one time"); SYSCTL_NULL_INT_PTR, 0, "Min Maximum number of streams a process may have open at one time");
SYSCTL_INT(_user, USER_TZNAME_MAX, tzname_max, CTLFLAG_RD, SYSCTL_INT(_user, USER_TZNAME_MAX, tzname_max, CTLFLAG_RD,
0, 0, "Min Maximum number of types supported for timezone names"); SYSCTL_NULL_INT_PTR, 0, "Min Maximum number of types supported for timezone names");
#include <sys/vnode.h> #include <sys/vnode.h>
SYSCTL_INT(_debug_sizeof, OID_AUTO, vnode, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, vnode, CTLFLAG_RD,
0, sizeof(struct vnode), "sizeof(struct vnode)"); SYSCTL_NULL_INT_PTR, sizeof(struct vnode), "sizeof(struct vnode)");
SYSCTL_INT(_debug_sizeof, OID_AUTO, proc, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, proc, CTLFLAG_RD,
0, sizeof(struct proc), "sizeof(struct proc)"); SYSCTL_NULL_INT_PTR, sizeof(struct proc), "sizeof(struct proc)");
static int static int
sysctl_kern_pid_max(SYSCTL_HANDLER_ARGS) sysctl_kern_pid_max(SYSCTL_HANDLER_ARGS)
@ -533,13 +534,13 @@ SYSCTL_PROC(_kern, OID_AUTO, pid_max, CTLTYPE_INT |
#include <sys/bio.h> #include <sys/bio.h>
#include <sys/buf.h> #include <sys/buf.h>
SYSCTL_INT(_debug_sizeof, OID_AUTO, bio, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, bio, CTLFLAG_RD,
0, sizeof(struct bio), "sizeof(struct bio)"); SYSCTL_NULL_INT_PTR, sizeof(struct bio), "sizeof(struct bio)");
SYSCTL_INT(_debug_sizeof, OID_AUTO, buf, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, buf, CTLFLAG_RD,
0, sizeof(struct buf), "sizeof(struct buf)"); SYSCTL_NULL_INT_PTR, sizeof(struct buf), "sizeof(struct buf)");
#include <sys/user.h> #include <sys/user.h>
SYSCTL_INT(_debug_sizeof, OID_AUTO, kinfo_proc, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, kinfo_proc, CTLFLAG_RD,
0, sizeof(struct kinfo_proc), "sizeof(struct kinfo_proc)"); SYSCTL_NULL_INT_PTR, sizeof(struct kinfo_proc), "sizeof(struct kinfo_proc)");
/* XXX compatibility, remove for 6.0 */ /* XXX compatibility, remove for 6.0 */
#include <sys/imgact.h> #include <sys/imgact.h>

View File

@ -101,8 +101,7 @@ static fixpt_t cexp[3] = {
}; };
/* kernel uses `FSCALE', userland (SHOULD) use kern.fscale */ /* kernel uses `FSCALE', userland (SHOULD) use kern.fscale */
static int fscale __unused = FSCALE; SYSCTL_INT(_kern, OID_AUTO, fscale, CTLFLAG_RD, SYSCTL_NULL_INT_PTR, FSCALE, "");
SYSCTL_INT(_kern, OID_AUTO, fscale, CTLFLAG_RD, 0, FSCALE, "");
static void loadav(void *arg); static void loadav(void *arg);

View File

@ -575,4 +575,4 @@ devstat_free(struct devstat *dsp)
} }
SYSCTL_INT(_debug_sizeof, OID_AUTO, devstat, CTLFLAG_RD, SYSCTL_INT(_debug_sizeof, OID_AUTO, devstat, CTLFLAG_RD,
NULL, sizeof(struct devstat), "sizeof(struct devstat)"); SYSCTL_NULL_INT_PTR, sizeof(struct devstat), "sizeof(struct devstat)");

View File

@ -108,11 +108,11 @@ SYSCTL_PROC(_debug_kdb, OID_AUTO, trap_code,
kdb_sysctl_trap_code, "I", "set to cause a page fault via code access"); kdb_sysctl_trap_code, "I", "set to cause a page fault via code access");
SYSCTL_INT(_debug_kdb, OID_AUTO, break_to_debugger, SYSCTL_INT(_debug_kdb, OID_AUTO, break_to_debugger,
CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_SECURE, CTLFLAG_RWTUN | CTLFLAG_SECURE,
&kdb_break_to_debugger, 0, "Enable break to debugger"); &kdb_break_to_debugger, 0, "Enable break to debugger");
SYSCTL_INT(_debug_kdb, OID_AUTO, alt_break_to_debugger, SYSCTL_INT(_debug_kdb, OID_AUTO, alt_break_to_debugger,
CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_SECURE, CTLFLAG_RWTUN | CTLFLAG_SECURE,
&kdb_alt_break_to_debugger, 0, "Enable alternative break to debugger"); &kdb_alt_break_to_debugger, 0, "Enable alternative break to debugger");
/* /*

View File

@ -57,7 +57,7 @@ __FBSDID("$FreeBSD$");
#include <vm/vm_pageout.h> #include <vm/vm_pageout.h>
#include <vm/vm_map.h> #include <vm/vm_map.h>
SYSCTL_INT(_kern, KERN_IOV_MAX, iov_max, CTLFLAG_RD, NULL, UIO_MAXIOV, SYSCTL_INT(_kern, KERN_IOV_MAX, iov_max, CTLFLAG_RD, SYSCTL_NULL_INT_PTR, UIO_MAXIOV,
"Maximum number of elements in an I/O vector; sysconf(_SC_IOV_MAX)"); "Maximum number of elements in an I/O vector; sysconf(_SC_IOV_MAX)");
static int uiomove_faultflag(void *cp, int n, struct uio *uio, int nofault); static int uiomove_faultflag(void *cp, int n, struct uio *uio, int nofault);

View File

@ -264,7 +264,7 @@ SYSCTL_INT(_debug, OID_AUTO, vfscache, CTLFLAG_RW, &doingcache, 0,
"VFS namecache enabled"); "VFS namecache enabled");
/* Export size information to userland */ /* Export size information to userland */
SYSCTL_INT(_debug_sizeof, OID_AUTO, namecache, CTLFLAG_RD, 0, SYSCTL_INT(_debug_sizeof, OID_AUTO, namecache, CTLFLAG_RD, SYSCTL_NULL_INT_PTR,
sizeof(struct namecache), "sizeof(struct namecache)"); sizeof(struct namecache), "sizeof(struct namecache)");
/* /*

View File

@ -1262,9 +1262,9 @@ alloc_bounce_zone(bus_dma_tag_t dmat)
SYSCTL_ADD_STRING(busdma_sysctl_tree(bz), SYSCTL_ADD_STRING(busdma_sysctl_tree(bz),
SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO, SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO,
"lowaddr", CTLFLAG_RD, bz->lowaddrid, 0, ""); "lowaddr", CTLFLAG_RD, bz->lowaddrid, 0, "");
SYSCTL_ADD_INT(busdma_sysctl_tree(bz), SYSCTL_ADD_UAUTO(busdma_sysctl_tree(bz),
SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO, SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO,
"alignment", CTLFLAG_RD, &bz->alignment, 0, ""); "alignment", CTLFLAG_RD, &bz->alignment, "");
return (0); return (0);
} }

View File

@ -155,7 +155,7 @@ SYSCTL_PROC(_net_wlan, OID_AUTO, addba_backoff, CTLTYPE_INT | CTLFLAG_RW,
&ieee80211_addba_backoff, 0, ieee80211_sysctl_msecs_ticks, "I", &ieee80211_addba_backoff, 0, ieee80211_sysctl_msecs_ticks, "I",
"ADDBA request backoff (ms)"); "ADDBA request backoff (ms)");
static int ieee80211_addba_maxtries = 3;/* max ADDBA requests before backoff */ static int ieee80211_addba_maxtries = 3;/* max ADDBA requests before backoff */
SYSCTL_INT(_net_wlan, OID_AUTO, addba_maxtries, CTLTYPE_INT | CTLFLAG_RW, SYSCTL_INT(_net_wlan, OID_AUTO, addba_maxtries, CTLFLAG_RW,
&ieee80211_addba_maxtries, 0, "max ADDBA requests sent before backoff"); &ieee80211_addba_maxtries, 0, "max ADDBA requests sent before backoff");
static int ieee80211_bar_timeout = -1; /* timeout waiting for BAR response */ static int ieee80211_bar_timeout = -1; /* timeout waiting for BAR response */

View File

@ -168,7 +168,7 @@ struct ieee80211_hwmp_state {
static SYSCTL_NODE(_net_wlan, OID_AUTO, hwmp, CTLFLAG_RD, 0, static SYSCTL_NODE(_net_wlan, OID_AUTO, hwmp, CTLFLAG_RD, 0,
"IEEE 802.11s HWMP parameters"); "IEEE 802.11s HWMP parameters");
static int ieee80211_hwmp_targetonly = 0; static int ieee80211_hwmp_targetonly = 0;
SYSCTL_INT(_net_wlan_hwmp, OID_AUTO, targetonly, CTLTYPE_INT | CTLFLAG_RW, SYSCTL_INT(_net_wlan_hwmp, OID_AUTO, targetonly, CTLFLAG_RW,
&ieee80211_hwmp_targetonly, 0, "Set TO bit on generated PREQs"); &ieee80211_hwmp_targetonly, 0, "Set TO bit on generated PREQs");
static int ieee80211_hwmp_pathtimeout = -1; 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,

View File

@ -128,11 +128,11 @@ SYSCTL_PROC(_net_wlan_mesh, OID_AUTO, backofftimeout, CTLTYPE_INT | CTLFLAG_RW,
"Backoff timeout (msec). This is to throutles peering forever when " "Backoff timeout (msec). This is to throutles peering forever when "
"not receving answer or is rejected by a neighbor"); "not receving answer or is rejected by a neighbor");
static int ieee80211_mesh_maxretries = 2; static int ieee80211_mesh_maxretries = 2;
SYSCTL_INT(_net_wlan_mesh, OID_AUTO, maxretries, CTLTYPE_INT | CTLFLAG_RW, SYSCTL_INT(_net_wlan_mesh, OID_AUTO, maxretries, CTLFLAG_RW,
&ieee80211_mesh_maxretries, 0, &ieee80211_mesh_maxretries, 0,
"Maximum retries during peer link establishment"); "Maximum retries during peer link establishment");
static int ieee80211_mesh_maxholding = 2; static int ieee80211_mesh_maxholding = 2;
SYSCTL_INT(_net_wlan_mesh, OID_AUTO, maxholding, CTLTYPE_INT | CTLFLAG_RW, SYSCTL_INT(_net_wlan_mesh, OID_AUTO, maxholding, CTLFLAG_RW,
&ieee80211_mesh_maxholding, 0, &ieee80211_mesh_maxholding, 0,
"Maximum times we are allowed to transition to HOLDING state before " "Maximum times we are allowed to transition to HOLDING state before "
"backinoff during peer link establishment"); "backinoff during peer link establishment");

View File

@ -87,7 +87,7 @@ __FBSDID("$FreeBSD$");
memcpy(dst, src, sizeof(struct ether_header)) memcpy(dst, src, sizeof(struct ether_header))
static int ieee80211_ffppsmin = 2; /* pps threshold for ff aggregation */ static int ieee80211_ffppsmin = 2; /* pps threshold for ff aggregation */
SYSCTL_INT(_net_wlan, OID_AUTO, ffppsmin, CTLTYPE_INT | CTLFLAG_RW, SYSCTL_INT(_net_wlan, OID_AUTO, ffppsmin, CTLFLAG_RW,
&ieee80211_ffppsmin, 0, "min packet rate before fast-frame staging"); &ieee80211_ffppsmin, 0, "min packet rate before fast-frame staging");
static int ieee80211_ffagemax = -1; /* max time frames held on stage q */ static int ieee80211_ffagemax = -1; /* max time frames held on stage q */
SYSCTL_PROC(_net_wlan, OID_AUTO, ffagemax, CTLTYPE_INT | CTLFLAG_RW, SYSCTL_PROC(_net_wlan, OID_AUTO, ffagemax, CTLTYPE_INT | CTLFLAG_RW,

View File

@ -57,7 +57,7 @@ static u_int32_t bluetooth_sco_rtx_timeout_value = 60; /* sec */
SYSCTL_NODE(_net, OID_AUTO, bluetooth, CTLFLAG_RW, 0, "Bluetooth family"); SYSCTL_NODE(_net, OID_AUTO, bluetooth, CTLFLAG_RW, 0, "Bluetooth family");
SYSCTL_INT(_net_bluetooth, OID_AUTO, version, SYSCTL_INT(_net_bluetooth, OID_AUTO, version,
CTLFLAG_RD, 0, NG_BLUETOOTH_VERSION, "Version of the stack"); CTLFLAG_RD, SYSCTL_NULL_INT_PTR, NG_BLUETOOTH_VERSION, "Version of the stack");
/* /*
* HCI * HCI

View File

@ -3249,8 +3249,8 @@ static moduledata_t netgraph_mod = {
}; };
DECLARE_MODULE(netgraph, netgraph_mod, SI_SUB_NETGRAPH, SI_ORDER_FIRST); DECLARE_MODULE(netgraph, netgraph_mod, SI_SUB_NETGRAPH, SI_ORDER_FIRST);
SYSCTL_NODE(_net, OID_AUTO, graph, CTLFLAG_RW, 0, "netgraph Family"); SYSCTL_NODE(_net, OID_AUTO, graph, CTLFLAG_RW, 0, "netgraph Family");
SYSCTL_INT(_net_graph, OID_AUTO, abi_version, CTLFLAG_RD, 0, NG_ABI_VERSION,""); SYSCTL_INT(_net_graph, OID_AUTO, abi_version, CTLFLAG_RD, SYSCTL_NULL_INT_PTR, NG_ABI_VERSION,"");
SYSCTL_INT(_net_graph, OID_AUTO, msg_version, CTLFLAG_RD, 0, NG_VERSION, ""); SYSCTL_INT(_net_graph, OID_AUTO, msg_version, CTLFLAG_RD, SYSCTL_NULL_INT_PTR, NG_VERSION, "");
#ifdef NETGRAPH_DEBUG #ifdef NETGRAPH_DEBUG
void void

View File

@ -1199,9 +1199,9 @@ ngs_mod_event(module_t mod, int event, void *data)
VNET_DOMAIN_SET(ng); VNET_DOMAIN_SET(ng);
SYSCTL_INT(_net_graph, OID_AUTO, family, CTLFLAG_RD, 0, AF_NETGRAPH, ""); SYSCTL_INT(_net_graph, OID_AUTO, family, CTLFLAG_RD, SYSCTL_NULL_INT_PTR, AF_NETGRAPH, "");
static SYSCTL_NODE(_net_graph, OID_AUTO, data, CTLFLAG_RW, 0, "DATA"); static SYSCTL_NODE(_net_graph, OID_AUTO, data, CTLFLAG_RW, 0, "DATA");
SYSCTL_INT(_net_graph_data, OID_AUTO, proto, CTLFLAG_RD, 0, NG_DATA, ""); SYSCTL_INT(_net_graph_data, OID_AUTO, proto, CTLFLAG_RD, SYSCTL_NULL_INT_PTR, NG_DATA, "");
static SYSCTL_NODE(_net_graph, OID_AUTO, control, CTLFLAG_RW, 0, "CONTROL"); static SYSCTL_NODE(_net_graph, OID_AUTO, control, CTLFLAG_RW, 0, "CONTROL");
SYSCTL_INT(_net_graph_control, OID_AUTO, proto, CTLFLAG_RD, 0, NG_CONTROL, ""); SYSCTL_INT(_net_graph_control, OID_AUTO, proto, CTLFLAG_RD, SYSCTL_NULL_INT_PTR, NG_CONTROL, "");

View File

@ -484,11 +484,11 @@ SYSCTL_VNET_PROC(_net_inet_tcp_cc_chd, OID_AUTO, queue_threshold,
"IU", "Queueing congestion threshold in ticks"); "IU", "Queueing congestion threshold in ticks");
SYSCTL_VNET_UINT(_net_inet_tcp_cc_chd, OID_AUTO, queue_min, SYSCTL_VNET_UINT(_net_inet_tcp_cc_chd, OID_AUTO, queue_min,
CTLTYPE_UINT|CTLFLAG_RW, &VNET_NAME(chd_qmin), 5, CTLFLAG_RW, &VNET_NAME(chd_qmin), 5,
"Minimum queueing delay threshold in ticks"); "Minimum queueing delay threshold in ticks");
SYSCTL_VNET_UINT(_net_inet_tcp_cc_chd, OID_AUTO, use_max, SYSCTL_VNET_UINT(_net_inet_tcp_cc_chd, OID_AUTO, use_max,
CTLTYPE_UINT|CTLFLAG_RW, &VNET_NAME(chd_use_max), 1, CTLFLAG_RW, &VNET_NAME(chd_use_max), 1,
"Use the maximum RTT seen within the measurement period (RTT) " "Use the maximum RTT seen within the measurement period (RTT) "
"as the basic delay measurement for the algorithm."); "as the basic delay measurement for the algorithm.");

View File

@ -133,7 +133,7 @@ SYSCTL_INT(_net_inet_tcp, OID_AUTO, rexmit_drop_options, CTLFLAG_RW,
static VNET_DEFINE(int, tcp_pmtud_blackhole_detect); static VNET_DEFINE(int, tcp_pmtud_blackhole_detect);
#define V_tcp_pmtud_blackhole_detect VNET(tcp_pmtud_blackhole_detect) #define V_tcp_pmtud_blackhole_detect VNET(tcp_pmtud_blackhole_detect)
SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_detection, SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_detection,
CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_VNET, CTLFLAG_RW|CTLFLAG_VNET,
&VNET_NAME(tcp_pmtud_blackhole_detect), 0, &VNET_NAME(tcp_pmtud_blackhole_detect), 0,
"Path MTU Discovery Black Hole Detection Enabled"); "Path MTU Discovery Black Hole Detection Enabled");
@ -141,7 +141,7 @@ static VNET_DEFINE(int, tcp_pmtud_blackhole_activated);
#define V_tcp_pmtud_blackhole_activated \ #define V_tcp_pmtud_blackhole_activated \
VNET(tcp_pmtud_blackhole_activated) VNET(tcp_pmtud_blackhole_activated)
SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_activated, SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_activated,
CTLTYPE_INT|CTLFLAG_RD|CTLFLAG_VNET, CTLFLAG_RD|CTLFLAG_VNET,
&VNET_NAME(tcp_pmtud_blackhole_activated), 0, &VNET_NAME(tcp_pmtud_blackhole_activated), 0,
"Path MTU Discovery Black Hole Detection, Activation Count"); "Path MTU Discovery Black Hole Detection, Activation Count");
@ -149,14 +149,14 @@ static VNET_DEFINE(int, tcp_pmtud_blackhole_activated_min_mss);
#define V_tcp_pmtud_blackhole_activated_min_mss \ #define V_tcp_pmtud_blackhole_activated_min_mss \
VNET(tcp_pmtud_blackhole_activated_min_mss) VNET(tcp_pmtud_blackhole_activated_min_mss)
SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_activated_min_mss, SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_activated_min_mss,
CTLTYPE_INT|CTLFLAG_RD|CTLFLAG_VNET, CTLFLAG_RD|CTLFLAG_VNET,
&VNET_NAME(tcp_pmtud_blackhole_activated_min_mss), 0, &VNET_NAME(tcp_pmtud_blackhole_activated_min_mss), 0,
"Path MTU Discovery Black Hole Detection, Activation Count at min MSS"); "Path MTU Discovery Black Hole Detection, Activation Count at min MSS");
static VNET_DEFINE(int, tcp_pmtud_blackhole_failed); static VNET_DEFINE(int, tcp_pmtud_blackhole_failed);
#define V_tcp_pmtud_blackhole_failed VNET(tcp_pmtud_blackhole_failed) #define V_tcp_pmtud_blackhole_failed VNET(tcp_pmtud_blackhole_failed)
SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_failed, SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_failed,
CTLTYPE_INT|CTLFLAG_RD|CTLFLAG_VNET, CTLFLAG_RD|CTLFLAG_VNET,
&VNET_NAME(tcp_pmtud_blackhole_failed), 0, &VNET_NAME(tcp_pmtud_blackhole_failed), 0,
"Path MTU Discovery Black Hole Detection, Failure Count"); "Path MTU Discovery Black Hole Detection, Failure Count");
@ -164,7 +164,7 @@ SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_failed,
static VNET_DEFINE(int, tcp_pmtud_blackhole_mss) = 1200; static VNET_DEFINE(int, tcp_pmtud_blackhole_mss) = 1200;
#define V_tcp_pmtud_blackhole_mss VNET(tcp_pmtud_blackhole_mss) #define V_tcp_pmtud_blackhole_mss VNET(tcp_pmtud_blackhole_mss)
SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_mss, SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_mss,
CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_VNET, CTLFLAG_RW|CTLFLAG_VNET,
&VNET_NAME(tcp_pmtud_blackhole_mss), 0, &VNET_NAME(tcp_pmtud_blackhole_mss), 0,
"Path MTU Discovery Black Hole Detection lowered MSS"); "Path MTU Discovery Black Hole Detection lowered MSS");
#endif #endif
@ -173,7 +173,7 @@ SYSCTL_INT(_net_inet_tcp, OID_AUTO, pmtud_blackhole_mss,
static VNET_DEFINE(int, tcp_v6pmtud_blackhole_mss) = 1220; static VNET_DEFINE(int, tcp_v6pmtud_blackhole_mss) = 1220;
#define V_tcp_v6pmtud_blackhole_mss VNET(tcp_v6pmtud_blackhole_mss) #define V_tcp_v6pmtud_blackhole_mss VNET(tcp_v6pmtud_blackhole_mss)
SYSCTL_INT(_net_inet_tcp, OID_AUTO, v6pmtud_blackhole_mss, SYSCTL_INT(_net_inet_tcp, OID_AUTO, v6pmtud_blackhole_mss,
CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_VNET, CTLFLAG_RW|CTLFLAG_VNET,
&VNET_NAME(tcp_v6pmtud_blackhole_mss), 0, &VNET_NAME(tcp_v6pmtud_blackhole_mss), 0,
"Path MTU Discovery IPv6 Black Hole Detection lowered MSS"); "Path MTU Discovery IPv6 Black Hole Detection lowered MSS");
#endif #endif

View File

@ -86,7 +86,7 @@ struct secpolicy {
u_int state; /* 0: dead, others: alive */ u_int state; /* 0: dead, others: alive */
#define IPSEC_SPSTATE_DEAD 0 #define IPSEC_SPSTATE_DEAD 0
#define IPSEC_SPSTATE_ALIVE 1 #define IPSEC_SPSTATE_ALIVE 1
u_int16_t policy; /* policy_type per pfkeyv2.h */ u_int policy; /* policy_type per pfkeyv2.h */
u_int16_t scangen; /* scan generation # */ u_int16_t scangen; /* scan generation # */
struct ipsecrequest *req; struct ipsecrequest *req;
/* pointer to the ipsec request tree, */ /* pointer to the ipsec request tree, */

View File

@ -359,9 +359,9 @@ u_long pf_srchashmask;
static u_long pf_hashsize; static u_long pf_hashsize;
static u_long pf_srchashsize; static u_long pf_srchashsize;
SYSCTL_UINT(_net_pf, OID_AUTO, states_hashsize, CTLFLAG_RDTUN, SYSCTL_ULONG(_net_pf, OID_AUTO, states_hashsize, CTLFLAG_RDTUN,
&pf_hashsize, 0, "Size of pf(4) states hashtable"); &pf_hashsize, 0, "Size of pf(4) states hashtable");
SYSCTL_UINT(_net_pf, OID_AUTO, source_nodes_hashsize, CTLFLAG_RDTUN, SYSCTL_ULONG(_net_pf, OID_AUTO, source_nodes_hashsize, CTLFLAG_RDTUN,
&pf_srchashsize, 0, "Size of pf(4) source nodes hashtable"); &pf_srchashsize, 0, "Size of pf(4) source nodes hashtable");
VNET_DEFINE(void *, pf_swi_cookie); VNET_DEFINE(void *, pf_swi_cookie);

View File

@ -555,11 +555,11 @@ struct mlx4_en_priv {
u16 tx_usecs; u16 tx_usecs;
u16 tx_frames; u16 tx_frames;
u32 pkt_rate_low; u32 pkt_rate_low;
u16 rx_usecs_low; u32 rx_usecs_low;
u32 pkt_rate_high; u32 pkt_rate_high;
u16 rx_usecs_high; u32 rx_usecs_high;
u16 sample_interval; u32 sample_interval;
u16 adaptive_rx_coal; u32 adaptive_rx_coal;
u32 msg_enable; u32 msg_enable;
u32 loopback_ok; u32 loopback_ok;
u32 validate_loopback; u32 validate_loopback;

View File

@ -621,13 +621,13 @@ fcu_attach_fans(device_t dev)
OID_AUTO, sysctl_name, OID_AUTO, sysctl_name,
CTLFLAG_RD, 0, "Fan Information"); CTLFLAG_RD, 0, "Fan Information");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"minrpm", CTLTYPE_INT | CTLFLAG_RD, "minrpm", CTLFLAG_RD,
&(sc->sc_fans[i].fan.min_rpm), &(sc->sc_fans[i].fan.min_rpm), 0,
sizeof(int), "Minimum allowed RPM"); "Minimum allowed RPM");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"maxrpm", CTLTYPE_INT | CTLFLAG_RD, "maxrpm", CTLFLAG_RD,
&(sc->sc_fans[i].fan.max_rpm), &(sc->sc_fans[i].fan.max_rpm), 0,
sizeof(int), "Maximum allowed RPM"); "Maximum allowed RPM");
/* I use i to pass the fan id. */ /* I use i to pass the fan id. */
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"rpm", CTLTYPE_INT | CTLFLAG_RW, dev, i, "rpm", CTLTYPE_INT | CTLFLAG_RW, dev, i,
@ -641,13 +641,13 @@ fcu_attach_fans(device_t dev)
OID_AUTO, sysctl_name, OID_AUTO, sysctl_name,
CTLFLAG_RD, 0, "Fan Information"); CTLFLAG_RD, 0, "Fan Information");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"minpwm", CTLTYPE_INT | CTLFLAG_RD, "minpwm", CTLFLAG_RD,
&(sc->sc_fans[i].fan.min_rpm), &(sc->sc_fans[i].fan.min_rpm), 0,
sizeof(int), "Minimum allowed PWM in %"); "Minimum allowed PWM in %");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"maxpwm", CTLTYPE_INT | CTLFLAG_RD, "maxpwm", CTLFLAG_RD,
&(sc->sc_fans[i].fan.max_rpm), &(sc->sc_fans[i].fan.max_rpm), 0,
sizeof(int), "Maximum allowed PWM in %"); "Maximum allowed PWM in %");
/* I use i to pass the fan id or'ed with the type /* I use i to pass the fan id or'ed with the type
* of info I want to display/modify. * of info I want to display/modify.
*/ */

View File

@ -1033,12 +1033,12 @@ smu_attach_fans(device_t dev, phandle_t fanroot)
OID_AUTO, sysctl_name, OID_AUTO, sysctl_name,
CTLFLAG_RD, 0, "Fan Information"); CTLFLAG_RD, 0, "Fan Information");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"minrpm", CTLTYPE_INT | CTLFLAG_RD, "minrpm", CTLFLAG_RD,
&fan->fan.min_rpm, sizeof(int), &fan->fan.min_rpm, 0,
"Minimum allowed RPM"); "Minimum allowed RPM");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"maxrpm", CTLTYPE_INT | CTLFLAG_RD, "maxrpm", CTLFLAG_RD,
&fan->fan.max_rpm, sizeof(int), &fan->fan.max_rpm, 0,
"Maximum allowed RPM"); "Maximum allowed RPM");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"rpm",CTLTYPE_INT | CTLFLAG_RW | "rpm",CTLTYPE_INT | CTLFLAG_RW |
@ -1054,12 +1054,12 @@ smu_attach_fans(device_t dev, phandle_t fanroot)
OID_AUTO, sysctl_name, OID_AUTO, sysctl_name,
CTLFLAG_RD, 0, "Fan Information"); CTLFLAG_RD, 0, "Fan Information");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"minpwm", CTLTYPE_INT | CTLFLAG_RD, "minpwm", CTLFLAG_RD,
&fan->fan.min_rpm, sizeof(int), &fan->fan.min_rpm, 0,
"Minimum allowed PWM in %"); "Minimum allowed PWM in %");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"maxpwm", CTLTYPE_INT | CTLFLAG_RD, "maxpwm", CTLFLAG_RD,
&fan->fan.max_rpm, sizeof(int), &fan->fan.max_rpm, 0,
"Maximum allowed PWM in %"); "Maximum allowed PWM in %");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"pwm",CTLTYPE_INT | CTLFLAG_RW | "pwm",CTLTYPE_INT | CTLFLAG_RW |

View File

@ -191,7 +191,7 @@ static char model[64];
SYSCTL_STRING(_hw, HW_MODEL, model, CTLFLAG_RD, model, 0, ""); SYSCTL_STRING(_hw, HW_MODEL, model, CTLFLAG_RD, model, 0, "");
int cpu_features = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU; int cpu_features = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU;
SYSCTL_OPAQUE(_hw, OID_AUTO, cpu_features, CTLTYPE_INT | CTLFLAG_RD, SYSCTL_OPAQUE(_hw, OID_AUTO, cpu_features, CTLFLAG_RD,
&cpu_features, sizeof(cpu_features), "IX", "PowerPC CPU features"); &cpu_features, sizeof(cpu_features), "IX", "PowerPC CPU features");
/* Provide some user-friendly aliases for bits in cpu_features */ /* Provide some user-friendly aliases for bits in cpu_features */

View File

@ -226,53 +226,6 @@ TAILQ_HEAD(sysctl_ctx_list, sysctl_ctx_entry);
#define SYSCTL_NODE_CHILDREN(parent, name) \ #define SYSCTL_NODE_CHILDREN(parent, name) \
sysctl__##parent##_##name.oid_children sysctl__##parent##_##name.oid_children
/*
* These macros provide type safety for sysctls. SYSCTL_ALLOWED_TYPES()
* defines a transparent union of the allowed types. SYSCTL_ASSERT_TYPE()
* and SYSCTL_ADD_ASSERT_TYPE() use the transparent union to assert that
* the pointer matches the allowed types.
*
* The allow_0 member allows a literal 0 to be passed for ptr.
*/
#define SYSCTL_ALLOWED_TYPES(type, decls) \
union sysctl_##type { \
long allow_0; \
decls \
} __attribute__((__transparent_union__)); \
\
static inline void * \
__sysctl_assert_##type(union sysctl_##type ptr) \
{ \
return (ptr.a); \
} \
struct __hack
SYSCTL_ALLOWED_TYPES(INT, int *a; );
SYSCTL_ALLOWED_TYPES(UINT, unsigned int *a; );
SYSCTL_ALLOWED_TYPES(LONG, long *a; );
SYSCTL_ALLOWED_TYPES(ULONG, unsigned long *a; );
SYSCTL_ALLOWED_TYPES(INT64, int64_t *a; long long *b; );
SYSCTL_ALLOWED_TYPES(UINT64, uint64_t *a; unsigned long long *b; );
#ifdef notyet
#define SYSCTL_ADD_ASSERT_TYPE(type, ptr) \
__sysctl_assert_ ## type (ptr)
#define SYSCTL_ASSERT_TYPE(type, ptr, parent, name) \
_SYSCTL_ASSERT_TYPE(type, ptr, __LINE__, parent##_##name)
#else
#define SYSCTL_ADD_ASSERT_TYPE(type, ptr) ptr
#define SYSCTL_ASSERT_TYPE(type, ptr, parent, name)
#endif
#define _SYSCTL_ASSERT_TYPE(t, p, l, id) \
__SYSCTL_ASSERT_TYPE(t, p, l, id)
#define __SYSCTL_ASSERT_TYPE(type, ptr, line, id) \
static inline void \
sysctl_assert_##line##_##id(void) \
{ \
(void)__sysctl_assert_##type(ptr); \
} \
struct __hack
#ifndef NO_SYSCTL_DESCR #ifndef NO_SYSCTL_DESCR
#define __DESCR(d) d #define __DESCR(d) d
#else #else
@ -313,173 +266,263 @@ SYSCTL_ALLOWED_TYPES(UINT64, uint64_t *a; unsigned long long *b; );
/* This constructs a root node from which other nodes can hang. */ /* This constructs a root node from which other nodes can hang. */
#define SYSCTL_ROOT_NODE(nbr, name, access, handler, descr) \ #define SYSCTL_ROOT_NODE(nbr, name, access, handler, descr) \
SYSCTL_OID_RAW(sysctl___##name, &sysctl__children, \ SYSCTL_OID_RAW(sysctl___##name, &sysctl__children, \
nbr, #name, CTLTYPE_NODE|(access), NULL, 0, \ nbr, #name, CTLTYPE_NODE|(access), NULL, 0, \
handler, "N", descr) handler, "N", descr); \
CTASSERT(((access) & CTLTYPE) == 0)
/* This constructs a node from which other oids can hang. */ /* This constructs a node from which other oids can hang. */
#define SYSCTL_NODE(parent, nbr, name, access, handler, descr) \ #define SYSCTL_NODE(parent, nbr, name, access, handler, descr) \
SYSCTL_OID_GLOBAL(parent, nbr, name, CTLTYPE_NODE|(access), \ SYSCTL_OID_GLOBAL(parent, nbr, name, CTLTYPE_NODE|(access), \
NULL, 0, handler, "N", descr) NULL, 0, handler, "N", descr); \
CTASSERT(((access) & CTLTYPE) == 0)
#define SYSCTL_ADD_NODE(ctx, parent, nbr, name, access, handler, descr) \ #define SYSCTL_ADD_NODE(ctx, parent, nbr, name, access, handler, descr) \
sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_NODE|(access), \ ({ \
NULL, 0, handler, "N", __DESCR(descr)) CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_NODE|(access), \
NULL, 0, handler, "N", __DESCR(descr)); \
})
#define SYSCTL_ADD_ROOT_NODE(ctx, nbr, name, access, handler, descr) \ #define SYSCTL_ADD_ROOT_NODE(ctx, nbr, name, access, handler, descr) \
({ \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, &sysctl__children, nbr, name, \ sysctl_add_oid(ctx, &sysctl__children, nbr, name, \
CTLTYPE_NODE|(access), NULL, 0, handler, "N", __DESCR(descr)) CTLTYPE_NODE|(access), \
NULL, 0, handler, "N", __DESCR(descr)); \
})
/* Oid for a string. len can be 0 to indicate '\0' termination. */ /* Oid for a string. len can be 0 to indicate '\0' termination. */
#define SYSCTL_STRING(parent, nbr, name, access, arg, len, descr) \ #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|(access), \
arg, len, sysctl_handle_string, "A", descr) arg, len, sysctl_handle_string, "A", descr); \
CTASSERT(((access) & CTLTYPE) == 0)
#define SYSCTL_ADD_STRING(ctx, parent, nbr, name, access, arg, len, descr) \ #define SYSCTL_ADD_STRING(ctx, parent, nbr, name, access, arg, len, descr) \
sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_STRING|(access), \ ({ \
arg, len, sysctl_handle_string, "A", __DESCR(descr)) char *__arg = (arg); \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_STRING|(access), \
__arg, len, sysctl_handle_string, "A", __DESCR(descr)); \
})
/* Oid for an int. If ptr is NULL, val is returned. */ /* Oid for an int. If ptr is SYSCTL_NULL_INT_PTR, val is returned. */
#define SYSCTL_INT(parent, nbr, name, access, ptr, val, descr) \ #define SYSCTL_NULL_INT_PTR ((int *)NULL)
SYSCTL_ASSERT_TYPE(INT, ptr, parent, name); \ #define SYSCTL_INT(parent, nbr, name, access, ptr, val, descr) \
SYSCTL_OID(parent, nbr, name, \ SYSCTL_OID(parent, nbr, name, \
CTLTYPE_INT | CTLFLAG_MPSAFE | (access), \ CTLTYPE_INT | CTLFLAG_MPSAFE | (access), \
ptr, val, sysctl_handle_int, "I", descr) ptr, val, sysctl_handle_int, "I", descr); \
CTASSERT(((access) & CTLTYPE) == 0); \
CTASSERT(sizeof(int) == sizeof(*(ptr)))
#define SYSCTL_ADD_INT(ctx, parent, nbr, name, access, ptr, val, descr) \ #define SYSCTL_ADD_INT(ctx, parent, nbr, name, access, ptr, val, descr) \
({ \
int *__ptr = (ptr); \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, \ sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_INT | CTLFLAG_MPSAFE | (access), \ CTLTYPE_INT | CTLFLAG_MPSAFE | (access), \
SYSCTL_ADD_ASSERT_TYPE(INT, ptr), val, \ __ptr, val, sysctl_handle_int, "I", __DESCR(descr)); \
sysctl_handle_int, "I", __DESCR(descr)) })
/* Oid for an unsigned int. If ptr is NULL, val is returned. */ /* Oid for an unsigned int. If ptr is NULL, val is returned. */
#define SYSCTL_UINT(parent, nbr, name, access, ptr, val, descr) \ #define SYSCTL_NULL_UINT_PTR ((unsigned *)NULL)
SYSCTL_ASSERT_TYPE(UINT, ptr, parent, name); \ #define SYSCTL_UINT(parent, nbr, name, access, ptr, val, descr) \
SYSCTL_OID(parent, nbr, name, \ SYSCTL_OID(parent, nbr, name, \
CTLTYPE_UINT | CTLFLAG_MPSAFE | (access), \ CTLTYPE_UINT | CTLFLAG_MPSAFE | (access), \
ptr, val, sysctl_handle_int, "IU", descr) ptr, val, sysctl_handle_int, "IU", descr); \
CTASSERT(((access) & CTLTYPE) == 0); \
CTASSERT(sizeof(unsigned) == sizeof(*(ptr)))
#define SYSCTL_ADD_UINT(ctx, parent, nbr, name, access, ptr, val, descr) \ #define SYSCTL_ADD_UINT(ctx, parent, nbr, name, access, ptr, val, descr) \
({ \
unsigned *__ptr = (ptr); \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, \ sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_UINT | CTLFLAG_MPSAFE | (access), \ CTLTYPE_UINT | CTLFLAG_MPSAFE | (access), \
SYSCTL_ADD_ASSERT_TYPE(UINT, ptr), val, \ __ptr, val, sysctl_handle_int, "IU", __DESCR(descr)); \
sysctl_handle_int, "IU", __DESCR(descr)) })
/* Oid for a long. The pointer must be non NULL. */ /* Oid for a long. The pointer must be non NULL. */
#define SYSCTL_LONG(parent, nbr, name, access, ptr, val, descr) \ #define SYSCTL_NULL_LONG_PTR ((long *)NULL)
SYSCTL_ASSERT_TYPE(LONG, ptr, parent, name); \ #define SYSCTL_LONG(parent, nbr, name, access, ptr, val, descr) \
SYSCTL_OID(parent, nbr, name, \ SYSCTL_OID(parent, nbr, name, \
CTLTYPE_LONG | CTLFLAG_MPSAFE | (access), \ CTLTYPE_LONG | CTLFLAG_MPSAFE | (access), \
ptr, val, sysctl_handle_long, "L", descr) ptr, val, sysctl_handle_long, "L", descr); \
CTASSERT(((access) & CTLTYPE) == 0); \
CTASSERT(sizeof(long) == sizeof(*(ptr)))
#define SYSCTL_ADD_LONG(ctx, parent, nbr, name, access, ptr, descr) \ #define SYSCTL_ADD_LONG(ctx, parent, nbr, name, access, ptr, descr) \
({ \
long *__ptr = (ptr); \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, \ sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_LONG | CTLFLAG_MPSAFE | (access), \ CTLTYPE_LONG | CTLFLAG_MPSAFE | (access), \
SYSCTL_ADD_ASSERT_TYPE(LONG, ptr), 0, \ __ptr, 0, sysctl_handle_long, "L", __DESCR(descr)); \
sysctl_handle_long, "L", __DESCR(descr)) })
/* Oid for an unsigned long. The pointer must be non NULL. */ /* Oid for an unsigned long. The pointer must be non NULL. */
#define SYSCTL_NULL_ULONG_PTR ((unsigned long *)NULL)
#define SYSCTL_ULONG(parent, nbr, name, access, ptr, val, descr) \ #define SYSCTL_ULONG(parent, nbr, name, access, ptr, val, descr) \
SYSCTL_ASSERT_TYPE(ULONG, ptr, parent, name); \
SYSCTL_OID(parent, nbr, name, \ SYSCTL_OID(parent, nbr, name, \
CTLTYPE_ULONG | CTLFLAG_MPSAFE | (access), \ CTLTYPE_ULONG | CTLFLAG_MPSAFE | (access), \
ptr, val, sysctl_handle_long, "LU", descr) ptr, val, sysctl_handle_long, "LU", descr); \
CTASSERT(((access) & CTLTYPE) == 0); \
CTASSERT(sizeof(unsigned long) == sizeof(*(ptr)))
#define SYSCTL_ADD_ULONG(ctx, parent, nbr, name, access, ptr, descr) \ #define SYSCTL_ADD_ULONG(ctx, parent, nbr, name, access, ptr, descr) \
({ \
unsigned long *__ptr = (ptr); \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, \ sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_ULONG | CTLFLAG_MPSAFE | (access), \ CTLTYPE_ULONG | CTLFLAG_MPSAFE | (access), \
SYSCTL_ADD_ASSERT_TYPE(ULONG, ptr), 0, \ __ptr, 0, sysctl_handle_long, "LU", __DESCR(descr)); \
sysctl_handle_long, "LU", __DESCR(descr)) })
/* Oid for a quad. The pointer must be non NULL. */ /* Oid for a quad. The pointer must be non NULL. */
#define SYSCTL_QUAD(parent, nbr, name, access, ptr, val, descr) \ #define SYSCTL_NULL_QUAD_PTR ((int64_T *)NULL)
SYSCTL_ASSERT_TYPE(INT64, ptr, parent, name); \ #define SYSCTL_QUAD(parent, nbr, name, access, ptr, val, descr) \
SYSCTL_OID(parent, nbr, name, \ SYSCTL_OID(parent, nbr, name, \
CTLTYPE_S64 | CTLFLAG_MPSAFE | (access), \ CTLTYPE_S64 | CTLFLAG_MPSAFE | (access), \
ptr, val, sysctl_handle_64, "Q", descr) ptr, val, sysctl_handle_64, "Q", descr); \
CTASSERT(((access) & CTLTYPE) == 0); \
CTASSERT(sizeof(int64_t) == sizeof(*(ptr)))
#define SYSCTL_ADD_QUAD(ctx, parent, nbr, name, access, ptr, descr) \ #define SYSCTL_ADD_QUAD(ctx, parent, nbr, name, access, ptr, descr) \
({ \
int64_t *__ptr = (ptr); \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, \ sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_S64 | CTLFLAG_MPSAFE | (access), \ CTLTYPE_S64 | CTLFLAG_MPSAFE | (access), \
SYSCTL_ADD_ASSERT_TYPE(INT64, ptr), 0, \ __ptr, 0, sysctl_handle_64, "Q", __DESCR(descr)); \
sysctl_handle_64, "Q", __DESCR(descr)) })
#define SYSCTL_NULL_UQUAD_PTR ((uint64_t *)NULL)
#define SYSCTL_UQUAD(parent, nbr, name, access, ptr, val, descr) \ #define SYSCTL_UQUAD(parent, nbr, name, access, ptr, val, descr) \
SYSCTL_ASSERT_TYPE(UINT64, ptr, parent, name); \
SYSCTL_OID(parent, nbr, name, \ SYSCTL_OID(parent, nbr, name, \
CTLTYPE_U64 | CTLFLAG_MPSAFE | (access), \ CTLTYPE_U64 | CTLFLAG_MPSAFE | (access), \
ptr, val, sysctl_handle_64, "QU", descr) ptr, val, sysctl_handle_64, "QU", descr); \
CTASSERT(((access) & CTLTYPE) == 0); \
CTASSERT(sizeof(uint64_t) == sizeof(*(ptr)))
#define SYSCTL_ADD_UQUAD(ctx, parent, nbr, name, access, ptr, descr) \ #define SYSCTL_ADD_UQUAD(ctx, parent, nbr, name, access, ptr, descr) \
({ \
uint64_t *__ptr = (ptr); \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, \ sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_U64 | CTLFLAG_MPSAFE | (access), \ CTLTYPE_U64 | CTLFLAG_MPSAFE | (access), \
SYSCTL_ADD_ASSERT_TYPE(UINT64, ptr), 0, \ __ptr, 0, sysctl_handle_64, "QU", __DESCR(descr)); \
sysctl_handle_64, "QU", __DESCR(descr)) })
/* Oid for a CPU dependant variable */
#define SYSCTL_ADD_UAUTO(ctx, parent, nbr, name, access, ptr, descr) \
({ \
struct sysctl_oid *__ret; \
CTASSERT(sizeof(uint64_t) == sizeof(*(ptr)) || \
sizeof(unsigned) == sizeof(*(ptr))); \
CTASSERT(((access) & CTLTYPE) == 0); \
if (sizeof(uint64_t) == sizeof(*(ptr))) { \
__ret = sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_U64 | CTLFLAG_MPSAFE | (access), \
(ptr), 0, sysctl_handle_64, "QU", \
__DESCR(descr)); \
} else { \
__ret = sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_UINT | CTLFLAG_MPSAFE | (access), \
(ptr), 0, sysctl_handle_int, "IU", \
__DESCR(descr)); \
} \
__ret; \
})
/* Oid for a 64-bit unsigned counter(9). The pointer must be non NULL. */ /* Oid for a 64-bit unsigned counter(9). The pointer must be non NULL. */
#define SYSCTL_COUNTER_U64(parent, nbr, name, access, ptr, descr) \ #define SYSCTL_COUNTER_U64(parent, nbr, name, access, ptr, descr) \
SYSCTL_ASSERT_TYPE(UINT64, ptr, parent, name); \
SYSCTL_OID(parent, nbr, name, \ SYSCTL_OID(parent, nbr, name, \
CTLTYPE_U64 | CTLFLAG_MPSAFE | (access), \ CTLTYPE_U64 | CTLFLAG_MPSAFE | (access), \
ptr, 0, sysctl_handle_counter_u64, "QU", descr) (ptr), 0, sysctl_handle_counter_u64, "QU", descr); \
CTASSERT(((access) & CTLTYPE) == 0); \
CTASSERT(sizeof(counter_u64_t) == sizeof(*(ptr))); \
CTASSERT(sizeof(uint64_t) == sizeof(**(ptr)))
#define SYSCTL_ADD_COUNTER_U64(ctx, parent, nbr, name, access, ptr, descr)\ #define SYSCTL_ADD_COUNTER_U64(ctx, parent, nbr, name, access, ptr, descr) \
({ \
counter_u64_t *__ptr = (ptr); \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, \ sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_U64 | CTLFLAG_MPSAFE | (access), \ CTLTYPE_U64 | CTLFLAG_MPSAFE | (access), \
SYSCTL_ADD_ASSERT_TYPE(UINT64, ptr), 0, \ __ptr, 0, sysctl_handle_counter_u64, "QU", __DESCR(descr)); \
sysctl_handle_counter_u64, "QU", __DESCR(descr)) })
/* Oid for an opaque object. Specified by a pointer and a length. */ /* Oid for an opaque object. Specified by a pointer and a length. */
#define SYSCTL_OPAQUE(parent, nbr, name, access, ptr, len, fmt, descr) \ #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|(access), \
ptr, len, sysctl_handle_opaque, fmt, descr) ptr, len, sysctl_handle_opaque, fmt, descr); \
CTASSERT(((access) & CTLTYPE) == 0)
#define SYSCTL_ADD_OPAQUE(ctx, parent, nbr, name, access, ptr, len, fmt, descr)\ #define SYSCTL_ADD_OPAQUE(ctx, parent, nbr, name, access, ptr, len, fmt, descr) \
sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_OPAQUE|(access), \ ({ \
ptr, len, sysctl_handle_opaque, fmt, __DESCR(descr)) CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_OPAQUE|(access), \
ptr, len, sysctl_handle_opaque, fmt, __DESCR(descr)); \
})
/* Oid for a struct. Specified by a pointer and a type. */ /* Oid for a struct. Specified by a pointer and a type. */
#define SYSCTL_STRUCT(parent, nbr, name, access, ptr, type, descr) \ #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|(access), \
ptr, sizeof(struct type), sysctl_handle_opaque, \ ptr, sizeof(struct type), sysctl_handle_opaque, \
"S," #type, descr) "S," #type, descr); \
CTASSERT(((access) & CTLTYPE) == 0)
#define SYSCTL_ADD_STRUCT(ctx, parent, nbr, name, access, ptr, type, descr) \ #define SYSCTL_ADD_STRUCT(ctx, parent, nbr, name, access, ptr, type, descr) \
sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_OPAQUE|(access), \ ({ \
ptr, sizeof(struct type), sysctl_handle_opaque, "S," #type, __DESCR(descr)) CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_OPAQUE|(access), \
(ptr), sizeof(struct type), \
sysctl_handle_opaque, "S," #type, __DESCR(descr)); \
})
/* Oid for a procedure. Specified by a pointer and an arg. */ /* Oid for a procedure. Specified by a pointer and an arg. */
#define SYSCTL_PROC(parent, nbr, name, access, ptr, arg, handler, fmt, descr) \ #define SYSCTL_PROC(parent, nbr, name, access, ptr, arg, handler, fmt, descr) \
CTASSERT(((access) & CTLTYPE) != 0); \ SYSCTL_OID(parent, nbr, name, (access), \
SYSCTL_OID(parent, nbr, name, (access), \ ptr, arg, handler, fmt, descr); \
ptr, arg, handler, fmt, descr) CTASSERT(((access) & CTLTYPE) != 0)
#define SYSCTL_ADD_PROC(ctx, parent, nbr, name, access, ptr, arg, handler, fmt, descr) \ #define SYSCTL_ADD_PROC(ctx, parent, nbr, name, access, ptr, arg, handler, fmt, descr) \
sysctl_add_oid(ctx, parent, nbr, name, (access), \ ({ \
ptr, arg, handler, fmt, __DESCR(descr)) CTASSERT(((access) & CTLTYPE) != 0); \
sysctl_add_oid(ctx, parent, nbr, name, (access), \
(ptr), (arg), (handler), (fmt), __DESCR(descr)); \
})
/* Oid to handle limits on uma(9) zone specified by pointer. */ /* Oid to handle limits on uma(9) zone specified by pointer. */
#define SYSCTL_UMA_MAX(parent, nbr, name, access, ptr, descr) \ #define SYSCTL_UMA_MAX(parent, nbr, name, access, ptr, descr) \
SYSCTL_ASSERT_TYPE(INT, ptr, parent, name); \ SYSCTL_OID(parent, nbr, name, \
SYSCTL_OID(parent, nbr, name, \ CTLTYPE_INT | CTLFLAG_MPSAFE | (access), \
CTLTYPE_INT | CTLFLAG_MPSAFE | (access), \ (ptr), 0, sysctl_handle_uma_zone_max, "I", descr); \
ptr, 0, sysctl_handle_uma_zone_max, "I", descr) CTASSERT(((access) & CTLTYPE) == 0)
#define SYSCTL_ADD_UMA_MAX(ctx, parent, nbr, name, access, ptr, descr)\
#define SYSCTL_ADD_UMA_MAX(ctx, parent, nbr, name, access, ptr, descr) \
({ \
uma_zone_t __ptr = (ptr); \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, \ sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_INT | CTLFLAG_MPSAFE | (access), \ CTLTYPE_INT | CTLFLAG_MPSAFE | (access), \
SYSCTL_ADD_ASSERT_TYPE(INT, ptr), 0, \ __ptr, 0, sysctl_handle_uma_zone_max, "I", __DESCR(descr)); \
sysctl_handle_uma_zone_max, "I", __DESCR(descr)) })
/* Oid to obtain current use of uma(9) zone specified by pointer. */ /* Oid to obtain current use of uma(9) zone specified by pointer. */
#define SYSCTL_UMA_CUR(parent, nbr, name, access, ptr, descr) \ #define SYSCTL_UMA_CUR(parent, nbr, name, access, ptr, descr) \
SYSCTL_ASSERT_TYPE(INT, ptr, parent, name); \
SYSCTL_OID(parent, nbr, name, \ SYSCTL_OID(parent, nbr, name, \
CTLTYPE_INT | CTLFLAG_MPSAFE | CTLFLAG_RD | (access), \ CTLTYPE_INT | CTLFLAG_MPSAFE | CTLFLAG_RD | (access), \
ptr, 0, sysctl_handle_uma_zone_cur, "I", descr) (ptr), 0, sysctl_handle_uma_zone_cur, "I", descr); \
CTASSERT(((access) & CTLTYPE) == 0)
#define SYSCTL_ADD_UMA_CUR(ctx, parent, nbr, name, access, ptr, descr) \ #define SYSCTL_ADD_UMA_CUR(ctx, parent, nbr, name, access, ptr, descr) \
({ \
uma_zone_t __ptr = (ptr); \
CTASSERT(((access) & CTLTYPE) == 0); \
sysctl_add_oid(ctx, parent, nbr, name, \ sysctl_add_oid(ctx, parent, nbr, name, \
CTLTYPE_INT | CTLFLAG_MPSAFE | CTLFLAG_RD | (access), \ CTLTYPE_INT | CTLFLAG_MPSAFE | CTLFLAG_RD | (access), \
SYSCTL_ADD_ASSERT_TYPE(INT, ptr), 0, \ __ptr, 0, sysctl_handle_uma_zone_cur, "I", __DESCR(descr)); \
sysctl_handle_uma_zone_cur, "I", __DESCR(descr)) })
/* /*
* A macro to generate a read-only sysctl to indicate the presense of optional * A macro to generate a read-only sysctl to indicate the presense of optional
@ -487,7 +530,7 @@ SYSCTL_ALLOWED_TYPES(UINT64, uint64_t *a; unsigned long long *b; );
*/ */
#define FEATURE(name, desc) \ #define FEATURE(name, desc) \
SYSCTL_INT(_kern_features, OID_AUTO, name, CTLFLAG_RD | CTLFLAG_CAPRD, \ SYSCTL_INT(_kern_features, OID_AUTO, name, CTLFLAG_RD | CTLFLAG_CAPRD, \
NULL, 1, desc) SYSCTL_NULL_INT_PTR, 1, desc)
#endif /* _KERNEL */ #endif /* _KERNEL */

View File

@ -226,9 +226,9 @@ memguard_sysinit(void)
parent = SYSCTL_STATIC_CHILDREN(_vm_memguard); parent = SYSCTL_STATIC_CHILDREN(_vm_memguard);
SYSCTL_ADD_ULONG(NULL, parent, OID_AUTO, "mapstart", CTLFLAG_RD, SYSCTL_ADD_UAUTO(NULL, parent, OID_AUTO, "mapstart", CTLFLAG_RD,
&memguard_base, "MemGuard KVA base"); &memguard_base, "MemGuard KVA base");
SYSCTL_ADD_ULONG(NULL, parent, OID_AUTO, "maplimit", CTLFLAG_RD, SYSCTL_ADD_UAUTO(NULL, parent, OID_AUTO, "maplimit", CTLFLAG_RD,
&memguard_mapsize, "MemGuard KVA size"); &memguard_mapsize, "MemGuard KVA size");
#if 0 #if 0
SYSCTL_ADD_ULONG(NULL, parent, OID_AUTO, "mapused", CTLFLAG_RD, SYSCTL_ADD_ULONG(NULL, parent, OID_AUTO, "mapused", CTLFLAG_RD,

View File

@ -95,13 +95,13 @@ const void *zero_region;
CTASSERT((ZERO_REGION_SIZE & PAGE_MASK) == 0); CTASSERT((ZERO_REGION_SIZE & PAGE_MASK) == 0);
SYSCTL_ULONG(_vm, OID_AUTO, min_kernel_address, CTLFLAG_RD, SYSCTL_ULONG(_vm, OID_AUTO, min_kernel_address, CTLFLAG_RD,
NULL, VM_MIN_KERNEL_ADDRESS, "Min kernel address"); SYSCTL_NULL_ULONG_PTR, VM_MIN_KERNEL_ADDRESS, "Min kernel address");
SYSCTL_ULONG(_vm, OID_AUTO, max_kernel_address, CTLFLAG_RD, SYSCTL_ULONG(_vm, OID_AUTO, max_kernel_address, CTLFLAG_RD,
#if defined(__arm__) || defined(__sparc64__) #if defined(__arm__) || defined(__sparc64__)
&vm_max_kernel_address, 0, &vm_max_kernel_address, 0,
#else #else
NULL, VM_MAX_KERNEL_ADDRESS, SYSCTL_NULL_ULONG_PTR, VM_MAX_KERNEL_ADDRESS,
#endif #endif
"Max kernel address"); "Max kernel address");

View File

@ -831,13 +831,6 @@ busdma_sysctl_tree_top(struct bounce_zone *bz)
return (bz->sysctl_tree_top); return (bz->sysctl_tree_top);
} }
#if defined(__amd64__) || defined(PAE)
#define SYSCTL_ADD_BUS_SIZE_T SYSCTL_ADD_UQUAD
#else
#define SYSCTL_ADD_BUS_SIZE_T(ctx, parent, nbr, name, flag, ptr, desc) \
SYSCTL_ADD_UINT(ctx, parent, nbr, name, flag, ptr, 0, desc)
#endif
static int static int
alloc_bounce_zone(bus_dma_tag_t dmat) alloc_bounce_zone(bus_dma_tag_t dmat)
{ {
@ -905,7 +898,7 @@ alloc_bounce_zone(bus_dma_tag_t dmat)
SYSCTL_ADD_STRING(busdma_sysctl_tree(bz), SYSCTL_ADD_STRING(busdma_sysctl_tree(bz),
SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO, SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO,
"lowaddr", CTLFLAG_RD, bz->lowaddrid, 0, ""); "lowaddr", CTLFLAG_RD, bz->lowaddrid, 0, "");
SYSCTL_ADD_BUS_SIZE_T(busdma_sysctl_tree(bz), SYSCTL_ADD_UAUTO(busdma_sysctl_tree(bz),
SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO, SYSCTL_CHILDREN(busdma_sysctl_tree_top(bz)), OID_AUTO,
"alignment", CTLFLAG_RD, &bz->alignment, ""); "alignment", CTLFLAG_RD, &bz->alignment, "");