crypto/openssh/match.c

100

epsilon_closure(states, pattern, M);

crypto/openssh/match.c

107

if (!states[i])

crypto/openssh/match.c

128

tmp = states;

crypto/openssh/match.c

129

states = next_states;

crypto/openssh/match.c

135

if (states[i]) {

crypto/openssh/match.c

147

matched = states[M];

crypto/openssh/match.c

149

free(states);

crypto/openssh/match.c

61

epsilon_closure(char *states, const char *pattern, size_t M)

crypto/openssh/match.c

67

if (!states[i] || pattern[i] != '*')

crypto/openssh/match.c

73

states[i + 1] = 1;

crypto/openssh/match.c

86

char *states, *next_states, *tmp;

crypto/openssh/match.c

94

states = xcalloc(M + 1, sizeof(*states));

crypto/openssh/match.c

98

states[0] = 1;

lib/libc/regex/engine.c

107

static states step(struct re_guts *g, sopno start, sopno stop, states bef, wint_t ch, states aft, int sflags);

lib/libc/regex/engine.c

1133

states st,

lib/libc/regex/engine.c

123

static void print(struct match *m, const char *caption, states st, int ch, FILE *d);

lib/libc/regex/engine.c

845

states st = m->st;

lib/libc/regex/engine.c

846

states fresh = m->fresh;

lib/libc/regex/engine.c

847

states empty = m->empty;

lib/libc/regex/engine.c

848

states tmp = m->tmp;

lib/libc/regex/engine.c

90

states st; /* current states */

lib/libc/regex/engine.c

91

states fresh; /* states for a fresh start */

lib/libc/regex/engine.c

92

states tmp; /* temporary */

lib/libc/regex/engine.c

93

states empty; /* empty set of states */

lib/libc/regex/engine.c

992

static states

lib/libc/regex/engine.c

996

states bef, /* states reachable before */

lib/libc/regex/engine.c

998

states aft, /* states already known reachable after */

lib/libiconv_modules/BIG5/citrus_big5.c

108

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/DECHanyu/citrus_dechanyu.c

64

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.__CONCAT(s_,_func_)

lib/libiconv_modules/EUC/citrus_euc.c

102

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/EUCTW/citrus_euctw.c

94

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/GBK2K/citrus_gbk2k.c

65

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/HZ/citrus_hz.c

139

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/ISO2022/citrus_iso2022.c

127

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/JOHAB/citrus_johab.c

65

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/MSKanji/citrus_mskanji.c

99

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/UES/citrus_ues.c

61

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/UTF7/citrus_utf7.c

72

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/UTF8/citrus_utf8.c

121

#define _CEI_TO_STATE(_ei_, _func_) (_ei_)->states.s_##_func_

lib/libiconv_modules/VIQR/citrus_viqr.c

216

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libiconv_modules/ZW/citrus_zw.c

69

#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_

lib/libpfctl/libpfctl.c

2054

struct pfctl_states *states = (struct pfctl_states *)arg;

lib/libpfctl/libpfctl.c

2062

TAILQ_INSERT_TAIL(&states->states, new, entry);

lib/libpfctl/libpfctl.c

2068

pfctl_get_states(int dev __unused, struct pfctl_states *states)

lib/libpfctl/libpfctl.c

2072

bzero(states, sizeof(*states));

lib/libpfctl/libpfctl.c

2073

TAILQ_INIT(&states->states);

lib/libpfctl/libpfctl.c

2075

ret = pfctl_get_states_iter(pfctl_append_states, states);

lib/libpfctl/libpfctl.c

2077

pfctl_free_states(states);

lib/libpfctl/libpfctl.c

2085

pfctl_free_states(struct pfctl_states *states)

lib/libpfctl/libpfctl.c

2089

TAILQ_FOREACH_SAFE(s, &states->states, entry, tmp) {

lib/libpfctl/libpfctl.c

2093

bzero(states, sizeof(*states));

lib/libpfctl/libpfctl.c

3450

{ .type = PF_SN_STATES, .off = _OUT(states), .cb = snl_attr_get_uint32 },

lib/libpfctl/libpfctl.c

393

{ .type = PF_GS_STATES, .off = _OUT(states), .cb = snl_attr_get_uint32 },

lib/libpfctl/libpfctl.c

476

status->states = nvlist_get_number(nvl, "states");

lib/libpfctl/libpfctl.h

414

struct pfctl_statelist states;

lib/libpfctl/libpfctl.h

437

uint32_t states;

lib/libpfctl/libpfctl.h

514

int pfctl_get_states(int dev, struct pfctl_states *states);

lib/libpfctl/libpfctl.h

515

void pfctl_free_states(struct pfctl_states *states);

lib/libpfctl/libpfctl.h

54

uint64_t states;

sbin/pfctl/pf_print_state.c

321

const char *states[] = PFUDPS_NAMES;

sbin/pfctl/pf_print_state.c

323

printf(" %s:%s\n", states[src->state], states[dst->state]);

sbin/pfctl/pf_print_state.c

330

const char *states[] = PFOTHERS_NAMES;

sbin/pfctl/pf_print_state.c

332

printf(" %s:%s\n", states[src->state], states[dst->state]);

sbin/pfctl/pfctl_parser.c

597

printf(" %-25s %14ju %14s\n", "current entries", s->states, "");

sbin/pfctl/pfctl_parser.c

695

printf(" ( states %u, connections %u, rate %u.%u/%us )\n", sn->states,

sbin/pfctl/pfctl_parser.c

705

if (sn->states == 0) {

sys/compat/linuxkpi/common/src/linux_work.c

135

static const uint8_t states[WORK_ST_MAX] __aligned(8) = {

sys/compat/linuxkpi/common/src/linux_work.c

146

switch (linux_update_state(&work->state, states)) {

sys/compat/linuxkpi/common/src/linux_work.c

218

static const uint8_t states[WORK_ST_MAX] __aligned(8) = {

sys/compat/linuxkpi/common/src/linux_work.c

238

switch (linux_update_state(&dwork->work.state, states)) {

sys/compat/linuxkpi/common/src/linux_work.c

274

static const uint8_t states[WORK_ST_MAX] __aligned(8) = {

sys/compat/linuxkpi/common/src/linux_work.c

299

switch (linux_update_state(&work->state, states)) {

sys/compat/linuxkpi/common/src/linux_work.c

352

static const uint8_t states[WORK_ST_MAX] __aligned(8) = {

sys/compat/linuxkpi/common/src/linux_work.c

361

switch (linux_update_state(&dwork->work.state, states)) {

sys/compat/linuxkpi/common/src/linux_work.c

380

static const uint8_t states[WORK_ST_MAX] __aligned(8) = {

sys/compat/linuxkpi/common/src/linux_work.c

392

switch (linux_update_state(&work->state, states)) {

sys/compat/linuxkpi/common/src/linux_work.c

411

static const uint8_t states[WORK_ST_MAX] __aligned(8) = {

sys/compat/linuxkpi/common/src/linux_work.c

424

switch (linux_update_state(&work->state, states)) {

sys/compat/linuxkpi/common/src/linux_work.c

472

static const uint8_t states[WORK_ST_MAX] __aligned(8) = {

sys/compat/linuxkpi/common/src/linux_work.c

483

switch (linux_update_state(&dwork->work.state, states)) {

sys/compat/linuxkpi/common/src/linux_work.c

517

static const uint8_t states[WORK_ST_MAX] __aligned(8) = {

sys/compat/linuxkpi/common/src/linux_work.c

532

state = linux_update_state(&dwork->work.state, states);

sys/dev/ath/ath_hal/ah_internal.h

778

int states;

sys/dev/ath/ath_hal/ar5416/ar5416_misc.c

621

if (check->states & dcu_chain_state) {

sys/dev/ath/ath_hal/ar5416/ar5416_misc.c

635

if (check->states & dcu_complete_state) {

sys/dev/ath/ath_hal/ar5416/ar5416_misc.c

639

if (check->states & qcu_stitch_state) {

sys/dev/ath/ath_hal/ar5416/ar5416_misc.c

643

if (check->states & qcu_fetch_state) {

sys/dev/ath/ath_hal/ar5416/ar5416_misc.c

647

if (check->states & qcu_complete_state) {

sys/dev/ath/ath_hal/ar5416/ar5416_misc.c

651

return (found_states == check->states);

sys/dev/ath/ath_hal/ar5416/ar5416_misc.c

662

.states = dcu_chain_state

sys/dev/ath/ath_hal/ar5416/ar5416_misc.c

669

.states = qcu_stitch_state

sys/dev/cxgbe/iw_cxgbe/cm.c

1075

__func__, so, so->so_state, ep, states[ep->com.state],

sys/dev/cxgbe/iw_cxgbe/cm.c

1120

"ep %p ep_state %s", __func__, ep, states[state]);

sys/dev/cxgbe/iw_cxgbe/cm.c

1126

so->so_error, so->so_rcv.sb_state, ep, states[state]);

sys/dev/cxgbe/iw_cxgbe/cm.c

1200

ep, states[state]);

sys/dev/cxgbe/iw_cxgbe/cm.c

1641

states[ep->com.state], ep->hwtid);

sys/dev/cxgbe/iw_cxgbe/cm.c

168

static char *states[] = {

sys/dev/cxgbe/iw_cxgbe/cm.c

2214

CTR3(KTR_IW_CXGBE, "%s: ep %p, state %s", __func__, ep, states[state]);

sys/dev/cxgbe/iw_cxgbe/cm.c

2788

states[lep->com.state]);

sys/dev/cxgbe/iw_cxgbe/cm.c

2826

states[ep->com.state]);

sys/dev/cxgbe/iw_cxgbe/cm.c

2835

states[ep->com.state]);

sys/dev/cxgbe/iw_cxgbe/cm.c

480

__func__, epc->so, epc, states[epc->state], ep_events);

sys/dev/cxgbe/iw_cxgbe/cm.c

573

ep->com.so, states[ep->com.state]);

sys/dev/cxgbe/iw_cxgbe/cm.c

689

states[ep->com.state]);

sys/dev/cxgbe/iw_cxgbe/cm.c

760

ep->com.so, states[ep->com.state]);

sys/dev/cxgbe/iw_cxgbe/cm.c

876

ep->com.so, ep, states[ep->com.state], sbused(&ep->com.so->so_rcv));

sys/dev/dpms/dpms.c

132

int error, states;

sys/dev/dpms/dpms.c

134

error = dpms_get_supported_states(&states);

sys/dev/dpms/dpms.c

207

dpms_get_supported_states(int *states)

sys/dev/dpms/dpms.c

210

*states = 0;

sys/dev/dpms/dpms.c

211

return (dpms_call_bios(VBE_DPMS_GET_SUPPORTED_STATES, states));

sys/dev/gpio/gpioregulator.c

134

if (sc->def->states[n].val >= min_uvolt &&

sys/dev/gpio/gpioregulator.c

135

sc->def->states[n].val <= max_uvolt) {

sys/dev/gpio/gpioregulator.c

136

state = &sc->def->states[n];

sys/dev/gpio/gpioregulator.c

174

if (sc->def->states[n].mask == mask) {

sys/dev/gpio/gpioregulator.c

175

*uvolt = sc->def->states[n].val;

sys/dev/gpio/gpioregulator.c

221

sc->init_def.states = malloc(sc->init_def.nstates *

sys/dev/gpio/gpioregulator.c

222

sizeof(*sc->init_def.states), M_DEVBUF, M_WAITOK);

sys/dev/gpio/gpioregulator.c

224

sc->init_def.states[n].val = pstates[n * 2 + 0];

sys/dev/gpio/gpioregulator.c

225

sc->init_def.states[n].mask = pstates[n * 2 + 1];

sys/dev/gpio/gpioregulator.c

226

mask |= sc->init_def.states[n].mask;

sys/dev/gpio/gpioregulator.c

262

free(sc->init_def.states, M_DEVBUF);

sys/dev/gpio/gpioregulator.c

58

struct gpioregulator_state *states;

sys/dev/isp/isp_freebsd.c

781

const char *states[8] = { "Free", "ATIO", "CAM", "CTIO", "LAST_CTIO", "PDON", "?6", "7" };

sys/dev/isp/isp_freebsd.c

787

chan, atp->tag, atp->orig_datalen, atp->bytes_xfered, (uintmax_t)atp->lun, atp->nphdl, atp->sid, atp->did, atp->oxid, states[atp->state & 0x7]);

sys/dev/mlx4/mlx4_core/mlx4_qp.c

905

enum mlx4_qp_state states[] = {

sys/dev/mlx4/mlx4_core/mlx4_qp.c

912

for (i = 0; i < ARRAY_SIZE(states) - 1; i++) {

sys/dev/mlx4/mlx4_core/mlx4_qp.c

914

context->flags |= cpu_to_be32(states[i + 1] << 28);

sys/dev/mlx4/mlx4_core/mlx4_qp.c

915

if (states[i + 1] != MLX4_QP_STATE_RTR)

sys/dev/mlx4/mlx4_core/mlx4_qp.c

917

err = mlx4_qp_modify(dev, mtt, states[i], states[i + 1],

sys/dev/mlx4/mlx4_core/mlx4_qp.c

921

states[i + 1], err);

sys/dev/mlx4/mlx4_core/mlx4_qp.c

925

*qp_state = states[i + 1];

sys/dev/xen/cpu/xen_acpi_cpu.c

141

set_xen_guest_handle(op.u.set_pminfo.u.power.states, sc->cpu_cx_states);

sys/dev/xen/cpu/xen_acpi_cpu.c

176

set_xen_guest_handle(op.u.set_pminfo.u.perf.states, sc->cpu_px_states);

sys/kern/subr_prng.c

38

pcg32u_random_t states[2];

sys/kern/subr_prng.c

44

pcg32u_srandom_r(&state64->states[0], seed);

sys/kern/subr_prng.c

45

pcg32u_srandom_r(&state64->states[1], seed);

sys/kern/subr_prng.c

51

return ((((uint64_t)pcg32u_random_r(&state64->states[0])) << 32) |

sys/kern/subr_prng.c

52

pcg32u_random_r(&state64->states[1]));

sys/net/pfvar.h

1029

TAILQ_HEAD(, pf_kstate) states[2];

sys/net/pfvar.h

2200

uint32_t states;

sys/net/pfvar.h

2635

LIST_HEAD(, pf_kstate) states;

sys/net/pfvar.h

938

u_int32_t states;

sys/netinet/tcp_input.c

236

SYSCTL_COUNTER_U64_ARRAY(_net_inet_tcp, TCPCTL_STATES, states, CTLFLAG_RD |

sys/netpfil/ipfw/nat64/nat64lsn.c

1176

pg->states = uma_zalloc(nat64lsn_state_zone, M_NOWAIT);

sys/netpfil/ipfw/nat64/nat64lsn.c

1177

if (pg->states == NULL) {

sys/netpfil/ipfw/nat64/nat64lsn.c

1876

uma_zfree(nat64lsn_state_zone, pg->states);

sys/netpfil/ipfw/nat64/nat64lsn.c

234

((p)->chunks_count == 1 ? (p)->states : \

sys/netpfil/ipfw/nat64/nat64lsn.h

82

struct nat64lsn_states_chunk *states;

sys/netpfil/ipfw/nat64/nat64lsn_control.c

592

state = pg->chunks_count == 1 ? &pg->states->state[i] :

sys/netpfil/pf/if_pfsync.c

1170

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/if_pfsync.c

2732

s = LIST_FIRST(&ih->states);

sys/netpfil/pf/pf.c

1205

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf.c

1376

(*sn)->states >= rule->max_src_states) {

sys/netpfil/pf/pf.c

1385

(*sn)->states++;

sys/netpfil/pf/pf.c

1709

TAILQ_FOREACH(si, &cur->states[idx], key_list[idx]) {

sys/netpfil/pf/pf.c

1803

TAILQ_INSERT_TAIL(&s->key[idx]->states[idx], s, key_list[idx]);

sys/netpfil/pf/pf.c

1805

TAILQ_INSERT_HEAD(&s->key[idx]->states[idx], s, key_list[idx]);

sys/netpfil/pf/pf.c

1808

TAILQ_REMOVE(&s->key[idx]->states[idx], olds, key_list[idx]);

sys/netpfil/pf/pf.c

1809

TAILQ_INSERT_TAIL(&s->key[idx]->states[idx], olds,

sys/netpfil/pf/pf.c

1892

TAILQ_REMOVE(&sk->states[idx], s, key_list[idx]);

sys/netpfil/pf/pf.c

1895

if (TAILQ_EMPTY(&sk->states[0]) && TAILQ_EMPTY(&sk->states[1])) {

sys/netpfil/pf/pf.c

1907

TAILQ_INIT(&sk->states[PF_SK_WIRE]);

sys/netpfil/pf/pf.c

1908

TAILQ_INIT(&sk->states[PF_SK_STACK]);

sys/netpfil/pf/pf.c

2065

KASSERT(TAILQ_EMPTY(&sks->states[0]) && TAILQ_EMPTY(&sks->states[1]),

sys/netpfil/pf/pf.c

2067

KASSERT(TAILQ_EMPTY(&skw->states[0]) && TAILQ_EMPTY(&skw->states[1]),

sys/netpfil/pf/pf.c

2087

LIST_FOREACH(cur, &ih->states, entry)

sys/netpfil/pf/pf.c

2103

LIST_INSERT_HEAD(&ih->states, s, entry);

sys/netpfil/pf/pf.c

2129

LIST_FOREACH(s, &ih->states, entry)

sys/netpfil/pf/pf.c

2170

TAILQ_FOREACH(s, &sk->states[idx], key_list[idx])

sys/netpfil/pf/pf.c

2191

TAILQ_FOREACH(s, &sk->states[idx], key_list[idx]) {

sys/netpfil/pf/pf.c

2283

TAILQ_FOREACH(s, &sk->states[idx], key_list[idx]) {

sys/netpfil/pf/pf.c

2980

u_int32_t states;

sys/netpfil/pf/pf.c

2995

states = counter_u64_fetch(state->rule->states_cur);

sys/netpfil/pf/pf.c

2999

states = V_pf_status.states;

sys/netpfil/pf/pf.c

3001

if (end && states > start && start < end) {

sys/netpfil/pf/pf.c

3002

if (states < end) {

sys/netpfil/pf/pf.c

3003

timeout = (u_int64_t)timeout * (end - states) /

sys/netpfil/pf/pf.c

3025

if (cur->states == 0 && cur->expire <= time_uptime) {

sys/netpfil/pf/pf.c

3053

if (--(s->sns[sn_type]->states) == 0)

sys/netpfil/pf/pf.c

3229

V_pf_status.states = uma_zone_get_cur(V_pf_state_z);

sys/netpfil/pf/pf.c

3239

if (!LIST_EMPTY(&ih->states)) {

sys/netpfil/pf/pf.c

3242

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf.c

3244

V_pf_status.states -=

sys/netpfil/pf/pf.c

3267

V_pf_status.states = uma_zone_get_cur(V_pf_state_z);

sys/netpfil/pf/pf.c

3274

V_pf_status.states = uma_zone_get_cur(V_pf_state_z);

sys/netpfil/pf/pf.c

6965

if (--sns[sn_type]->states == 0 &&

sys/netpfil/pf/pf.h

296

uint32_t states;

sys/netpfil/pf/pf.h

705

u_int32_t states;

sys/netpfil/pf/pf_ioctl.c

2459

out->states = in->states;

sys/netpfil/pf/pf_ioctl.c

3298

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf_ioctl.c

5011

if (LIST_EMPTY(&ih->states))

sys/netpfil/pf/pf_ioctl.c

5016

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf_ioctl.c

5037

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf_ioctl.c

5091

if (LIST_EMPTY(&ih->states))

sys/netpfil/pf/pf_ioctl.c

5096

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf_ioctl.c

5117

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf_ioctl.c

6958

nvlist_add_number(nvl, "states", V_pf_status.states);

sys/netpfil/pf/pf_ioctl.c

7057

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf_ioctl.c

7118

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf_ioctl.c

7184

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf_lb.c

983

LIST_FOREACH(st, &ih->states, entry) {

sys/netpfil/pf/pf_nl.c

1292

nlattr_add_u32(nw, PF_GS_STATES, V_pf_status.states);

sys/netpfil/pf/pf_nl.c

1827

nlattr_add_u32(nw, PF_SN_STATES, n->states);

sys/netpfil/pf/pf_nl.c

281

if (LIST_EMPTY(&ih->states))

sys/netpfil/pf/pf_nl.c

285

LIST_FOREACH(s, &ih->states, entry) {

sys/netpfil/pf/pf_nl.c

394

if (LIST_EMPTY(&ih->states))

sys/netpfil/pf/pf_nl.c

398

LIST_FOREACH(s, &ih->states, entry) {

sys/powerpc/cpufreq/dfs.c

141

int states;

sys/powerpc/cpufreq/dfs.c

144

states = sc->dfs4 ? 3 : 2;

sys/powerpc/cpufreq/dfs.c

147

if (*count < states)

sys/powerpc/cpufreq/dfs.c

151

memset(sets, CPUFREQ_VAL_UNKNOWN, sizeof(*sets) * states);

sys/powerpc/cpufreq/dfs.c

159

*count = states;

usr.bin/bluetooth/btsockstat/btsockstat.c

321

static char const * const states[] = {

usr.bin/bluetooth/btsockstat/btsockstat.c

425

static char const * const states[] = {

usr.bin/bluetooth/btsockstat/btsockstat.c

490

static char const * const states[] = {

usr.bin/bluetooth/btsockstat/btsockstat.c

99

(((x) >= sizeof(states)/sizeof(states[0]))? "UNKNOWN" : states[(x)])

usr.bin/iscsictl/iscsictl.c

302

struct iscsi_session_state *states = NULL;

usr.bin/iscsictl/iscsictl.c

311

states = realloc(states,

usr.bin/iscsictl/iscsictl.c

313

if (states == NULL)

usr.bin/iscsictl/iscsictl.c

318

isl.isl_pstates = states;

usr.bin/iscsictl/iscsictl.c

331

state = &states[i];

usr.bin/iscsictl/iscsictl.c

384

struct iscsi_session_state *states = NULL;

usr.bin/iscsictl/iscsictl.c

392

states = realloc(states,

usr.bin/iscsictl/iscsictl.c

394

if (states == NULL)

usr.bin/iscsictl/iscsictl.c

399

isl.isl_pstates = states;

usr.bin/iscsictl/iscsictl.c

416

state = &states[i];

usr.bin/iscsictl/iscsictl.c

521

state = &states[i];

usr.bin/iscsictl/iscsictl.c

556

struct iscsi_session_state *states = NULL;

usr.bin/iscsictl/iscsictl.c

565

states = realloc(states,

usr.bin/iscsictl/iscsictl.c

567

if (states == NULL)

usr.bin/iscsictl/iscsictl.c

572

isl.isl_pstates = states;

usr.bin/iscsictl/iscsictl.c

588

state = &states[i];

usr.bin/top/display.c

416

i_cpustates(int *states)

usr.bin/top/display.c

422

int *hstates = states;

usr.bin/top/display.c

444

value = *states++;

usr.bin/top/display.c

456

states = hstates;

usr.bin/top/display.c

457

memcpy(lcpustates, states, num_cpustates * sizeof(int) * num_cpus);

usr.bin/top/display.c

461

u_cpustates(int *states)

usr.bin/top/display.c

466

int *hstates = states;

usr.bin/top/display.c

485

if (*lp != *states)

usr.bin/top/display.c

492

value = *states;

usr.bin/top/display.c

505

states++;

usr.bin/top/display.c

510

states = hstates;

usr.bin/top/display.h

18

void i_cpustates(int *states);

usr.bin/top/display.h

32

void u_cpustates(int *states);

usr.bin/top/top.c

76

static void (*d_cpustates)(int *states) = i_cpustates;

usr.sbin/bsnmpd/modules/snmp_hostres/hostres_processor_tbl.c

113

delta += e->states[e->cur_sample_idx][i];

usr.sbin/bsnmpd/modules/snmp_hostres/hostres_processor_tbl.c

114

delta -= e->states[oldest][i];

usr.sbin/bsnmpd/modules/snmp_hostres/hostres_processor_tbl.c

121

usage = (double)(e->states[e->cur_sample_idx][CPUSTATES-1] -

usr.sbin/bsnmpd/modules/snmp_hostres/hostres_processor_tbl.c

122

e->states[oldest][CPUSTATES-1]) / delta;

usr.sbin/bsnmpd/modules/snmp_hostres/hostres_processor_tbl.c

142

e->states[e->cur_sample_idx][i] = cp_times[i];

usr.sbin/bsnmpd/modules/snmp_hostres/hostres_processor_tbl.c

65

long states[MAX_CPU_SAMPLES][CPUSTATES];

usr.sbin/bsnmpd/modules/snmp_pf/pf_snmp.c

251

val->v.uint32 = pfs->states;

usr.sbin/moused/moused/moused.c

2498

states[e3b->mouse_button_state].s[trans]);

usr.sbin/moused/moused/moused.c

2506

S_DELAYED(states[e3b->mouse_button_state].s[trans])) {

usr.sbin/moused/moused/moused.c

2510

states[e3b->mouse_button_state].s[A_TIMEOUT];

usr.sbin/moused/moused/moused.c

2516

if (e3b->mouse_button_state != states[e3b->mouse_button_state].s[trans])

usr.sbin/moused/moused/moused.c

2521

e3b->mouse_button_state = states[e3b->mouse_button_state].s[trans];

usr.sbin/moused/moused/moused.c

2524

a2->button &= states[e3b->mouse_button_state].mask;

usr.sbin/moused/moused/moused.c

2525

a2->button |= states[e3b->mouse_button_state].buttons;

usr.sbin/moused/moused/moused.c

2762

if (states[e3b->mouse_button_state].timeout)

usr.sbin/moused/moused/moused.c

326

#define S_DELAYED(st) (states[st].s[A_TIMEOUT] != (st))

usr.sbin/moused/moused/moused.c

333

} states[10] = {

usr.sbin/ppp/datalink.c

1255

static const char * const states[] = {

usr.sbin/ppp/datalink.c

1273

if (dl->state >= sizeof states / sizeof states[0])

usr.sbin/ppp/datalink.c

1275

return states[dl->state];

usr.sbin/ppp/datalink.c

1282

if (state < sizeof states / sizeof states[0]) {

usr.sbin/ppp/datalink.c

1284

states[state]);