bin/pwait/pwait.c

228

if (e[i].filter == EVFILT_SIGNAL) {

cddl/usr.sbin/zfsd/zpool_list.cc

107

ZpoolList::ZpoolList(PoolFilter_t *filter, void * filterArg)

cddl/usr.sbin/zfsd/zpool_list.cc

108

: m_filter(filter),

cddl/usr.sbin/zfsd/zpool_list.h

105

ZpoolList(PoolFilter_t *filter = ZpoolAll, void *filterArg = NULL);

crypto/heimdal/lib/hdb/hdb-ldap.c

749

const char *filter = "(objectClass=krb5Principal)";

crypto/heimdal/lib/hdb/hdb-ldap.c

758

filter, krb5principal_attrs, 0,

crypto/heimdal/lib/hdb/hdb-ldap.c

765

filter, ldap_err2string(rc));

crypto/heimdal/lib/hdb/hdb-ldap.c

843

char *quote, *filter = NULL;

crypto/heimdal/lib/hdb/hdb-ldap.c

858

rc = asprintf(&filter,

crypto/heimdal/lib/hdb/hdb-ldap.c

874

LDAP_SCOPE_SUBTREE, filter,

crypto/heimdal/lib/hdb/hdb-ldap.c

882

filter, ldap_err2string(rc));

crypto/heimdal/lib/hdb/hdb-ldap.c

887

free(filter);

crypto/heimdal/lib/hdb/hdb-ldap.c

888

filter = NULL;

crypto/heimdal/lib/hdb/hdb-ldap.c

896

rc = asprintf(&filter,

crypto/heimdal/lib/hdb/hdb-ldap.c

911

filter, krb5kdcentry_attrs, 0,

crypto/heimdal/lib/hdb/hdb-ldap.c

918

filter, ldap_err2string(rc));

crypto/heimdal/lib/hdb/hdb-ldap.c

926

if (filter)

crypto/heimdal/lib/hdb/hdb-ldap.c

927

free(filter);

crypto/heimdal/lib/kadm5/ad.c

1079

char *filter, *dn;

crypto/heimdal/lib/kadm5/ad.c

1107

asprintf(&filter,

crypto/heimdal/lib/kadm5/ad.c

1115

filter, attr, 0, &m);

crypto/heimdal/lib/kadm5/ad.c

1117

free(filter);

crypto/heimdal/lib/kadm5/ad.c

440

char *filter;

crypto/heimdal/lib/kadm5/ad.c

447

asprintf(&filter,

crypto/heimdal/lib/kadm5/ad.c

451

asprintf(&filter, "(&(objectClass=account)(userPrincipalName=%s))", pn);

crypto/heimdal/lib/kadm5/ad.c

457

filter, attr, 0, &m);

crypto/heimdal/lib/kadm5/ad.c

458

free(filter);

crypto/heimdal/lib/kadm5/ad.c

882

char *filter, *p, *q, *u;

crypto/heimdal/lib/kadm5/ad.c

919

asprintf(&filter,

crypto/heimdal/lib/kadm5/ad.c

927

filter, attr, 0, &m);

crypto/krb5/src/clients/ksu/heuristic.c

249

retval = filter(users_fp,cmd, k5users_list, &k5users_filt_list);

crypto/krb5/src/clients/ksu/ksu.h

197

extern krb5_error_code filter (FILE *, char *, char **, char ***);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/kdb_ldap.h

106

st = ldap_search_ext_s(ld, base, scope, filter, attrs, 0, \

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/kdb_ldap.h

95

#define LDAP_SEARCH(base, scope, filter, attrs) LDAP_SEARCH_1(base, scope, filter, attrs, CHECK_STATUS)

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/kdb_ldap.h

97

#define LDAP_SEARCH_1(base, scope, filter, attrs, status_check) \

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/kdb_ldap.h

99

st = ldap_search_ext_s(ld, base, scope, filter, attrs, 0, NULL, \

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_misc.c

1160

char *filter = NULL, *corrected = NULL, **subtree = NULL;

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_misc.c

1186

if (asprintf(&filter, "%s=%s", refattr, corrected) < 0) {

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_misc.c

1187

filter = NULL;

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_misc.c

1197

LDAP_SEARCH(subtree[i], LDAP_SCOPE_SUBTREE, filter, refcntattr);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_misc.c

1216

free(filter);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal.c

208

char **subtree=NULL, *realm=NULL, *filter=NULL;

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal.c

240

if (asprintf(&filter, FILTER"%s))", match_expr) < 0)

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal.c

241

filter = NULL;

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal.c

242

CHECK_NULL(filter);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal.c

251

LDAP_SEARCH(subtree[tree], ldap_context->lrparams->search_scope, filter, principal_attributes);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal.c

262

if (filter)

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal.c

263

free (filter);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c

110

int scope, const char *filter, const char *user,

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c

120

LDAP_SEARCH(base, scope, filter, principal_attributes);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c

1520

free(filter);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c

155

char *user = NULL, *filtuser = NULL, *filter = NULL;

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c

171

if (asprintf(&filter, FILTER"%s))", filtuser) < 0) {

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c

172

filter = NULL;

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c

179

LDAP_SCOPE_BASE, filter, user, entry_out, result_out);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c

190

filter, user, entry_out, result_out);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c

198

free(filter);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c

894

char *filter = NULL;

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_realm.c

235

char *attr[] = {"krbprincipalname", NULL}, *realm=NULL, filter[256];

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_realm.c

239

assert (sizeof (filter) >= sizeof ("(krbprincipalname=)") +

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_realm.c

242

snprintf (filter, sizeof(filter), "(krbprincipalname=*@%s)", realm);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_realm.c

259

LDAP_SEARCH(subtrees[l], rparam->search_scope, filter, attr);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_tkt_policy.c

432

char *filter=NULL, *dn=NULL;

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_tkt_policy.c

454

filter = malloc ((unsigned) filterlen);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_tkt_policy.c

455

if (filter == NULL) {

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_tkt_policy.c

459

snprintf(filter, (unsigned) filterlen,"(objectclass=%s)",objectclass);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_tkt_policy.c

461

LDAP_SEARCH(containerdn, LDAP_SCOPE_SUBTREE, filter, NULL);

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_tkt_policy.c

487

if (filter)

crypto/krb5/src/plugins/kdb/ldap/libkdb_ldap/ldap_tkt_policy.c

488

free (filter);

crypto/openssh/match.c

321

filter_list(const char *proposal, const char *filter, int denylist)

crypto/openssh/match.c

338

r = match_pattern_list(cp, filter, 0);

crypto/openssh/match.c

354

match_filter_denylist(const char *proposal, const char *filter)

crypto/openssh/match.c

356

return filter_list(proposal, filter, 1);

crypto/openssh/match.c

364

match_filter_allowlist(const char *proposal, const char *filter)

crypto/openssh/match.c

366

return filter_list(proposal, filter, 0);

crypto/openssh/regress/unittests/match/tests.c

105

#define CHECK_FILTER(string,filter,expected) \

crypto/openssh/regress/unittests/match/tests.c

107

char *result = match_filter_denylist((string), (filter)); \

crypto/openssh/sandbox-seccomp-filter.c

429

.filter = (struct sock_filter *)preauth_insns,

crypto/openssl/apps/s_server.c

3273

BIO *filter;

crypto/openssl/apps/s_server.c

3340

filter = BIO_new(BIO_f_ebcdic_filter());

crypto/openssl/apps/s_server.c

3341

if (filter == NULL)

crypto/openssl/apps/s_server.c

3344

io = BIO_push(filter, io);

crypto/openssl/apps/s_server.c

3346

filter = BIO_new(BIO_f_ebcdic_filter());

crypto/openssl/apps/s_server.c

3347

if (filter == NULL)

crypto/openssl/apps/s_server.c

3350

edio = BIO_push(filter, edio);

crypto/openssl/apps/s_server.c

3743

BIO *filter;

crypto/openssl/apps/s_server.c

3788

filter = BIO_new(BIO_f_ebcdic_filter());

crypto/openssl/apps/s_server.c

3789

if (filter == NULL)

crypto/openssl/apps/s_server.c

3792

io = BIO_push(filter, io);

crypto/openssl/crypto/hashtable/hashtable.c

366

int (*filter)(HT_VALUE *obj, void *arg),

crypto/openssl/crypto/hashtable/hashtable.c

389

if (v != NULL && filter((HT_VALUE *)v, arg)) {

crypto/openssl/include/internal/hashtable.h

351

int (*filter)(HT_VALUE *obj, void *arg),

crypto/openssl/include/internal/qlog.h

49

int ossl_qlog_set_filter(QLOG *qlog, const char *filter);

crypto/openssl/ssl/quic/qlog.c

684

int ossl_qlog_set_filter(QLOG *qlog, const char *filter)

crypto/openssl/ssl/quic/qlog.c

694

if (!lex_init(&lex, filter, strlen(filter)))

crypto/openssl/test/quic_qlog_test.c

155

const char *filter;

crypto/openssl/test/quic_qlog_test.c

228

if (!TEST_int_eq(ossl_qlog_set_filter(qlog, filters[idx].filter),

lib/libbluetooth/bluetooth.h

176

void bt_devfilter_pkt_set(struct bt_devfilter *filter, uint8_t type);

lib/libbluetooth/bluetooth.h

177

void bt_devfilter_pkt_clr(struct bt_devfilter *filter, uint8_t type);

lib/libbluetooth/bluetooth.h

178

int bt_devfilter_pkt_tst(struct bt_devfilter const *filter, uint8_t type);

lib/libbluetooth/bluetooth.h

179

void bt_devfilter_evt_set(struct bt_devfilter *filter, uint8_t event);

lib/libbluetooth/bluetooth.h

180

void bt_devfilter_evt_clr(struct bt_devfilter *filter, uint8_t event);

lib/libbluetooth/bluetooth.h

181

int bt_devfilter_evt_tst(struct bt_devfilter const *filter, uint8_t event);

lib/libbluetooth/hci.c

371

bt_devfilter_pkt_set(struct bt_devfilter *filter, uint8_t type)

lib/libbluetooth/hci.c

373

bit_set(filter->packet_mask, type - 1);

lib/libbluetooth/hci.c

377

bt_devfilter_pkt_clr(struct bt_devfilter *filter, uint8_t type)

lib/libbluetooth/hci.c

379

bit_clear(filter->packet_mask, type - 1);

lib/libbluetooth/hci.c

383

bt_devfilter_pkt_tst(struct bt_devfilter const *filter, uint8_t type)

lib/libbluetooth/hci.c

385

return (bit_test(filter->packet_mask, type - 1));

lib/libbluetooth/hci.c

389

bt_devfilter_evt_set(struct bt_devfilter *filter, uint8_t event)

lib/libbluetooth/hci.c

391

bit_set(filter->event_mask, event - 1);

lib/libbluetooth/hci.c

395

bt_devfilter_evt_clr(struct bt_devfilter *filter, uint8_t event)

lib/libbluetooth/hci.c

397

bit_clear(filter->event_mask, event - 1);

lib/libbluetooth/hci.c

401

bt_devfilter_evt_tst(struct bt_devfilter const *filter, uint8_t event)

lib/libbluetooth/hci.c

403

return (bit_test(filter->event_mask, event - 1));

lib/libc/net/nscachedcli.c

119

if (nevents == 1 && eventlist.filter == EVFILT_READ) {

lib/libc/net/nscachedcli.c

174

if (nevents == 1 && eventlist.filter == EVFILT_WRITE) {

lib/libc/net/nscachedcli.c

76

if ((nevents == 1) && (eventlist.filter == EVFILT_WRITE)) {

lib/libc/rpc/netnamer.c

150

int filter;

lib/libc/rpc/netnamer.c

164

filter = 0;

lib/libc/rpc/netnamer.c

167

filter++;

lib/libc/rpc/netnamer.c

170

if (!filter)

lib/libpfctl/libpfctl.c

1972

pfctl_get_states_h(struct pfctl_handle *h, struct pfctl_state_filter *filter, pfctl_get_state_fn f, void *arg)

lib/libpfctl/libpfctl.c

1986

snl_add_msg_attr_string(&nw, PF_ST_IFNAME, filter->ifname);

lib/libpfctl/libpfctl.c

1987

snl_add_msg_attr_u16(&nw, PF_ST_PROTO, filter->proto);

lib/libpfctl/libpfctl.c

1988

snl_add_msg_attr_u8(&nw, PF_ST_AF, filter->af);

lib/libpfctl/libpfctl.c

1989

snl_add_msg_attr_ip6(&nw, PF_ST_FILTER_ADDR, &filter->addr.v6);

lib/libpfctl/libpfctl.c

1990

snl_add_msg_attr_ip6(&nw, PF_ST_FILTER_MASK, &filter->mask.v6);

lib/libpfctl/libpfctl.c

2018

struct pfctl_state_filter filter = {};

lib/libpfctl/libpfctl.c

2019

return (pfctl_get_filtered_states_iter(&filter, f, arg));

lib/libpfctl/libpfctl.c

2023

pfctl_get_filtered_states_iter(struct pfctl_state_filter *filter, pfctl_get_state_fn f, void *arg)

lib/libpfctl/libpfctl.c

2029

error = pfctl_get_states_h(&h, filter, f, arg);

lib/libpfctl/libpfctl.c

3461

pfctl_clear_tables(struct pfctl_handle *h, struct pfr_table *filter,

lib/libpfctl/libpfctl.c

3477

snl_add_msg_attr_string(&nw, PF_T_ANCHOR, filter->pfrt_anchor);

lib/libpfctl/libpfctl.c

3478

snl_add_msg_attr_string(&nw, PF_T_NAME, filter->pfrt_name);

lib/libpfctl/libpfctl.c

3479

snl_add_msg_attr_u32(&nw, PF_T_TABLE_FLAGS, filter->pfrt_flags);

lib/libpfctl/libpfctl.c

3627

pfctl_get_tstats(struct pfctl_handle *h, const struct pfr_table *filter,

lib/libpfctl/libpfctl.c

3644

snl_add_msg_attr_string(&nw, PF_T_ANCHOR, filter->pfrt_anchor);

lib/libpfctl/libpfctl.c

3645

snl_add_msg_attr_string(&nw, PF_T_NAME, filter->pfrt_name);

lib/libpfctl/libpfctl.c

3646

snl_add_msg_attr_u32(&nw, PF_T_TABLE_FLAGS, filter->pfrt_flags);

lib/libpfctl/libpfctl.c

3676

pfctl_clear_tstats(struct pfctl_handle *h, const struct pfr_table *filter,

lib/libpfctl/libpfctl.c

3693

snl_add_msg_attr_string(&nw, PF_T_ANCHOR, filter->pfrt_anchor);

lib/libpfctl/libpfctl.c

3694

snl_add_msg_attr_string(&nw, PF_T_NAME, filter->pfrt_name);

lib/libpfctl/libpfctl.c

3695

snl_add_msg_attr_u32(&nw, PF_T_TABLE_FLAGS, filter->pfrt_flags);

lib/libpfctl/libpfctl.c

3722

pfctl_clear_addrs(struct pfctl_handle *h, const struct pfr_table *filter,

lib/libpfctl/libpfctl.c

3739

snl_add_msg_attr_string(&nw, PF_T_ANCHOR, filter->pfrt_anchor);

lib/libpfctl/libpfctl.c

3740

snl_add_msg_attr_string(&nw, PF_T_NAME, filter->pfrt_name);

lib/libpfctl/libpfctl.c

3741

snl_add_msg_attr_u32(&nw, PF_T_TABLE_FLAGS, filter->pfrt_flags);

lib/libpfctl/libpfctl.h

510

int pfctl_get_states_h(struct pfctl_handle *h, struct pfctl_state_filter *filter, pfctl_get_state_fn f, void *arg);

lib/libpfctl/libpfctl.h

511

int pfctl_get_filtered_states_iter(struct pfctl_state_filter *filter, pfctl_get_state_fn f, void *arg);

lib/libpfctl/libpfctl.h

581

int pfctl_clear_tables(struct pfctl_handle *h, struct pfr_table *filter,

lib/libpfctl/libpfctl.h

589

int pfctl_get_tstats(struct pfctl_handle *h, const struct pfr_table *filter,

lib/libpfctl/libpfctl.h

591

int pfctl_clear_tstats(struct pfctl_handle *h, const struct pfr_table *filter,

lib/libpfctl/libpfctl.h

593

int pfctl_clear_addrs(struct pfctl_handle *h, const struct pfr_table *filter,

lib/libpmc/pmu-events/jevents.c

573

char *filter = NULL;

lib/libpmc/pmu-events/jevents.c

716

addfield(map, &filter, "", "", val);

lib/libpmc/pmu-events/jevents.c

846

if (filter)

lib/libpmc/pmu-events/jevents.c

847

addfield(map, &event, ",", filter, NULL);

lib/libpmc/pmu-events/jevents.c

884

free(filter);

lib/libsysdecode/flags.c

388

sysdecode_kevent_fflags(FILE *fp, short filter, int fflags, int base)

lib/libsysdecode/flags.c

397

switch (filter) {

lib/libsysdecode/flags.c

466

sysdecode_kevent_filter(int filter)

lib/libsysdecode/flags.c

469

return (lookup_value(keventfilters, filter));

sbin/ifconfig/ifclone.c

103

dcp->ifmatch = filter;

sbin/ifconfig/ifclone.c

98

clone_setdefcallback_filter(clone_match_func *filter, clone_callback_func *p)

sbin/ipf/ipf/ipf.c

106

flushfilter(optarg, filter);

sbin/ipf/ipf/ipf.c

115

filter = parseipfexpr(optarg, NULL);

sbin/ipf/ipf/ipf.c

343

flushfilter(char *arg, int *filter)

sbin/ipf/ipf/ipf.c

366

} else if (filter != NULL) {

sbin/ipf/ipf/ipf.c

370

obj.ipfo_size = filter[0] * sizeof(int);

sbin/ipf/ipf/ipf.c

372

obj.ipfo_ptr = filter;

sbin/ipf/ipf/ipf.c

67

int c, *filter = NULL;

sbin/ipf/ipfstat/ipfstat.c

1058

static void showipstates(ips_stat_t *ipsp, int *filter)

sbin/ipf/ipfstat/ipfstat.c

1092

if ((filter != NULL) &&

sbin/ipf/ipfstat/ipfstat.c

1093

(state_matcharray(&ips, filter) == 0)) {

sbin/ipf/ipfstat/ipfstat.c

1275

int protocol, int ver, int refreshtime, int topclosed, int *filter)

sbin/ipf/ipfstat/ipfstat.c

1345

if ((filter != NULL) &&

sbin/ipf/ipfstat/ipfstat.c

1346

(state_matcharray(&ips, filter) == 0))

sbin/ipf/ipfstat/ipfstat.c

195

int *filter = NULL;

sbin/ipf/ipfstat/ipfstat.c

324

filter = parseipfexpr(optarg, NULL);

sbin/ipf/ipfstat/ipfstat.c

325

if (filter == NULL) {

sbin/ipf/ipfstat/ipfstat.c

414

showipstates(ipsstp, filter);

sbin/ipf/ipfstat/ipfstat.c

432

refreshtime, topclosed, filter);

sbin/ipf/ipnat/ipnat.c

326

dostats_dead(natstat_t *nsp, int opts, int *filter)

sbin/ipf/ipnat/ipnat.c

362

if ((filter != NULL) && (nat_matcharray(&nat, filter) == 0))

sbin/ipf/ipnat/ipnat.c

460

dostats(int fd, natstat_t *nsp, int opts, int alive, int *filter)

sbin/ipf/ipnat/ipnat.c

503

dostats_live(fd, nsp, opts, filter);

sbin/ipf/ipnat/ipnat.c

505

dostats_dead(nsp, opts, filter);

sbin/ipf/ipnat/ipnat.c

514

dostats_live(int fd, natstat_t *nsp, int opts, int *filter)

sbin/ipf/ipnat/ipnat.c

572

if ((filter != NULL) && (nat_matcharray(&nat, filter) == 0))

sbin/ipfw/ipfw2.c

6171

ipfw_rtsock_monitor(const char *filter)

sbin/ipfw/ipfw2.c

6218

if (filter != NULL &&

sbin/ipfw/ipfw2.c

6219

strncmp(filter, loghdr->comment, 80) != 0)

sbin/pfctl/pfctl.c

1993

struct pfctl_state_filter filter = {};

sbin/pfctl/pfctl.c

1996

strlcpy(filter.ifname, iface, IFNAMSIZ);

sbin/pfctl/pfctl.c

2002

if (pfctl_get_states_h(pfh, &filter, pfctl_show_state, &arg))

sbin/pfctl/pfctl_parser.c

1859

ifa_skip_if(const char *filter, struct node_host *p)

sbin/pfctl/pfctl_parser.c

1865

if (filter == NULL || !*filter)

sbin/pfctl/pfctl_parser.c

1867

if (!strcmp(p->ifname, filter))

sbin/pfctl/pfctl_parser.c

1869

n = strlen(filter);

sbin/pfctl/pfctl_parser.c

1872

if (filter[n-1] >= '0' && filter[n-1] <= '9')

sbin/pfctl/pfctl_parser.c

1874

if (strncmp(p->ifname, filter, n))

sbin/pfctl/pfctl_parser.c

75

int ifa_skip_if(const char *filter, struct node_host *p);

sbin/pfctl/pfctl_radix.c

103

pfr_get_tables(struct pfr_table *filter, struct pfr_table *tbl, int *size,

sbin/pfctl/pfctl_radix.c

114

if (filter != NULL)

sbin/pfctl/pfctl_radix.c

115

io.pfrio_table = *filter;

sbin/pfctl/pfctl_radix.c

263

pfi_get_ifaces(const char *filter, struct pfi_kif *buf, int *size)

sbin/pfctl/pfctl_radix.c

272

if (filter != NULL)

sbin/pfctl/pfctl_radix.c

273

if (strlcpy(io.pfiio_name, filter, sizeof(io.pfiio_name)) >=

sbin/pfctl/pfctl_table.c

664

pfctl_show_ifaces(const char *filter, int opts)

sbin/pfctl/pfctl_table.c

674

if (pfi_get_ifaces(filter, b.pfrb_caddr, &b.pfrb_size))

share/examples/inotify/inotify.c

143

if (kev.filter == EVFILT_SIGNAL)

share/examples/scsi_target/scsi_target.c

450

switch (events[i].filter) {

share/examples/scsi_target/scsi_target.c

479

warnx("unknown event %d", events[i].filter);

share/examples/scsi_target/scsi_target.c

484

warnx("event %d done", events[i].filter);

stand/efi/include/efi_driver_utils.h

33

EFI_STATUS connect_controllers(EFI_GUID *filter);

stand/efi/libefi/efi_driver_utils.c

34

connect_controllers(EFI_GUID *filter)

stand/efi/libefi/efi_driver_utils.c

42

status = BS->LocateHandle(ByProtocol, filter, NULL,

stand/efi/libefi/efi_driver_utils.c

54

status = BS->LocateHandle(ByProtocol, filter, NULL,

stand/i386/libi386/pxe.h

231

uint8_t filter; /* see UNDI_OPEN (0x0006) */

stand/kshim/bsd_kernel.c

180

driver_filter_t filter, driver_intr_t handler, void *arg, void **cookiep)

stand/kshim/bsd_kernel.c

183

dev->dev_irq_filter = filter;

stand/kshim/bsd_kernel.c

43

bus_addr_t highaddr, bus_dma_filter_t *filter,

stand/kshim/bsd_kernel.c

597

device_set_interrupt(device_t dev, driver_filter_t *filter,

stand/kshim/bsd_kernel.c

600

dev->dev_irq_filter = filter;

stand/kshim/bsd_kernel.h

703

bus_addr_t highaddr, bus_dma_filter_t *filter,

sys/arm/allwinner/aw_thermal.c

161

uint32_t filter;

sys/arm/allwinner/aw_thermal.c

197

.filter = A83T_FILTER,

sys/arm/allwinner/aw_thermal.c

229

.filter = A64_FILTER,

sys/arm/allwinner/aw_thermal.c

261

.filter = H3_FILTER,

sys/arm/allwinner/aw_thermal.c

335

.filter = H5_FILTER,

sys/arm/allwinner/aw_thermal.c

415

WR4(sc, THS_FILTER, sc->conf->filter);

sys/arm/arm/busdma_machdep.c

363

bus_dma_filter_t *filter, void *filterarg, bus_size_t maxsize,

sys/arm/arm/busdma_machdep.c

383

if (filter != NULL || filterarg != NULL)

sys/arm64/arm64/busdma_machdep.c

123

bus_dma_filter_t *filter, void *filterarg, bus_size_t maxsize,

sys/arm64/arm64/busdma_machdep.c

131

if (filter != NULL || filterarg != NULL)

sys/compat/freebsd32/freebsd32_misc.c

719

CP(*kevp, *ks32, filter);

sys/compat/freebsd32/freebsd32_misc.c

794

CP(ks32[i], kevp[i], filter);

sys/compat/freebsd32/freebsd32_misc.c

858

CP(kevp[i], ks32[i], filter);

sys/compat/freebsd32/freebsd32_misc.c

890

CP(ks32[i], kevp[i], filter);

sys/compat/linux/linux_event.c

217

switch (kevent->filter) {

sys/compat/linux/linux_event.c

530

epoll_register_kevent(struct thread *td, struct file *epfp, int fd, int filter,

sys/compat/linux/linux_event.c

540

EV_SET(&kev, fd, filter, flags, 0, 0, 0);

sys/compat/linux/linux_event.c

86

int fd, int filter, unsigned int flags);

sys/dev/ahci/ahci.c

662

int flags, driver_filter_t *filter, driver_intr_t *function,

sys/dev/ahci/ahci.c

668

if (filter != NULL) {

sys/dev/ahci/ahci.h

661

int flags, driver_filter_t *filter, driver_intr_t *function,

sys/dev/aic7xxx/aic_osm_lib.h

114

lowaddr, highaddr, filter, filterarg, \

sys/dev/aic7xxx/aic_osm_lib.h

118

lowaddr, highaddr, filter, filterarg, \

sys/dev/al_eth/al_eth.c

2949

entry.filter = false;

sys/dev/al_eth/al_eth.c

609

entry.filter = false;

sys/dev/al_eth/al_eth.c

632

entry.filter = false;

sys/dev/al_eth/al_eth.c

653

entry.filter = false;

sys/dev/al_eth/al_eth.c

674

entry.filter = (promiscuous) ? false : true;

sys/dev/aq/aq_hw_llh.c

1052

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1054

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_EN_F_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1062

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1064

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_ACT_F_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1072

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1074

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_ID_F_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1082

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1084

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_RXQ_EN_F_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1092

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1094

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_RXQ_F_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1102

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1104

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_ENF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1111

uint32_t etht_user_priority_en, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1113

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_UPFEN_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1120

uint32_t etht_rx_queue_en, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1122

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_RXQFEN_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1130

uint32_t etht_user_priority, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1132

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_UPF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1139

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1141

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_RXQF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1148

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1150

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_MNG_RXQF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1158

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1160

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_ACTF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1167

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1169

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_VALF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1175

hw_atl_rpf_l3_l4_enf_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1177

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_L4_ENF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1183

hw_atl_rpf_l3_v6_enf_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1185

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_V6_ENF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1191

hw_atl_rpf_l3_saf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1193

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_SAF_EN_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1199

hw_atl_rpf_l3_daf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1201

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_DAF_EN_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1207

hw_atl_rpf_l4_spf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1209

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_SPF_EN_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1215

hw_atl_rpf_l4_dpf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1217

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_DPF_EN_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1223

hw_atl_rpf_l4_protf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1225

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_PROTF_EN_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1231

hw_atl_rpf_l3_arpf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1233

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_ARPF_EN_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1240

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1242

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_L4_RXQF_EN_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1249

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1251

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_L4_MNG_RXQF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1257

hw_atl_rpf_l3_l4_actf_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1259

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_L4_ACTF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1265

hw_atl_rpf_l3_l4_rxqf_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1267

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_L4_RXQF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1273

hw_atl_rpf_l4_protf_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1275

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_PROTF_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1281

hw_atl_rpf_l4_spd_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1283

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_SPD_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1289

hw_atl_rpf_l4_dpd_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1291

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_DPD_ADR(filter),

sys/dev/aq/aq_hw_llh.c

1335

rpf_vlan_flr_en_set(struct aq_hw *aq_hw, uint32_t vlan_flr_en, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1337

AQ_WRITE_REG_BIT(aq_hw, rpf_vl_en_f_adr(filter), rpf_vl_en_f_msk,

sys/dev/aq/aq_hw_llh.c

1343

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1345

AQ_WRITE_REG_BIT(aq_hw, rpf_vl_act_f_adr(filter), rpf_vl_act_f_msk,

sys/dev/aq/aq_hw_llh.c

1350

rpf_vlan_id_flr_set(struct aq_hw *aq_hw, uint32_t vlan_id_flr, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1352

AQ_WRITE_REG_BIT(aq_hw, rpf_vl_id_f_adr(filter), rpf_vl_id_f_msk,

sys/dev/aq/aq_hw_llh.c

1357

rpf_etht_flr_en_set(struct aq_hw *aq_hw, uint32_t etht_flr_en, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1359

AQ_WRITE_REG_BIT(aq_hw, rpf_et_enf_adr(filter), rpf_et_enf_msk,

sys/dev/aq/aq_hw_llh.c

1365

uint32_t etht_user_priority_en, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1367

AQ_WRITE_REG_BIT(aq_hw, rpf_et_upfen_adr(filter), rpf_et_upfen_msk,

sys/dev/aq/aq_hw_llh.c

1373

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1375

AQ_WRITE_REG_BIT(aq_hw, rpf_et_rxqfen_adr(filter), rpf_et_rxqfen_msk,

sys/dev/aq/aq_hw_llh.c

1381

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1383

AQ_WRITE_REG_BIT(aq_hw, rpf_et_upf_adr(filter), rpf_et_upf_msk,

sys/dev/aq/aq_hw_llh.c

1389

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1391

AQ_WRITE_REG_BIT(aq_hw, rpf_et_rxqf_adr(filter), rpf_et_rxqf_msk,

sys/dev/aq/aq_hw_llh.c

1397

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1399

AQ_WRITE_REG_BIT(aq_hw, rpf_et_mng_rxqf_adr(filter),

sys/dev/aq/aq_hw_llh.c

1405

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1407

AQ_WRITE_REG_BIT(aq_hw, rpf_et_actf_adr(filter), rpf_et_actf_msk,

sys/dev/aq/aq_hw_llh.c

1412

rpf_etht_flr_set(struct aq_hw *aq_hw, uint32_t etht_flr, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

1414

AQ_WRITE_REG_BIT(aq_hw, rpf_et_valf_adr(filter), rpf_et_valf_msk,

sys/dev/aq/aq_hw_llh.c

686

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

688

AQ_WRITE_REG(aq_hw, rx_flr_mcst_flr_adr(filter), rx_flr_mcst_flr);

sys/dev/aq/aq_hw_llh.c

848

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

850

AQ_WRITE_REG_BIT(aq_hw, rpfl2mc_enf_adr(filter), rpfl2mc_enf_msk,

sys/dev/aq/aq_hw_llh.c

864

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

866

AQ_WRITE_REG_BIT(aq_hw, rpfl2uc_actf_adr(filter), rpfl2uc_actf_msk,

sys/dev/aq/aq_hw_llh.c

872

uint32_t filter)

sys/dev/aq/aq_hw_llh.c

874

AQ_WRITE_REG_BIT(aq_hw, rpfl2uc_enf_adr(filter), rpfl2uc_enf_msk,

sys/dev/aq/aq_hw_llh.c

880

uint32_t l2unicast_dest_addresslsw, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

882

AQ_WRITE_REG(aq_hw, rpfl2uc_daflsw_adr(filter),

sys/dev/aq/aq_hw_llh.c

888

uint32_t l2unicast_dest_addressmsw, uint32_t filter)

sys/dev/aq/aq_hw_llh.c

890

AQ_WRITE_REG_BIT(aq_hw, rpfl2uc_dafmsw_adr(filter), rpfl2uc_dafmsw_msk,

sys/dev/aq/aq_hw_llh.h

1101

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1105

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1109

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1113

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1117

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1121

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1125

uint32_t etht_user_priority_en, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1129

uint32_t etht_rx_queue_en, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1133

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1137

uint32_t etht_user_priority, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1141

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1145

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1149

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1153

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1157

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1161

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1165

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1169

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1173

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1177

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1181

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1185

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1189

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1193

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1197

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1201

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1204

void hw_atl_rpf_l4_spd_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

1207

void hw_atl_rpf_l4_dpd_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

393

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

487

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

495

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

499

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

503

uint32_t l2unicast_dest_addresslsw, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

507

uint32_t l2unicast_dest_addressmsw, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

572

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

576

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

580

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

584

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

588

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

592

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

596

uint32_t etht_user_priority_en, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

600

uint32_t etht_rx_queue_en, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

604

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

608

uint32_t etht_user_priority, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

612

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

616

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

620

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

624

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

628

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

632

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

636

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

640

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

644

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

648

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

652

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

656

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

660

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

664

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

668

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

672

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

675

void hw_atl_rpf_l4_spd_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

678

void hw_atl_rpf_l4_dpd_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

698

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

702

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

706

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

710

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

714

uint32_t etht_user_priority_en, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

718

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

722

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

726

uint32_t etht_user_priority, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

730

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

734

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

737

void rpf_etht_flr_set(struct aq_hw *aq_hw, uint32_t etht_flr, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

741

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

745

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

749

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

753

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

757

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

761

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

765

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

769

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

773

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

777

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

781

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

785

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

789

uint32_t filter);

sys/dev/aq/aq_hw_llh.h

792

void hw_atl_rpf_l4_spd_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter);

sys/dev/aq/aq_hw_llh.h

795

void hw_atl_rpf_l4_dpd_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter);

sys/dev/aq/aq_hw_llh_internal.h

1003

#define rpfl2uc_enf_adr(filter) (0x00005114 + (filter) * 0x8)

sys/dev/aq/aq_hw_llh_internal.h

1016

#define rpfl2uc_daflsw_adr(filter) (0x00005110 + (filter) * 0x8)

sys/dev/aq/aq_hw_llh_internal.h

1018

#define rpfl2uc_dafmsw_adr(filter) (0x00005114 + (filter) * 0x8)

sys/dev/aq/aq_hw_llh_internal.h

1288

#define rpf_vl_en_f_adr(filter) (0x00005290 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1307

#define rpf_vl_act_f_adr(filter) (0x00005290 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1326

#define rpf_vl_id_f_adr(filter) (0x00005290 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1345

#define rpf_et_en_f_adr(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1364

#define rpf_et_enf_adr(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1383

#define rpf_et_upfen_adr(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1402

#define rpf_et_rxqfen_adr(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1421

#define rpf_et_upf_adr(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1440

#define rpf_et_rxqf_adr(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1459

#define rpf_et_mng_rxqf_adr(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1478

#define rpf_et_actf_adr(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1497

#define rpf_et_valf_adr(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1606

#define HW_ATL_RPF_VL_EN_F_ADR(filter) (0x00005290 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1625

#define HW_ATL_RPF_VL_ACT_F_ADR(filter) (0x00005290 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1644

#define HW_ATL_RPF_VL_ID_F_ADR(filter) (0x00005290 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1663

#define HW_ATL_RPF_VL_RXQ_EN_F_ADR(filter) (0x00005290 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1682

#define HW_ATL_RPF_VL_RXQ_F_ADR(filter) (0x00005290 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1701

#define HW_ATL_RPF_ET_ENF_ADR(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1720

#define HW_ATL_RPF_ET_UPFEN_ADR(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1739

#define HW_ATL_RPF_ET_RXQFEN_ADR(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1758

#define HW_ATL_RPF_ET_UPF_ADR(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1777

#define HW_ATL_RPF_ET_RXQF_ADR(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1796

#define HW_ATL_RPF_ET_MNG_RXQF_ADR(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1815

#define HW_ATL_RPF_ET_ACTF_ADR(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1834

#define HW_ATL_RPF_ET_VALF_ADR(filter) (0x00005300 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1853

#define HW_ATL_RPF_L3_L4_ENF_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1871

#define HW_ATL_RPF_L3_V6_ENF_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1890

#define HW_ATL_RPF_L3_SAF_EN_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1909

#define HW_ATL_RPF_L3_DAF_EN_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1928

#define HW_ATL_RPF_L4_SPF_EN_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1947

#define HW_ATL_RPF_L4_DPF_EN_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1966

#define HW_ATL_RPF_L4_PROTF_EN_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

1985

#define HW_ATL_RPF_L3_ARPF_EN_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

2004

#define HW_ATL_RPF_L3_L4_RXQF_EN_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

2023

#define HW_ATL_RPF_L3_L4_MNG_RXQF_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

2042

#define HW_ATL_RPF_L3_L4_ACTF_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

2061

#define HW_ATL_RPF_L3_L4_RXQF_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

2080

#define HW_ATL_RPF_L4_PROTF_ADR(filter) (0x00005380u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

691

#define rx_flr_mcst_flr_adr(filter) (0x00005250u + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

947

#define rpfl2mc_enf_adr(filter) (0x00005250 + (filter) * 0x4)

sys/dev/aq/aq_hw_llh_internal.h

984

#define rpfl2uc_actf_adr(filter) (0x00005114 + (filter) * 0x8)

sys/dev/ata/ata-pci.c

322

int flags, driver_filter_t *filter, driver_intr_t *function,

sys/dev/ata/ata-pci.c

329

flags, filter, function, argument, cookiep);

sys/dev/ata/ata-pci.c

334

if (filter != NULL) {

sys/dev/ata/ata-pci.h

542

int ata_pci_setup_intr(device_t dev, device_t child, struct resource *irq, int flags, driver_filter_t *filter, driver_intr_t *function, void *argument, void **cookiep);

sys/dev/bhnd/bhnd.c

973

int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg,

sys/dev/bhnd/bhnd.c

976

return (bus_generic_setup_intr(dev, child, irq, flags, filter, intr,

sys/dev/bhnd/bhndb/bhnd_bhndb.c

140

int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg,

sys/dev/bhnd/bhndb/bhnd_bhndb.c

165

return (bhnd_generic_setup_intr(dev, child, irq, flags, filter, intr,

sys/dev/bhnd/bhndb/bhndb.c

1912

int flags, driver_filter_t filter, driver_intr_t handler, void *arg,

sys/dev/bhnd/bhndb/bhndb.c

1934

error = bus_setup_intr(isrc->is_owner, isrc->is_res, flags, filter,

sys/dev/bhnd/bhndvar.h

106

int flags, driver_filter_t *filter,

sys/dev/bhnd/cores/pmu/bhnd_pmu_subr.c

1046

pmu_res_filter filter;

sys/dev/bhnd/cores/pmu/bhnd_pmu_subr.c

1052

filter = rdep->filter;

sys/dev/bhnd/cores/pmu/bhnd_pmu_subr.c

1054

if (filter != NULL && !filter(sc))

sys/dev/bhnd/cores/pmu/bhnd_pmu_subr.c

462

pmu_res_filter filter; /* action is taken when filter is NULL or returns true */

sys/dev/bnxt/bnxt_en/hsi_struct_def.h

26068

uint8_t filter;

sys/dev/bnxt/bnxt_re/main.c

3023

req.filter = fn_info->filter;

sys/dev/bnxt/bnxt_re/main.c

3024

if (req.filter > HWRM_FUNC_HOST_PF_IDS_QUERY_INPUT_FILTER_ROCE)

sys/dev/bnxt/bnxt_re/main.c

3025

req.filter = HWRM_FUNC_HOST_PF_IDS_QUERY_INPUT_FILTER_ALL;

sys/dev/bnxt/bnxt_re/qplib_res.h

454

u32 filter;

sys/dev/bxe/ecore_sp.c

3508

#define ECORE_57711_SET_MC_FILTER(filter, bit) \

sys/dev/bxe/ecore_sp.c

3510

(filter)[(bit) >> 5] |= (1 << ((bit) & 0x1f)); \

sys/dev/cxgbe/firmware/t4fw_interface.h

919

__be32 filter;

sys/dev/dc/if_dc.c

1194

uint32_t filter, *sp;

sys/dev/dc/if_dc.c

1224

filter = CSR_READ_4(sc, DC_NETCFG);

sys/dev/dc/if_dc.c

1225

filter &= ~(DC_NETCFG_RX_PROMISC | DC_NETCFG_RX_ALLMULTI);

sys/dev/dc/if_dc.c

1231

filter |= DC_NETCFG_RX_ALLMULTI;

sys/dev/dc/if_dc.c

1239

if (filter & (DC_NETCFG_TX_ON | DC_NETCFG_RX_ON))

sys/dev/dc/if_dc.c

1241

filter & ~(DC_NETCFG_TX_ON | DC_NETCFG_RX_ON));

sys/dev/dc/if_dc.c

1243

filter |= DC_NETCFG_RX_PROMISC | DC_NETCFG_RX_ALLMULTI;

sys/dev/dc/if_dc.c

1245

filter |= DC_NETCFG_RX_ALLMULTI;

sys/dev/dc/if_dc.c

1247

filter & ~(DC_NETCFG_TX_ON | DC_NETCFG_RX_ON));

sys/dev/dc/if_dc.c

1248

if (filter & (DC_NETCFG_TX_ON | DC_NETCFG_RX_ON))

sys/dev/dc/if_dc.c

1249

CSR_WRITE_4(sc, DC_NETCFG, filter);

sys/dev/dpaa2/dpaa2_rc.c

334

int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg,

sys/dev/dpaa2/dpaa2_rc.c

343

error = bus_generic_setup_intr(rcdev, child, irq, flags, filter, intr,

sys/dev/hyperv/netvsc/hn_rndis.c

829

hn_rndis_set_rxfilter(struct hn_softc *sc, uint32_t filter)

sys/dev/hyperv/netvsc/hn_rndis.c

834

&filter, sizeof(filter));

sys/dev/hyperv/netvsc/hn_rndis.c

837

filter, error);

sys/dev/hyperv/netvsc/hn_rndis.c

841

filter);

sys/dev/hyperv/netvsc/hn_rndis.h

44

int hn_rndis_set_rxfilter(struct hn_softc *sc, uint32_t filter);

sys/dev/hyperv/netvsc/if_hn.c

4501

uint32_t filter;

sys/dev/hyperv/netvsc/if_hn.c

4504

filter = sc->hn_rx_filter;

sys/dev/hyperv/netvsc/if_hn.c

4506

snprintf(filter_str, sizeof(filter_str), "%b", filter,

sys/dev/hyperv/netvsc/if_hn.c

898

hn_set_rxfilter(struct hn_softc *sc, uint32_t filter)

sys/dev/hyperv/netvsc/if_hn.c

904

if (sc->hn_rx_filter != filter) {

sys/dev/hyperv/netvsc/if_hn.c

905

error = hn_rndis_set_rxfilter(sc, filter);

sys/dev/hyperv/netvsc/if_hn.c

907

sc->hn_rx_filter = filter;

sys/dev/hyperv/netvsc/if_hn.c

916

uint32_t filter;

sys/dev/hyperv/netvsc/if_hn.c

926

filter = NDIS_PACKET_TYPE_PROMISCUOUS;

sys/dev/hyperv/netvsc/if_hn.c

928

filter = NDIS_PACKET_TYPE_DIRECTED;

sys/dev/hyperv/netvsc/if_hn.c

930

filter |= NDIS_PACKET_TYPE_BROADCAST;

sys/dev/hyperv/netvsc/if_hn.c

934

filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;

sys/dev/hyperv/netvsc/if_hn.c

936

return (hn_set_rxfilter(sc, filter));

sys/dev/iwn/if_iwn.c

2915

sc->rxon->filter &= ~htole32(IWN_FILTER_BSS);

sys/dev/iwn/if_iwn.c

5546

sc->rxon->filter |= htole32(promisc_filter);

sys/dev/iwn/if_iwn.c

5548

sc->rxon->filter &= ~htole32(promisc_filter);

sys/dev/iwn/if_iwn.c

6685

return ((sc->rxon->filter & htole32(IWN_FILTER_BSS)) != 0);

sys/dev/iwn/if_iwn.c

6695

cmd.filter = rxon->filter;

sys/dev/iwn/if_iwn.c

6713

cmd.filter = rxon->filter;

sys/dev/iwn/if_iwn.c

6877

sc->rxon->filter = htole32(IWN_FILTER_MULTICAST);

sys/dev/iwn/if_iwn.c

7092

hdr->filter = htole32(IWN_FILTER_MULTICAST | IWN_FILTER_BEACON);

sys/dev/iwn/if_iwn.c

7384

sc->rxon->filter |= htole32(IWN_FILTER_BSS);

sys/dev/iwn/if_iwnreg.h

1261

uint32_t filter;

sys/dev/iwn/if_iwnreg.h

597

uint32_t filter;

sys/dev/iwn/if_iwnreg.h

622

uint32_t filter;

sys/dev/iwn/if_iwnreg.h

634

uint32_t filter;

sys/dev/iwn/if_iwnreg.h

650

uint32_t filter;

sys/dev/iwn/if_iwnreg.h

935

uint32_t filter;

sys/dev/ixl/i40e_adminq_cmd.h

636

u8 filter[128];

sys/dev/ixl/i40e_common.c

7640

struct i40e_aqc_set_wol_filter_data *filter,

sys/dev/ixl/i40e_common.c

7660

if (!filter)

sys/dev/ixl/i40e_common.c

7677

buff_len = sizeof(*filter);

sys/dev/ixl/i40e_common.c

7683

cmd->address_high = CPU_TO_LE32(I40E_HI_DWORD((u64)filter));

sys/dev/ixl/i40e_common.c

7684

cmd->address_low = CPU_TO_LE32(I40E_LO_DWORD((u64)filter));

sys/dev/ixl/i40e_common.c

7686

status = i40e_asq_send_command(hw, &desc, filter,

sys/dev/ixl/i40e_prototype.h

615

struct i40e_aqc_set_wol_filter_data *filter,

sys/dev/ixl/if_ixl.c

505

struct i40e_filter_control_settings filter;

sys/dev/ixl/if_ixl.c

643

bzero(&filter, sizeof(filter));

sys/dev/ixl/if_ixl.c

644

filter.enable_ethtype = TRUE;

sys/dev/ixl/if_ixl.c

645

filter.enable_macvlan = TRUE;

sys/dev/ixl/if_ixl.c

646

filter.enable_fdir = FALSE;

sys/dev/ixl/if_ixl.c

647

filter.hash_lut_size = I40E_HASH_LUT_SIZE_512;

sys/dev/ixl/if_ixl.c

648

if (i40e_set_filter_control(hw, &filter))

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

131

struct mlx4_en_filter *filter = container_of(work,

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

134

struct mlx4_en_priv *priv = filter->priv;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

136

.id = mlx4_ip_proto_to_trans_rule_id(filter->ip_proto),

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

139

.dst_port = filter->dst_port,

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

141

.src_port = filter->src_port,

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

150

.dst_ip = filter->dst_ip,

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

152

.src_ip = filter->src_ip,

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

174

filter->ip_proto);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

181

rule.qpn = priv->rss_map.qps[filter->rxq_index].qpn;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

185

filter->activated = 0;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

187

if (filter->reg_id) {

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

188

rc = mlx4_flow_detach(priv->mdev->dev, filter->reg_id);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

193

rc = mlx4_flow_attach(priv->mdev->dev, &rule, &filter->reg_id);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

200

filter->activated = 1;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

224

struct mlx4_en_filter *filter = NULL;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

226

filter = kzalloc(sizeof(struct mlx4_en_filter), GFP_ATOMIC);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

227

if (!filter)

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

230

filter->priv = priv;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

231

filter->rxq_index = rxq_index;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

232

INIT_WORK(&filter->work, mlx4_en_filter_work);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

234

filter->src_ip = src_ip;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

235

filter->dst_ip = dst_ip;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

236

filter->ip_proto = ip_proto;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

237

filter->src_port = src_port;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

238

filter->dst_port = dst_port;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

240

filter->flow_id = flow_id;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

242

filter->id = priv->last_filter_id++ % RPS_NO_FILTER;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

244

list_add_tail(&filter->next, &priv->filters);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

245

hlist_add_head(&filter->filter_chain,

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

249

return filter;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

252

static void mlx4_en_filter_free(struct mlx4_en_filter *filter)

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

254

struct mlx4_en_priv *priv = filter->priv;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

257

list_del(&filter->next);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

259

rc = mlx4_flow_detach(priv->mdev->dev, filter->reg_id);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

263

kfree(filter);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

270

struct mlx4_en_filter *filter;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

273

hlist_for_each_entry(filter,

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

277

if (filter->src_ip == src_ip &&

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

278

filter->dst_ip == dst_ip &&

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

279

filter->ip_proto == ip_proto &&

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

280

filter->src_port == src_port &&

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

281

filter->dst_port == dst_port) {

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

282

ret = filter;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

295

struct mlx4_en_filter *filter;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

324

filter = mlx4_en_filter_find(priv, src_ip, dst_ip, ip_proto,

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

326

if (filter) {

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

327

if (filter->rxq_index == rxq_index)

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

330

filter->rxq_index = rxq_index;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

332

filter = mlx4_en_filter_alloc(priv, rxq_index,

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

335

if (!filter) {

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

341

queue_work(priv->mdev->workqueue, &filter->work);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

344

ret = filter->id;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

353

struct mlx4_en_filter *filter, *tmp;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

357

list_for_each_entry_safe(filter, tmp, &priv->filters, next) {

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

358

list_move(&filter->next, &del_list);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

359

hlist_del(&filter->filter_chain);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

363

list_for_each_entry_safe(filter, tmp, &del_list, next) {

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

364

cancel_work_sync(&filter->work);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

365

mlx4_en_filter_free(filter);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

371

struct mlx4_en_filter *filter = NULL, *tmp, *last_filter = NULL;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

376

list_for_each_entry_safe(filter, tmp, &priv->filters, next) {

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

380

if (filter->activated &&

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

381

!work_pending(&filter->work) &&

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

383

filter->rxq_index, filter->flow_id,

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

384

filter->id)) {

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

385

list_move(&filter->next, &del_list);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

386

hlist_del(&filter->filter_chain);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

388

last_filter = filter;

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

398

list_for_each_entry_safe(filter, tmp, &del_list, next)

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

399

mlx4_en_filter_free(filter);

sys/dev/mlx4/mlx4_en/mlx4_en_port.c

47

struct mlx4_set_vlan_fltr_mbox *filter;

sys/dev/mlx4/mlx4_en/mlx4_en_port.c

58

filter = mailbox->buf;

sys/dev/mlx4/mlx4_en/mlx4_en_port.c

66

filter->entry[i] = cpu_to_be32(entry);

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

1287

#define FIELDS_NOT_SUPPORTED(filter, field)\

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

1288

memchr_inv((void *)&filter.field +\

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

1289

sizeof(filter.field), 0,\

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

1290

sizeof(filter) -\

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

1291

offsetof(typeof(filter), field) -\

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

1292

sizeof(filter.field))

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1821

#define FIELDS_NOT_SUPPORTED(filter, field)\

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1822

memchr_inv((void *)&filter.field +\

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1823

sizeof(filter.field), 0,\

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1824

sizeof(filter) -\

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1825

offsetof(typeof(filter), field) -\

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1826

sizeof(filter.field))

sys/dev/mpt/mpt.h

220

lowaddr, highaddr, filter, filterarg, \

sys/dev/mpt/mpt.h

224

lowaddr, highaddr, filter, filterarg, \

sys/dev/mvs/mvs_pci.c

443

int flags, driver_filter_t *filter, driver_intr_t *function,

sys/dev/mvs/mvs_pci.c

449

if (filter != NULL) {

sys/dev/mvs/mvs_soc.c

382

int flags, driver_filter_t *filter, driver_intr_t *function,

sys/dev/mvs/mvs_soc.c

388

if (filter != NULL) {

sys/dev/nfe/if_nfe.c

2538

uint32_t filter;

sys/dev/nfe/if_nfe.c

2573

filter = NFE_READ(sc, NFE_RXFILTER);

sys/dev/nfe/if_nfe.c

2574

filter &= NFE_PFF_RX_PAUSE;

sys/dev/nfe/if_nfe.c

2575

filter |= NFE_RXFILTER_MAGIC;

sys/dev/nfe/if_nfe.c

2576

filter |= (if_getflags(ifp) & IFF_PROMISC) ? NFE_PFF_PROMISC : NFE_PFF_U2M;

sys/dev/nfe/if_nfe.c

2577

NFE_WRITE(sc, NFE_RXFILTER, filter);

sys/dev/ocs_fc/ocs_pci.c

816

driver_filter_t *filter = NULL;

sys/dev/ocs_fc/ocs_pci.c

819

filter = ocs_pci_intx_filter;

sys/dev/ocs_fc/ocs_pci.c

823

filter, ocs_pci_intr, &ocs->intr_ctx,

sys/dev/pci/pci.c

4837

driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep)

sys/dev/pci/pci.c

4847

error = bus_generic_setup_intr(dev, child, irq, flags, filter, intr,

sys/dev/pci/vga_pci.c

399

int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg,

sys/dev/pci/vga_pci.c

403

filter, intr, arg, cookiep));

sys/dev/qlnx/qlnxe/ecore_dev.c

1170

union ecore_llh_filter filter;

sys/dev/qlnx/qlnxe/ecore_dev.c

1181

OSAL_MEM_ZERO(&filter, sizeof(filter));

sys/dev/qlnx/qlnxe/ecore_dev.c

1182

OSAL_MEMCPY(filter.mac.addr, mac_addr, ETH_ALEN);

sys/dev/qlnx/qlnxe/ecore_dev.c

1185

&filter, &filter_idx, &ref_cnt);

sys/dev/qlnx/qlnxe/ecore_dev.c

1307

union ecore_llh_filter filter;

sys/dev/qlnx/qlnxe/ecore_dev.c

1323

OSAL_MEM_ZERO(&filter, sizeof(filter));

sys/dev/qlnx/qlnxe/ecore_dev.c

1324

filter.protocol.type = type;

sys/dev/qlnx/qlnxe/ecore_dev.c

1325

filter.protocol.source_port_or_eth_type = source_port_or_eth_type;

sys/dev/qlnx/qlnxe/ecore_dev.c

1326

filter.protocol.dest_port = dest_port;

sys/dev/qlnx/qlnxe/ecore_dev.c

1329

&filter, &filter_idx, &ref_cnt);

sys/dev/qlnx/qlnxe/ecore_dev.c

1373

union ecore_llh_filter filter;

sys/dev/qlnx/qlnxe/ecore_dev.c

1384

OSAL_MEM_ZERO(&filter, sizeof(filter));

sys/dev/qlnx/qlnxe/ecore_dev.c

1385

OSAL_MEMCPY(filter.mac.addr, mac_addr, ETH_ALEN);

sys/dev/qlnx/qlnxe/ecore_dev.c

1386

rc = ecore_llh_shadow_remove_filter(p_dev, ppfid, &filter, &filter_idx,

sys/dev/qlnx/qlnxe/ecore_dev.c

1428

union ecore_llh_filter filter;

sys/dev/qlnx/qlnxe/ecore_dev.c

1444

OSAL_MEM_ZERO(&filter, sizeof(filter));

sys/dev/qlnx/qlnxe/ecore_dev.c

1445

filter.protocol.type = type;

sys/dev/qlnx/qlnxe/ecore_dev.c

1446

filter.protocol.source_port_or_eth_type = source_port_or_eth_type;

sys/dev/qlnx/qlnxe/ecore_dev.c

1447

filter.protocol.dest_port = dest_port;

sys/dev/qlnx/qlnxe/ecore_dev.c

1448

rc = ecore_llh_shadow_remove_filter(p_dev, ppfid, &filter, &filter_idx,

sys/dev/qlnx/qlnxe/ecore_dev.c

426

union ecore_llh_filter filter;

sys/dev/qlnx/qlnxe/ecore_dev.c

541

if (!OSAL_MEMCMP(p_filter, &p_filters[i].filter,

sys/dev/qlnx/qlnxe/ecore_dev.c

594

OSAL_MEMCPY(&p_filters[filter_idx].filter, p_filter,

sys/dev/qlnx/qlnxe/ecore_dev.c

595

sizeof(p_filters[filter_idx].filter));

sys/dev/qlnx/qlnxe/ecore_sriov.c

1952

struct ecore_filter_ucast filter;

sys/dev/qlnx/qlnxe/ecore_sriov.c

1956

OSAL_MEMSET(&filter, 0, sizeof(filter));

sys/dev/qlnx/qlnxe/ecore_sriov.c

1957

filter.is_rx_filter = 1;

sys/dev/qlnx/qlnxe/ecore_sriov.c

1958

filter.is_tx_filter = 1;

sys/dev/qlnx/qlnxe/ecore_sriov.c

1959

filter.vport_to_add_to = p_vf->vport_id;

sys/dev/qlnx/qlnxe/ecore_sriov.c

1960

filter.opcode = ECORE_FILTER_ADD;

sys/dev/qlnx/qlnxe/ecore_sriov.c

1967

filter.type = ECORE_FILTER_VLAN;

sys/dev/qlnx/qlnxe/ecore_sriov.c

1968

filter.vlan = p_vf->shadow_config.vlans[i].vid;

sys/dev/qlnx/qlnxe/ecore_sriov.c

1971

filter.vlan, p_vf->relative_vf_id);

sys/dev/qlnx/qlnxe/ecore_sriov.c

1973

&filter, ECORE_SPQ_MODE_CB, OSAL_NULL);

sys/dev/qlnx/qlnxe/ecore_sriov.c

1976

filter.vlan,

sys/dev/qlnx/qlnxe/ecore_sriov.c

2007

struct ecore_filter_ucast filter;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2016

OSAL_MEMSET(&filter, 0, sizeof(filter));

sys/dev/qlnx/qlnxe/ecore_sriov.c

2017

filter.type = ECORE_FILTER_MAC;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2018

filter.opcode = ECORE_FILTER_REPLACE;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2019

filter.is_rx_filter = 1;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2020

filter.is_tx_filter = 1;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2021

filter.vport_to_add_to = p_vf->vport_id;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2022

OSAL_MEMCPY(filter.mac,

sys/dev/qlnx/qlnxe/ecore_sriov.c

2027

&filter,

sys/dev/qlnx/qlnxe/ecore_sriov.c

2043

OSAL_MEMSET(&filter, 0, sizeof(filter));

sys/dev/qlnx/qlnxe/ecore_sriov.c

2044

filter.type = ECORE_FILTER_VLAN;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2045

filter.is_rx_filter = 1;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2046

filter.is_tx_filter = 1;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2047

filter.vport_to_add_to = p_vf->vport_id;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2048

filter.vlan = p_vf->bulletin.p_virt->pvid;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2049

filter.opcode = filter.vlan ? ECORE_FILTER_REPLACE :

sys/dev/qlnx/qlnxe/ecore_sriov.c

2054

&filter,

sys/dev/qlnx/qlnxe/ecore_sriov.c

2067

vport_update.default_vlan_enable_flg = filter.vlan ? 1 : 0;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2069

vport_update.default_vlan = filter.vlan;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2072

removal = filter.vlan ?

sys/dev/qlnx/qlnxe/ecore_sriov.c

2075

vport_update.silent_vlan_removal_flg = filter.vlan ? 1 : 0;

sys/dev/qlnx/qlnxe/ecore_sriov.c

2108

if (filter.vlan)

sys/dev/qlnx/qlnxe/qlnx_def.h

443

uint8_t filter;

sys/dev/qlnx/qlnxe/qlnx_os.c

138

static int qlnx_set_rx_accept_filter(qlnx_host_t *ha, uint8_t filter);

sys/dev/qlnx/qlnxe/qlnx_os.c

2499

uint8_t filter;

sys/dev/qlnx/qlnxe/qlnx_os.c

2502

filter = ha->filter;

sys/dev/qlnx/qlnxe/qlnx_os.c

2503

filter |= ECORE_ACCEPT_UCAST_MATCHED;

sys/dev/qlnx/qlnxe/qlnx_os.c

2504

filter |= ECORE_ACCEPT_MCAST_MATCHED;

sys/dev/qlnx/qlnxe/qlnx_os.c

2505

filter |= ECORE_ACCEPT_BCAST;

sys/dev/qlnx/qlnxe/qlnx_os.c

2511

filter |= ECORE_ACCEPT_MCAST_UNMATCHED;

sys/dev/qlnx/qlnxe/qlnx_os.c

2513

filter &= ~ECORE_ACCEPT_MCAST_UNMATCHED;

sys/dev/qlnx/qlnxe/qlnx_os.c

2516

filter |= ECORE_ACCEPT_UCAST_UNMATCHED;

sys/dev/qlnx/qlnxe/qlnx_os.c

2518

filter &= ~ECORE_ACCEPT_UCAST_UNMATCHED;

sys/dev/qlnx/qlnxe/qlnx_os.c

2520

if (filter == ha->filter)

sys/dev/qlnx/qlnxe/qlnx_os.c

2523

rc = qlnx_set_rx_accept_filter(ha, filter);

sys/dev/qlnx/qlnxe/qlnx_os.c

2525

ha->filter = filter;

sys/dev/qlnx/qlnxe/qlnx_os.c

6877

ha->filter = 0;

sys/dev/qlnx/qlnxe/qlnx_os.c

6895

qlnx_set_rx_accept_filter(qlnx_host_t *ha, uint8_t filter)

sys/dev/qlnx/qlnxe/qlnx_os.c

6906

accept.rx_accept_filter = filter;

sys/dev/rtwn/if_rtwn_rx.c

480

uint16_t filter;

sys/dev/rtwn/if_rtwn_rx.c

482

filter = 0x7f7f;

sys/dev/rtwn/if_rtwn_rx.c

484

filter &= ~(

sys/dev/rtwn/if_rtwn_rx.c

490

filter &= ~(

sys/dev/rtwn/if_rtwn_rx.c

494

rtwn_write_2(sc, R92C_RXFLTMAP0, filter);

sys/dev/sfxge/common/efx_filter.c

1042

__out efx_oword_t *filter,

sys/dev/sfxge/common/efx_filter.c

1054

EFX_POPULATE_OWORD_7(*filter,

sys/dev/sfxge/common/efx_filter.c

1070

EFX_POPULATE_OWORD_7(*filter,

sys/dev/sfxge/common/efx_filter.c

1087

EFX_POPULATE_OWORD_5(*filter,

sys/dev/sfxge/common/efx_filter.c

1099

EFX_POPULATE_OWORD_5(*filter,

sys/dev/sfxge/common/efx_filter.c

1111

EFX_ZERO_OWORD(*filter);

sys/dev/sfxge/common/efx_filter.c

1243

efx_oword_t filter;

sys/dev/sfxge/common/efx_filter.c

1248

EFX_ZERO_OWORD(filter);

sys/dev/sfxge/common/efx_filter.c

1251

index, &filter);

sys/dev/sfxge/common/efx_filter.c

1412

efx_oword_t filter;

sys/dev/sfxge/common/efx_filter.c

1429

if ((key = siena_filter_build(&filter, spec)) == 0) {

sys/dev/sfxge/common/efx_filter.c

1434

spec->sfs_type, filter_idx, &filter)) != 0)

sys/dev/sfxge/common/efx_filter.c

1469

efx_oword_t filter;

sys/dev/sfxge/common/efx_filter.c

1488

key = siena_filter_build(&filter, &sf_spec);

sys/dev/sfxge/common/efx_filter.c

1519

filter_idx, &filter);

sys/dev/sfxge/common/efx_filter.c

1549

efx_oword_t filter;

sys/dev/sfxge/common/efx_filter.c

1563

key = siena_filter_build(&filter, &sf_spec);

sys/dev/sfxge/sfxge_intr.c

165

driver_filter_t *filter;

sys/dev/sfxge/sfxge_intr.c

175

filter = NULL; /* not shared */

sys/dev/sfxge/sfxge_intr.c

180

filter = sfxge_intr_line_filter;

sys/dev/sfxge/sfxge_intr.c

192

INTR_MPSAFE|INTR_TYPE_NET, filter, handler,

sys/dev/siis/siis.c

367

int flags, driver_filter_t *filter, driver_intr_t *function,

sys/dev/siis/siis.c

373

if (filter != NULL) {

sys/dev/sis/if_sis.c

717

uint32_t i, filter;

sys/dev/sis/if_sis.c

720

filter = CSR_READ_4(sc, SIS_RXFILT_CTL);

sys/dev/sis/if_sis.c

721

if (filter & SIS_RXFILTCTL_ENABLE) {

sys/dev/sis/if_sis.c

725

CSR_WRITE_4(sc, SIS_RXFILT_CTL, filter & ~SIS_RXFILTCTL_ENABLE);

sys/dev/sis/if_sis.c

728

filter &= ~(NS_RXFILTCTL_ARP | NS_RXFILTCTL_PERFECT |

sys/dev/sis/if_sis.c

733

filter |= SIS_RXFILTCTL_BROAD;

sys/dev/sis/if_sis.c

740

filter |= NS_RXFILTCTL_ARP | NS_RXFILTCTL_PERFECT;

sys/dev/sis/if_sis.c

743

filter |= SIS_RXFILTCTL_ALLMULTI;

sys/dev/sis/if_sis.c

745

filter |= SIS_RXFILTCTL_ALLPHYS;

sys/dev/sis/if_sis.c

751

filter |= NS_RXFILTCTL_MCHASH;

sys/dev/sis/if_sis.c

764

CSR_WRITE_4(sc, SIS_RXFILT_CTL, filter | SIS_RXFILTCTL_ENABLE);

sys/dev/sis/if_sis.c

790

uint32_t filter, i, n;

sys/dev/sis/if_sis.c

800

filter = CSR_READ_4(sc, SIS_RXFILT_CTL);

sys/dev/sis/if_sis.c

801

if (filter & SIS_RXFILTCTL_ENABLE) {

sys/dev/sis/if_sis.c

802

CSR_WRITE_4(sc, SIS_RXFILT_CTL, filter & ~SIS_RXFILTCTL_ENABLE);

sys/dev/sis/if_sis.c

805

filter &= ~(SIS_RXFILTCTL_ALLPHYS | SIS_RXFILTCTL_BROAD |

sys/dev/sis/if_sis.c

808

filter |= SIS_RXFILTCTL_BROAD;

sys/dev/sis/if_sis.c

811

filter |= SIS_RXFILTCTL_ALLMULTI;

sys/dev/sis/if_sis.c

813

filter |= SIS_RXFILTCTL_ALLPHYS;

sys/dev/sis/if_sis.c

821

filter |= SIS_RXFILTCTL_ALLMULTI;

sys/dev/sis/if_sis.c

833

CSR_WRITE_4(sc, SIS_RXFILT_CTL, filter | SIS_RXFILTCTL_ENABLE);

sys/dev/sound/pci/csa.c

408

driver_filter_t *filter,

sys/dev/sound/pci/csa.c

415

if (filter != NULL) {

sys/dev/sound/pci/csa.c

88

driver_filter_t *filter,

sys/dev/usb/net/if_urndis.c

223

uint32_t filter;

sys/dev/usb/net/if_urndis.c

224

} filter;

sys/dev/usb/net/if_urndis.c

299

msg.filter.filter = htole32(sc->sc_filter);

sys/dev/usb/net/if_urndis.c

302

(struct rndis_set_req *)&msg.filter, sizeof(msg.filter));

sys/dev/usb/net/if_urndis.c

637

uint32_t filter;

sys/dev/usb/net/if_urndis.c

640

msg_filter.filter = htole32(sc->sc_filter);

sys/dev/usb/wlan/if_upgt.c

586

struct upgt_lmac_filter *filter;

sys/dev/usb/wlan/if_upgt.c

605

filter = (struct upgt_lmac_filter *)(mem + 1);

sys/dev/usb/wlan/if_upgt.c

607

filter->header1.flags = UPGT_H1_FLAGS_TX_NO_CALLBACK;

sys/dev/usb/wlan/if_upgt.c

608

filter->header1.type = UPGT_H1_TYPE_CTRL;

sys/dev/usb/wlan/if_upgt.c

609

filter->header1.len = htole16(

sys/dev/usb/wlan/if_upgt.c

613

filter->header2.reqid = htole32(sc->sc_memaddr_frame_start);

sys/dev/usb/wlan/if_upgt.c

614

filter->header2.type = htole16(UPGT_H2_TYPE_MACFILTER);

sys/dev/usb/wlan/if_upgt.c

615

filter->header2.flags = 0;

sys/dev/usb/wlan/if_upgt.c

621

filter->type = htole16(UPGT_FILTER_TYPE_RESET);

sys/dev/usb/wlan/if_upgt.c

627

filter->type = htole16(UPGT_FILTER_TYPE_NONE);

sys/dev/usb/wlan/if_upgt.c

628

IEEE80211_ADDR_COPY(filter->dst,

sys/dev/usb/wlan/if_upgt.c

630

IEEE80211_ADDR_COPY(filter->src, ieee80211broadcastaddr);

sys/dev/usb/wlan/if_upgt.c

631

filter->unknown1 = htole16(UPGT_FILTER_UNKNOWN1);

sys/dev/usb/wlan/if_upgt.c

632

filter->rxaddr = htole32(sc->sc_memaddr_rx_start);

sys/dev/usb/wlan/if_upgt.c

633

filter->unknown2 = htole16(UPGT_FILTER_UNKNOWN2);

sys/dev/usb/wlan/if_upgt.c

634

filter->rxhw = htole32(sc->sc_eeprom_hwrx);

sys/dev/usb/wlan/if_upgt.c

635

filter->unknown3 = htole16(UPGT_FILTER_UNKNOWN3);

sys/dev/usb/wlan/if_upgt.c

641

filter->type = htole16(UPGT_FILTER_TYPE_MONITOR);

sys/dev/usb/wlan/if_upgt.c

642

IEEE80211_ADDR_COPY(filter->dst,

sys/dev/usb/wlan/if_upgt.c

644

IEEE80211_ADDR_COPY(filter->src, ni->ni_bssid);

sys/dev/usb/wlan/if_upgt.c

645

filter->unknown1 = htole16(UPGT_FILTER_MONITOR_UNKNOWN1);

sys/dev/usb/wlan/if_upgt.c

646

filter->rxaddr = htole32(sc->sc_memaddr_rx_start);

sys/dev/usb/wlan/if_upgt.c

647

filter->unknown2 = htole16(UPGT_FILTER_MONITOR_UNKNOWN2);

sys/dev/usb/wlan/if_upgt.c

648

filter->rxhw = htole32(sc->sc_eeprom_hwrx);

sys/dev/usb/wlan/if_upgt.c

649

filter->unknown3 = htole16(UPGT_FILTER_MONITOR_UNKNOWN3);

sys/dev/usb/wlan/if_upgt.c

654

filter->type = htole16(UPGT_FILTER_TYPE_STA);

sys/dev/usb/wlan/if_upgt.c

655

IEEE80211_ADDR_COPY(filter->dst,

sys/dev/usb/wlan/if_upgt.c

657

IEEE80211_ADDR_COPY(filter->src, ni->ni_bssid);

sys/dev/usb/wlan/if_upgt.c

658

filter->unknown1 = htole16(UPGT_FILTER_UNKNOWN1);

sys/dev/usb/wlan/if_upgt.c

659

filter->rxaddr = htole32(sc->sc_memaddr_rx_start);

sys/dev/usb/wlan/if_upgt.c

660

filter->unknown2 = htole16(UPGT_FILTER_UNKNOWN2);

sys/dev/usb/wlan/if_upgt.c

661

filter->rxhw = htole32(sc->sc_eeprom_hwrx);

sys/dev/usb/wlan/if_upgt.c

662

filter->unknown3 = htole16(UPGT_FILTER_UNKNOWN3);

sys/dev/usb/wlan/if_upgt.c

672

data_cmd->buflen = sizeof(*mem) + sizeof(*filter);

sys/dev/usb/wlan/if_upgt.c

674

mem->chksum = upgt_chksum_le((uint32_t *)filter,

sys/dev/virtio/network/if_vtnet.c

3776

struct vtnet_mac_filter *filter = arg;

sys/dev/virtio/network/if_vtnet.c

3779

bcopy(LLADDR(sdl), &filter->vmf_multicast.macs[mcnt],

sys/dev/virtio/network/if_vtnet.c

3789

struct vtnet_mac_filter *filter;

sys/dev/virtio/network/if_vtnet.c

3799

filter = sc->vtnet_mac_filter;

sys/dev/virtio/network/if_vtnet.c

3817

mcnt = if_foreach_llmaddr(ifp, vtnet_copy_maddr, filter);

sys/dev/virtio/network/if_vtnet.c

3830

filter->vmf_unicast.nentries = vtnet_gtoh32(sc, ucnt);

sys/dev/virtio/network/if_vtnet.c

3831

filter->vmf_multicast.nentries = vtnet_gtoh32(sc, mcnt);

sys/dev/virtio/network/if_vtnet.c

3839

error |= sglist_append(&sg, &filter->vmf_unicast,

sys/dev/virtio/network/if_vtnet.c

3841

error |= sglist_append(&sg, &filter->vmf_multicast,

sys/dev/wpi/if_wpi.c

1656

return (sc->rxon.filter & htole32(WPI_FILTER_BSS)) != 0;

sys/dev/wpi/if_wpi.c

1760

sc->rxon.filter &= ~htole32(WPI_FILTER_BSS);

sys/dev/wpi/if_wpi.c

1809

sc->rxon.filter &= ~htole32(WPI_FILTER_BSS);

sys/dev/wpi/if_wpi.c

3567

sc->rxon.filter |= htole32(promisc_filter);

sys/dev/wpi/if_wpi.c

3569

sc->rxon.filter &= ~htole32(promisc_filter);

sys/dev/wpi/if_wpi.c

3874

rxon_assoc.filter = sc->rxon.filter;

sys/dev/wpi/if_wpi.c

3964

sc->rxon.filter = WPI_FILTER_MULTICAST;

sys/dev/wpi/if_wpi.c

3971

sc->rxon.filter |= WPI_FILTER_BEACON;

sys/dev/wpi/if_wpi.c

3976

sc->rxon.filter |= WPI_FILTER_ASSOC | WPI_FILTER_PROMISC;

sys/dev/wpi/if_wpi.c

3989

sc->rxon.filter = htole32(sc->rxon.filter);

sys/dev/wpi/if_wpi.c

4153

hdr->filter = htole32(WPI_FILTER_MULTICAST | WPI_FILTER_BEACON);

sys/dev/wpi/if_wpi.c

4300

sc->rxon.filter &= ~htole32(WPI_FILTER_BSS);

sys/dev/wpi/if_wpi.c

4540

sc->rxon.filter |= htole32(WPI_FILTER_BSS);

sys/dev/wpi/if_wpireg.h

395

uint32_t filter;

sys/dev/wpi/if_wpireg.h

411

uint32_t filter;

sys/dev/wpi/if_wpireg.h

625

uint32_t filter;

sys/dev/xen/bus/intr-internal.h

86

driver_filter_t filter, driver_intr_t handler, void *arg,

sys/dev/xen/bus/xen_intr.c

1042

xen_intr_add_handler(const char *name, driver_filter_t filter,

sys/dev/xen/bus/xen_intr.c

1053

error = xen_arch_intr_add_handler(name, filter, handler, arg,

sys/dev/xen/bus/xen_intr.c

255

enum evtchn_type type, const char *intr_owner, driver_filter_t filter,

sys/dev/xen/bus/xen_intr.c

299

if (filter != NULL || handler != NULL) {

sys/dev/xen/bus/xen_intr.c

300

error = xen_intr_add_handler(intr_owner, filter, handler, arg,

sys/dev/xen/bus/xen_intr.c

762

driver_filter_t filter, driver_intr_t handler, void *arg,

sys/dev/xen/bus/xen_intr.c

769

device_get_nameunit(dev), filter, handler, arg, flags,

sys/dev/xen/bus/xen_intr.c

784

driver_filter_t filter, driver_intr_t handler, void *arg,

sys/dev/xen/bus/xen_intr.c

804

device_get_nameunit(dev), filter, handler, arg, flags,

sys/dev/xen/bus/xen_intr.c

819

u_int remote_port, driver_filter_t filter, driver_intr_t handler,

sys/dev/xen/bus/xen_intr.c

839

EVTCHN_TYPE_PORT, device_get_nameunit(dev), filter, handler, arg,

sys/dev/xen/bus/xen_intr.c

858

driver_filter_t filter, driver_intr_t handler, void *arg,

sys/dev/xen/bus/xen_intr.c

877

device_get_nameunit(dev), filter, handler, arg, flags,

sys/dev/xen/bus/xen_intr.c

917

xen_intr_alloc_and_bind_ipi(u_int cpu, driver_filter_t filter,

sys/dev/xen/bus/xen_intr.c

941

name, filter, NULL, NULL, flags, port_handlep);

sys/kern/kern_event.c

1397

kev11.filter = kevp->filter;

sys/kern/kern_event.c

1429

kevp->filter = kev11.filter;

sys/kern/kern_event.c

1506

if (!kevp->filter)

sys/kern/kern_event.c

1673

filt = kev->filter;

sys/kern/kern_event.c

1744

if (kev->filter == kn->kn_filter)

sys/kern/kern_event.c

1760

if (kev->filter == EVFILT_PROC &&

sys/kern/kern_event.c

1775

kev->filter == kn->kn_filter)

sys/kern/kern_event.c

2966

kqueue_fo_release(kn->kn_kevent.filter);

sys/kern/kern_event.c

3101

(void)kqueue_fo_find(kn->kn_kevent.filter);

sys/kern/kern_event.c

3104

kqueue_fo_release(kn->kn_kevent.filter);

sys/kern/kern_event.c

608

kev.filter = kn->kn_filter;

sys/kern/kern_event.c

623

kev.filter = kn->kn_filter;

sys/kern/kern_intr.c

127

PMC_SOFT_DEFINE( , , intr, filter);

sys/kern/kern_intr.c

1352

bool filter, thread;

sys/kern/kern_intr.c

1368

filter = false;

sys/kern/kern_intr.c

1404

filter = filter || ret == FILTER_HANDLED;

sys/kern/kern_intr.c

1409

PMC_SOFT_CALL_TF( , , intr, filter, frame);

sys/kern/kern_intr.c

1456

if (!thread && !filter)

sys/kern/kern_intr.c

603

driver_filter_t filter, driver_intr_t handler, void *arg, u_char pri,

sys/kern/kern_intr.c

610

if (ie == NULL || name == NULL || (handler == NULL && filter == NULL))

sys/kern/kern_intr.c

621

ih->ih_filter = filter;

sys/kern/kern_rctl.c

1417

struct rctl_rule *filter = (struct rctl_rule *)arg2;

sys/kern/kern_rctl.c

1423

found += rctl_racct_remove_rules(racct, filter);

sys/kern/kern_rctl.c

1432

rctl_rule_remove(struct rctl_rule *filter)

sys/kern/kern_rctl.c

1439

if (filter->rr_subject_type == RCTL_SUBJECT_TYPE_PROCESS &&

sys/kern/kern_rctl.c

1440

filter->rr_subject.rs_proc != NULL) {

sys/kern/kern_rctl.c

1441

p = filter->rr_subject.rs_proc;

sys/kern/kern_rctl.c

1443

found = rctl_racct_remove_rules(p->p_racct, filter);

sys/kern/kern_rctl.c

1452

filter, (void *)&found);

sys/kern/kern_rctl.c

1455

filter, (void *)&found);

sys/kern/kern_rctl.c

1458

filter, (void *)&found);

sys/kern/kern_rctl.c

1463

found += rctl_racct_remove_rules(p->p_racct, filter);

sys/kern/kern_rctl.c

1611

struct rctl_rule *filter;

sys/kern/kern_rctl.c

1632

error = rctl_string_to_rule(inputstr, &filter);

sys/kern/kern_rctl.c

1639

switch (filter->rr_subject_type) {

sys/kern/kern_rctl.c

1641

p = filter->rr_subject.rs_proc;

sys/kern/kern_rctl.c

1649

uip = filter->rr_subject.rs_uip;

sys/kern/kern_rctl.c

1657

lc = filter->rr_subject.rs_loginclass;

sys/kern/kern_rctl.c

1665

prr = filter->rr_subject.rs_prison_racct;

sys/kern/kern_rctl.c

1676

rctl_rule_release(filter);

sys/kern/kern_rctl.c

1689

struct rctl_rule *filter = (struct rctl_rule *)arg2;

sys/kern/kern_rctl.c

1697

if (!rctl_rule_matches(link->rrl_rule, filter))

sys/kern/kern_rctl.c

1708

struct rctl_rule *filter;

sys/kern/kern_rctl.c

1727

error = rctl_string_to_rule(inputstr, &filter);

sys/kern/kern_rctl.c

1754

if (!rctl_rule_matches(link->rrl_rule, filter))

sys/kern/kern_rctl.c

1764

filter, sb);

sys/kern/kern_rctl.c

1767

filter, sb);

sys/kern/kern_rctl.c

1770

filter, sb);

sys/kern/kern_rctl.c

1784

rctl_rule_release(filter);

sys/kern/kern_rctl.c

1794

struct rctl_rule *filter;

sys/kern/kern_rctl.c

1812

error = rctl_string_to_rule(inputstr, &filter);

sys/kern/kern_rctl.c

1819

if (filter->rr_subject_type == RCTL_SUBJECT_TYPE_UNDEFINED) {

sys/kern/kern_rctl.c

1820

rctl_rule_release(filter);

sys/kern/kern_rctl.c

1824

if (filter->rr_subject_type != RCTL_SUBJECT_TYPE_PROCESS) {

sys/kern/kern_rctl.c

1825

rctl_rule_release(filter);

sys/kern/kern_rctl.c

1829

if (filter->rr_subject.rs_proc == NULL) {

sys/kern/kern_rctl.c

1830

rctl_rule_release(filter);

sys/kern/kern_rctl.c

1837

rctl_rule_release(filter);

sys/kern/kern_rctl.c

1847

LIST_FOREACH(link, &filter->rr_subject.rs_proc->p_racct->r_rule_links,

sys/kern/kern_rctl.c

1867

rctl_rule_release(filter);

sys/kern/kern_rctl.c

1921

struct rctl_rule *filter;

sys/kern/kern_rctl.c

1937

error = rctl_string_to_rule(inputstr, &filter);

sys/kern/kern_rctl.c

1944

error = rctl_rule_remove(filter);

sys/kern/kern_rctl.c

1945

rctl_rule_release(filter);

sys/kern/kern_rctl.c

764

rctl_rule_matches(const struct rctl_rule *rule, const struct rctl_rule *filter)

sys/kern/kern_rctl.c

769

if (filter->rr_subject_type != RCTL_SUBJECT_TYPE_UNDEFINED) {

sys/kern/kern_rctl.c

770

if (rule->rr_subject_type != filter->rr_subject_type)

sys/kern/kern_rctl.c

773

switch (filter->rr_subject_type) {

sys/kern/kern_rctl.c

775

if (filter->rr_subject.rs_proc != NULL &&

sys/kern/kern_rctl.c

777

filter->rr_subject.rs_proc)

sys/kern/kern_rctl.c

781

if (filter->rr_subject.rs_uip != NULL &&

sys/kern/kern_rctl.c

783

filter->rr_subject.rs_uip)

sys/kern/kern_rctl.c

787

if (filter->rr_subject.rs_loginclass != NULL &&

sys/kern/kern_rctl.c

789

filter->rr_subject.rs_loginclass)

sys/kern/kern_rctl.c

793

if (filter->rr_subject.rs_prison_racct != NULL &&

sys/kern/kern_rctl.c

795

filter->rr_subject.rs_prison_racct)

sys/kern/kern_rctl.c

800

filter->rr_subject_type);

sys/kern/kern_rctl.c

804

if (filter->rr_resource != RACCT_UNDEFINED) {

sys/kern/kern_rctl.c

805

if (rule->rr_resource != filter->rr_resource)

sys/kern/kern_rctl.c

809

if (filter->rr_action != RCTL_ACTION_UNDEFINED) {

sys/kern/kern_rctl.c

810

if (rule->rr_action != filter->rr_action)

sys/kern/kern_rctl.c

814

if (filter->rr_amount != RCTL_AMOUNT_UNDEFINED) {

sys/kern/kern_rctl.c

815

if (rule->rr_amount != filter->rr_amount)

sys/kern/kern_rctl.c

819

if (filter->rr_per != RCTL_SUBJECT_TYPE_UNDEFINED) {

sys/kern/kern_rctl.c

820

if (rule->rr_per != filter->rr_per)

sys/kern/kern_rctl.c

927

const struct rctl_rule *filter)

sys/kern/kern_rctl.c

936

if (!rctl_rule_matches(link->rrl_rule, filter))

sys/kern/subr_bus.c

3939

int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg,

sys/kern/subr_bus.c

3945

filter, intr, arg, cookiep));

sys/kern/subr_bus.c

4817

driver_filter_t filter, driver_intr_t handler, void *arg, void **cookiep)

sys/kern/subr_bus.c

4823

error = BUS_SETUP_INTR(dev->parent, dev, r, flags, filter, handler,

sys/kern/subr_bus.c

5149

driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep)

sys/kern/subr_intr.c

105

intr_irq_filter_t *filter;

sys/kern/subr_intr.c

341

KASSERT(root->filter != NULL, ("%s: no filter", __func__));

sys/kern/subr_intr.c

351

(root->filter)(root->arg);

sys/kern/subr_intr.c

580

intr_irq_filter_t *filter, void *arg, void **cookiep)

sys/kern/subr_intr.c

583

if (filter == NULL)

sys/kern/subr_intr.c

595

isrc->isrc_filter = filter;

sys/kern/subr_intr.c

735

driver_filter_t filter, driver_intr_t handler, void *arg,

sys/kern/subr_intr.c

746

error = intr_event_add_handler(isrc->isrc_event, name, filter, handler,

sys/kern/subr_intr.c

893

intr_pic_claim_root(device_t dev, intptr_t xref, intr_irq_filter_t *filter,

sys/kern/subr_intr.c

909

if (filter == NULL) {

sys/kern/subr_intr.c

928

root->filter = filter;

sys/kern/subr_intr.c

940

intr_child_irq_filter_t *filter, void *arg, uintptr_t start,

sys/kern/subr_intr.c

956

newchild->pc_filter = filter;

sys/kern/vfs_aio.c

1656

kev.filter = EVFILT_AIO;

sys/kern/vfs_aio.c

2281

kev.filter = EVFILT_LIO;

sys/net/altq/altq_cdnr.h

169

struct flow_filter filter;

sys/net/altq/altq_subr.c

1312

acc_add_filter(classifier, filter, class, phandle)

sys/net/altq/altq_subr.c

1314

struct flow_filter *filter;

sys/net/altq/altq_subr.c

1322

if (filter->ff_flow.fi_family != AF_INET &&

sys/net/altq/altq_subr.c

1323

filter->ff_flow.fi_family != AF_INET6)

sys/net/altq/altq_subr.c

1326

if (filter->ff_flow.fi_family != AF_INET)

sys/net/altq/altq_subr.c

1331

afp->f_filter = *filter;

sys/net/altq/altq_subr.c

1335

if (filter->ff_flow.fi_family == AF_INET) {

sys/net/altq/altq_subr.c

1367

else if (filter->ff_flow.fi_family == AF_INET6) {

sys/net/altq/altq_subr.c

1404

afp->f_fbmask = filt2fibmask(filter);

sys/net/bpf.c

1787

struct bpf_insn *filter;

sys/net/bpf.c

1817

filter = NULL;

sys/net/bpf.c

1832

filter = (struct bpf_insn *)fcode->buffer;

sys/net/bpf.c

1833

if (copyin(fp->bf_insns, filter, size) != 0 ||

sys/net/bpf.c

1834

!bpf_validate(filter, flen)) {

sys/net/bpf.c

1844

jfunc = bpf_jitter(filter, flen);

sys/net/bpf.c

1863

d->bd_wfilter = filter;

sys/net/bpf.c

1872

d->bd_rfilter = filter;

sys/net/bpf.c

1879

if (bpf_check_upgrade(cmd, d, filter, flen) != 0) {

sys/net/bpf_jitter.c

100

bpf_destroy_jit_filter(bpf_jit_filter *filter)

sys/net/bpf_jitter.c

104

if (filter->func != bpf_jit_accept_all)

sys/net/bpf_jitter.c

105

free(filter->func, M_BPFJIT);

sys/net/bpf_jitter.c

106

free(filter, M_BPFJIT);

sys/net/bpf_jitter.c

108

if (filter->func != bpf_jit_accept_all)

sys/net/bpf_jitter.c

109

munmap(filter->func, filter->size);

sys/net/bpf_jitter.c

110

free(filter);

sys/net/bpf_jitter.c

68

bpf_jit_filter *filter;

sys/net/bpf_jitter.c

72

filter = (struct bpf_jit_filter *)malloc(sizeof(*filter),

sys/net/bpf_jitter.c

75

filter = (struct bpf_jit_filter *)malloc(sizeof(*filter));

sys/net/bpf_jitter.c

77

if (filter == NULL)

sys/net/bpf_jitter.c

82

filter->func = bpf_jit_accept_all;

sys/net/bpf_jitter.c

83

return (filter);

sys/net/bpf_jitter.c

87

if ((filter->func = bpf_jit_compile(fp, nins, &filter->size)) == NULL) {

sys/net/bpf_jitter.c

89

free(filter, M_BPFJIT);

sys/net/bpf_jitter.c

91

free(filter);

sys/net/bpf_jitter.c

96

return (filter);

sys/net/bpf_jitter.h

81

void bpf_destroy_jit_filter(bpf_jit_filter *filter);

sys/net/iflib.c

1638

driver_filter_t filter, driver_intr_t handler, void *arg,

sys/net/iflib.c

1658

KASSERT(filter == NULL || handler == NULL, ("filter and handler can't both be non-NULL"));

sys/net/iflib.c

1660

filter, handler, arg, &tag);

sys/net/iflib.c

6031

driver_filter_t filter, void *filter_arg, driver_intr_t handler, void *arg, const char *name)

sys/net/iflib.c

6034

return (_iflib_irq_alloc(ctx, irq, rid, filter, handler, arg, name));

sys/net/iflib.c

6076

driver_filter_t *filter, void *filter_arg,

sys/net/iflib.c

6111

info->ifi_filter = filter;

sys/net/iflib.c

6140

iflib_intr_type_t type, driver_filter_t *filter,

sys/net/iflib.c

6198

info->ifi_filter = filter;

sys/net/iflib.c

6277

iflib_legacy_setup(if_ctx_t ctx, driver_filter_t filter, void *filter_arg, int *rid, const char *name)

sys/net/iflib.c

6295

info->ifi_filter = filter;

sys/net/iflib.c

681

static int iflib_legacy_setup(if_ctx_t ctx, driver_filter_t filter, void *filterarg, int *rid, const char *str);

sys/net/iflib.h

466

iflib_intr_type_t type, driver_filter_t *filter,

sys/net/iflib.h

508

driver_filter_t *filter, void *filter_arg,

sys/netgraph/bluetooth/include/ng_btsocket_hci_raw.h

51

struct ng_btsocket_hci_raw_filter filter; /* filter */

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

1437

struct ng_btsocket_hci_raw_filter filter;

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

1454

error = sooptcopyout(sopt, &pcb->filter,

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

1455

sizeof(pcb->filter));

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

1472

error = sooptcopyin(sopt, &filter, sizeof(filter),

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

1473

sizeof(filter));

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

1475

bcopy(&filter, &pcb->filter,

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

1476

sizeof(pcb->filter));

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

693

if (d && !bit_test(pcb->filter.packet_mask, NG_HCI_CMD_PKT - 1))

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

700

!bit_test(pcb->filter.packet_mask, type - 1) ||

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

715

if (!bit_test(pcb->filter.event_mask, event))

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

944

bit_set(pcb->filter.event_mask, NG_HCI_EVENT_COMMAND_COMPL - 1);

sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c

945

bit_set(pcb->filter.event_mask, NG_HCI_EVENT_COMMAND_STATUS - 1);

sys/netgraph/ng_etf.c

134

LIST_ENTRY(filter) next;

sys/netgraph/ng_etf.c

141

LIST_HEAD(filterhead, filter);

sys/netgraph/ng_etf.c

155

static struct filter *

sys/netgraph/ng_etf.c

159

struct filter *fil;

sys/netgraph/ng_etf.c

281

struct filter *fil;

sys/netgraph/ng_etf.c

369

struct filter *fil;

sys/netgraph/ng_etf.c

452

struct filter *fil1, *fil2;

sys/netgraph/ng_vlan.c

390

vlan_count * sizeof(*t->filter), M_NOWAIT);

sys/netgraph/ng_vlan.c

399

vf = &t->filter[0];

sys/netgraph/ng_vlan.h

97

struct ng_vlan_filter filter[];

sys/netinet6/raw_ip6.c

654

struct icmp6_filter *filter;

sys/netinet6/raw_ip6.c

668

filter = malloc(sizeof(struct icmp6_filter), M_PCB, M_NOWAIT);

sys/netinet6/raw_ip6.c

669

if (filter == NULL)

sys/netinet6/raw_ip6.c

673

free(filter, M_PCB);

sys/netinet6/raw_ip6.c

679

inp->in6p_icmp6filt = filter;

sys/netpfil/pf/pf_if.c

965

pfi_skip_if(const char *filter, struct pfi_kkif *p)

sys/netpfil/pf/pf_if.c

972

if (filter == NULL || !*filter)

sys/netpfil/pf/pf_if.c

974

if (!strcmp(p->pfik_name, filter))

sys/netpfil/pf/pf_if.c

976

n = strlen(filter);

sys/netpfil/pf/pf_if.c

979

if (filter[n-1] >= '0' && filter[n-1] <= '9')

sys/netpfil/pf/pf_if.c

984

if (!strncmp(i->ifgl_group->ifg_group, filter, IFNAMSIZ))

sys/netpfil/pf/pf_table.c

1200

pfr_clr_tables(struct pfr_table *filter, int *ndel, int flags)

sys/netpfil/pf/pf_table.c

1207

if (pfr_fix_anchor(filter->pfrt_anchor))

sys/netpfil/pf/pf_table.c

1209

if (pfr_table_count(filter, flags) < 0)

sys/netpfil/pf/pf_table.c

1214

if (pfr_skip_table(filter, p, flags))

sys/netpfil/pf/pf_table.c

1343

pfr_get_tables(struct pfr_table *filter, struct pfr_table *tbl, int *size,

sys/netpfil/pf/pf_table.c

1352

if (pfr_fix_anchor(filter->pfrt_anchor))

sys/netpfil/pf/pf_table.c

1354

n = nn = pfr_table_count(filter, flags);

sys/netpfil/pf/pf_table.c

1362

if (pfr_skip_table(filter, p, flags))

sys/netpfil/pf/pf_table.c

1376

pfr_get_tstats(struct pfr_table *filter, struct pfr_tstats *tbl, int *size,

sys/netpfil/pf/pf_table.c

1387

if (pfr_fix_anchor(filter->pfrt_anchor))

sys/netpfil/pf/pf_table.c

1389

n = nn = pfr_table_count(filter, flags);

sys/netpfil/pf/pf_table.c

1398

if (pfr_skip_table(filter, p, flags))

sys/netpfil/pf/pf_table.c

1836

pfr_table_count(struct pfr_table *filter, int flags)

sys/netpfil/pf/pf_table.c

1844

if (filter->pfrt_anchor[0]) {

sys/netpfil/pf/pf_table.c

1845

rs = pf_find_kruleset(filter->pfrt_anchor);

sys/netpfil/pf/pf_table.c

1852

pfr_skip_table(struct pfr_table *filter, struct pfr_ktable *kt, int flags)

sys/netpfil/pf/pf_table.c

1856

if (strcmp(filter->pfrt_anchor, kt->pfrkt_anchor))

sys/netpfil/pf/pf_table.c

2318

sa_family_t af, pf_addr_filter_func_t filter, bool loop_once)

sys/netpfil/pf/pf_table.c

2390

if (filter && filter(af, addr)) {

sys/netpfil/pf/pf_table.c

2416

if (filter && filter(af, addr))

sys/ofed/drivers/infiniband/core/core_priv.h

65

struct cma_device *cma_enum_devices_by_ibdev(cma_device_filter filter,

sys/ofed/drivers/infiniband/core/core_priv.h

89

roce_netdev_filter filter,

sys/ofed/drivers/infiniband/core/core_priv.h

93

void ib_enum_all_roce_netdevs(roce_netdev_filter filter,

sys/ofed/drivers/infiniband/core/ib_cache.c

564

bool (*filter)(const union ib_gid *,

sys/ofed/drivers/infiniband/core/ib_cache.c

599

if (filter(gid, &attr, context))

sys/ofed/drivers/infiniband/core/ib_cache.c

911

bool (*filter)(const union ib_gid *gid,

sys/ofed/drivers/infiniband/core/ib_cache.c

917

if (!rdma_cap_roce_gid_table(device, port_num) && filter)

sys/ofed/drivers/infiniband/core/ib_cache.c

921

port_num, filter,

sys/ofed/drivers/infiniband/core/ib_cma.c

245

struct cma_device *cma_enum_devices_by_ibdev(cma_device_filter filter,

sys/ofed/drivers/infiniband/core/ib_cma.c

254

if (filter(cma_dev->device, cookie)) {

sys/ofed/drivers/infiniband/core/ib_device.c

723

roce_netdev_filter filter,

sys/ofed/drivers/infiniband/core/ib_device.c

743

if (filter(ib_dev, port, idev, filter_cookie))

sys/ofed/drivers/infiniband/core/ib_device.c

762

void ib_enum_all_roce_netdevs(roce_netdev_filter filter,

sys/ofed/drivers/infiniband/core/ib_device.c

771

ib_enum_roce_netdev(dev, filter, filter_cookie, cb, cookie);

sys/ofed/include/rdma/ib_cache.h

106

bool (*filter)(const union ib_gid *gid,

sys/powerpc/powerpc/busdma_machdep.c

140

bus_addr_t highaddr, bus_dma_filter_t *filter,

sys/powerpc/powerpc/busdma_machdep.c

157

if (filter != NULL || filterarg != NULL)

sys/powerpc/powerpc/intr_machdep.c

151

filter, driver_intr_t handler, void *arg, enum intr_type flags, void

sys/powerpc/powerpc/intr_machdep.c

501

powerpc_setup_intr(const char *name, u_int irq, driver_filter_t filter,

sys/powerpc/powerpc/intr_machdep.c

506

return (powerpc_setup_intr_int(name, irq, filter, handler, arg, flags,

sys/powerpc/powerpc/intr_machdep.c

512

powerpc_setup_intr_int(const char *name, u_int irq, driver_filter_t filter,

sys/powerpc/powerpc/intr_machdep.c

535

error = intr_event_add_handler(i->event, name, filter, handler, arg,

sys/riscv/riscv/busdma_machdep.c

117

bus_dma_filter_t *filter, void *filterarg, bus_size_t maxsize,

sys/riscv/riscv/busdma_machdep.c

125

if (filter != NULL || filterarg != NULL)

sys/sys/bus.h

494

driver_filter_t *filter, driver_intr_t *intr,

sys/sys/bus.h

580

driver_filter_t filter, driver_intr_t handler,

sys/sys/event.h

111

short filter; /* filter for event */

sys/sys/event.h

128

short filter; /* filter for event */

sys/sys/event.h

332

#define kn_filter kn_kevent.filter

sys/sys/event.h

56

.filter = (b), \

sys/sys/event.h

72

(kevp)->filter = (b); \

sys/sys/event.h

86

short filter; /* filter for event */

sys/sys/event.h

98

short filter; /* filter for event */

sys/sys/interrupt.h

170

driver_filter_t filter, driver_intr_t handler, void *arg,

sys/sys/rctl.h

141

int rctl_rule_remove(struct rctl_rule *filter);

sys/x86/include/intr_machdep.h

140

driver_filter_t filter, driver_intr_t handler, void *arg,

sys/x86/include/xen/arch-intr.h

65

xen_arch_intr_add_handler(const char *name, driver_filter_t filter,

sys/x86/include/xen/arch-intr.h

70

return (intr_add_handler(&isrc->xi_arch.intsrc, name, filter, handler,

sys/x86/x86/busdma_machdep.c

140

bus_dma_filter_t *filter, void *filterarg, bus_size_t maxsize,

sys/x86/x86/busdma_machdep.c

148

if (filter != NULL || filterarg != NULL)

sys/x86/x86/intr_machdep.c

278

intr_add_handler(struct intsrc *isrc, const char *name, driver_filter_t filter,

sys/x86/x86/intr_machdep.c

284

error = intr_event_add_handler(isrc->is_event, name, filter, handler,

sys/x86/x86/nexus.c

455

int flags, driver_filter_t filter, void (*ihand)(void *),

sys/x86/x86/nexus.c

482

filter, ihand, arg, flags, cookiep, domain);

sys/x86/xen/xen_apic.c

319

if (ipi->filter == NULL) {

sys/x86/xen/xen_apic.c

324

rc = xen_intr_alloc_and_bind_ipi(cpu, ipi->filter,

sys/x86/xen/xen_apic.c

78

driver_filter_t *filter;

sys/xen/xen_intr.h

111

evtchn_port_t remote_port, driver_filter_t filter,

sys/xen/xen_intr.h

136

driver_filter_t filter, driver_intr_t handler,

sys/xen/xen_intr.h

153

driver_filter_t filter, enum intr_type irqflags,

sys/xen/xen_intr.h

225

int xen_intr_add_handler(const char *name, driver_filter_t filter,

sys/xen/xen_intr.h

63

driver_filter_t filter, driver_intr_t handler, void *arg,

sys/xen/xen_intr.h

87

u_int remote_domain, driver_filter_t filter, driver_intr_t handler,

tests/sys/aio/aio_kqueue_test.c

176

kq_returned.filter,

tests/sys/aio/aio_test.c

1780

ATF_CHECK_EQ(events[0].filter, EVFILT_AIO);

tests/sys/aio/aio_test.c

287

ATF_CHECK_EQ(events[0].filter, EVFILT_AIO);

tests/sys/aio/lio_test.c

165

ATF_REQUIRE_EQ(EVFILT_LIO, kq_returned.filter);

tests/sys/capsicum/linux.cc

1033

struct sock_filter filter[] = {

tests/sys/capsicum/linux.cc

1037

bpf.len = (sizeof(filter) / sizeof(filter[0]));

tests/sys/capsicum/linux.cc

1038

bpf.filter = filter;

tests/sys/capsicum/linux.cc

1081

struct sock_filter filter[] = { EXAMINE_SYSCALL,

tests/sys/capsicum/linux.cc

1087

struct sock_fprog bpf = {.len = (sizeof(filter) / sizeof(filter[0])),

tests/sys/capsicum/linux.cc

1088

.filter = filter};

tests/sys/fifo/fifo_io.c

973

if (kp->filter == EVFILT_READ)

tests/sys/fifo/fifo_io.c

975

if (kp->filter == EVFILT_WRITE)

tests/sys/fifo/fifo_kqueue.c

103

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/fifo/fifo_kqueue.c

119

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/fifo/fifo_kqueue.c

134

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/fifo/fifo_kqueue.c

170

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/fifo/fifo_kqueue.c

193

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/fifo/fifo_kqueue.c

206

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/fifo/fifo_kqueue.c

257

ATF_REQUIRE(kev[0].filter == EVFILT_READ);

tests/sys/fifo/fifo_kqueue.c

309

ATF_REQUIRE(kev[0].filter == EVFILT_READ);

tests/sys/fifo/fifo_kqueue.c

362

ATF_REQUIRE(kev[0].filter == EVFILT_READ);

tests/sys/fifo/fifo_kqueue.c

410

ATF_REQUIRE(kev[0].filter == EVFILT_READ);

tests/sys/fifo/fifo_kqueue.c

69

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/kern/ktls_test.c

1213

switch (ev.filter) {

tests/sys/kern/ktls_test.c

1529

switch (ev.filter) {

tests/sys/kern/pipe/pipe_kqueue_test.c

115

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/kern/pipe/pipe_kqueue_test.c

131

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/kern/pipe/pipe_kqueue_test.c

175

ATF_REQUIRE(kev[0].filter == EVFILT_READ);

tests/sys/kern/pipe/pipe_kqueue_test.c

220

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/kern/pipe/pipe_kqueue_test.c

229

ATF_REQUIRE(kev[1].filter == EVFILT_READ);

tests/sys/kern/pipe/pipe_kqueue_test.c

283

ATF_REQUIRE(kev[0].filter == EVFILT_READ);

tests/sys/kern/pipe/pipe_kqueue_test.c

337

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/kern/pipe/pipe_kqueue_test.c

345

ATF_REQUIRE(kev[1].filter == EVFILT_READ);

tests/sys/kern/pipe/pipe_kqueue_test.c

65

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/kern/pipe/pipe_kqueue_test.c

99

ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);

tests/sys/kern/ptrace_test.c

2864

CHILD_REQUIRE_EQ(kev.filter, EVFILT_SIGNAL);

tests/sys/kern/unix_dgram.c

312

ATF_REQUIRE(ev.filter == EVFILT_READ);

tests/sys/kern/unix_stream.c

174

kev.filter == ctx->kev_filter &&

tests/sys/kern/unix_stream.c

488

kev.filter == EVFILT_WRITE &&

tests/sys/kqueue/kqueue_fork.c

116

switch (ev.filter) {

tests/sys/kqueue/libkqueue/common.h

56

short filter,

tests/sys/kqueue/libkqueue/common.h

65

kev.filter != (_filter) || \

tests/sys/kqueue/libkqueue/common.h

69

(int)kev.ident, kev.filter, kev.flags);\

tests/sys/kqueue/libkqueue/main.c

121

if (kev->filter == EVFILT_PROC) {

tests/sys/kqueue/libkqueue/main.c

130

} else if (kev->filter == EVFILT_PROCDESC) {

tests/sys/kqueue/libkqueue/main.c

136

} else if (kev->filter == EVFILT_VNODE) {

tests/sys/kqueue/libkqueue/main.c

202

kev->filter,

tests/sys/kqueue/libkqueue/main.c

221

short filter,

tests/sys/kqueue/libkqueue/main.c

229

EV_SET(kev, ident, filter, flags, fflags, data, udata);

tests/sys/kqueue/libkqueue/main.c

252

if (k1->ident != k2->ident || k1->filter != k2->filter ||

tests/sys/kqueue/libkqueue/vnode.c

167

kev.filter != EVFILT_VNODE ||

tests/sys/kqueue/libkqueue/vnode.c

170

test_id, (unsigned int)kev.ident, kev.filter, kev.flags);

tests/sys/kqueue/libkqueue/vnode.c

195

kev.filter != EVFILT_VNODE ||

tests/sys/kqueue/libkqueue/vnode.c

198

test_id, (unsigned int)kev.ident, kev.filter, kev.flags);

tests/sys/kqueue/libkqueue/vnode.c

255

kev.filter != EVFILT_VNODE ||

tests/sys/kqueue/libkqueue/vnode.c

258

test_id, (unsigned int)kev.ident, kev.filter, kev.flags);

tests/sys/kqueue/libkqueue/vnode.c

286

kev.filter != EVFILT_VNODE ||

tests/sys/kqueue/libkqueue/vnode.c

289

test_id, (unsigned int)kev.ident, kev.filter, kev.flags);

tests/sys/netinet/ip6_mrouted.c

115

assert(ev.filter == EVFILT_READ);

tools/regression/bpf/bpf_filter/bpf_test.c

65

bpf_jit_filter *filter;

tools/regression/bpf/bpf_filter/bpf_test.c

69

if ((filter = bpf_jitter(pc, nins)) == NULL) {

tools/regression/bpf/bpf_filter/bpf_test.c

78

hexdump(filter->func, filter->size, NULL, HD_OMIT_CHARS);

tools/regression/bpf/bpf_filter/bpf_test.c

82

ret = (*(filter->func))(pkt, wirelen, buflen);

tools/regression/bpf/bpf_filter/bpf_test.c

84

bpf_destroy_jit_filter(filter);

tools/tools/nvmf/nvmfd/nvmfd.c

128

assert(ev.filter == EVFILT_READ);

tools/tools/so_splice/proxy.c

287

switch (kev.filter) {

usr.bin/kdump/kdump.c

2305

switch (kev->filter) {

usr.bin/kdump/kdump.c

2322

print_integer_arg(sysdecode_kevent_filter, kev->filter);

usr.bin/kdump/kdump.c

2326

sysdecode_kevent_fflags(stdout, kev->filter, kev->fflags,

usr.bin/kdump/kdump.c

2389

kev.filter = kev11.filter;

usr.bin/kdump/kdump.c

2404

kev.filter = kev32.filter;

usr.bin/kdump/kdump.c

2418

kev.filter = kev32.filter;

usr.bin/nl/nl.c

265

filter();

usr.bin/nl/nl.c

85

static void filter(void);

usr.bin/procstat/procstat_kqueue.c

211

procstat_kqueue_fflags(int filter, unsigned fflags)

usr.bin/procstat/procstat_kqueue.c

216

if (filter < 0 && -filter < (int)nitems(filter_pk_names))

usr.bin/procstat/procstat_kqueue.c

217

names = filter_pk_names[-filter];

usr.bin/procstat/procstat_kqueue.c

224

procstat_kqueue_get_filter_name(int filter)

usr.bin/procstat/procstat_kqueue.c

226

filter = -filter;

usr.bin/procstat/procstat_kqueue.c

227

if (filter < 0 || filter >= (int)nitems(filter_names))

usr.bin/procstat/procstat_kqueue.c

228

filter = 0;

usr.bin/procstat/procstat_kqueue.c

229

return (filter_names[filter]);

usr.bin/procstat/procstat_kqueue.c

252

fflags = procstat_kqueue_fflags(kni->knt_event.filter,

usr.bin/procstat/procstat_kqueue.c

260

kni->knt_event.filter));

usr.bin/rctl/rctl.c

410

show_limits(const char *filter, const char *unexpanded_rule,

usr.bin/rctl/rctl.c

422

error = rctl_get_limits(filter, strlen(filter) + 1,

usr.bin/rctl/rctl.c

443

remove_rule(const char *filter, const char *unexpanded_rule)

usr.bin/rctl/rctl.c

447

error = rctl_remove_rule(filter, strlen(filter) + 1, NULL, 0);

usr.bin/rctl/rctl.c

494

show_usage(const char *filter, const char *unexpanded_rule, int hflag)

usr.bin/rctl/rctl.c

505

error = rctl_get_racct(filter, strlen(filter) + 1,

usr.bin/rctl/rctl.c

540

show_rules(const char *filter, const char *unexpanded_rule,

usr.bin/rctl/rctl.c

547

if (filter != NULL)

usr.bin/rctl/rctl.c

548

filterlen = strlen(filter) + 1;

usr.bin/rctl/rctl.c

557

error = rctl_get_rules(filter, filterlen, outbuf, outbuflen);

usr.bin/tail/forward.c

419

} else if (ev->filter == EVFILT_READ && ev->data < 0) {

usr.bin/truss/syscalls.c

1039

switch (ke->filter) {

usr.bin/truss/syscalls.c

1056

print_integer_arg(sysdecode_kevent_filter, fp, ke->filter);

usr.bin/truss/syscalls.c

1060

sysdecode_kevent_fflags(fp, ke->filter, ke->fflags, 16);

usr.bin/truss/syscalls.c

2221

ke.filter = ke11[i].filter;

usr.bin/ul/ul.c

136

filter(stdin);

usr.bin/ul/ul.c

142

filter(f);

usr.bin/ul/ul.c

88

static void filter(FILE *);

usr.bin/vgrind/vfontedpr.c

149

filter = true;

usr.bin/vgrind/vfontedpr.c

282

if (!filter) {

usr.bin/vgrind/vfontedpr.c

292

if (!filter) {

usr.bin/vgrind/vfontedpr.c

316

if (!filter || pass)

usr.bin/vgrind/vfontedpr.c

70

static bool filter = false; /* act as a filter (like eqn) */

usr.bin/vtfontcvt/vtfontcvt.c

1058

filter = false;

usr.bin/vtfontcvt/vtfontcvt.c

171

static bool filter = true;

usr.bin/vtfontcvt/vtfontcvt.c

296

if (filter == false)

usr.bin/vtfontcvt/vtfontcvt.c

325

} else if (filter == false || curchar >= 0x20) {

usr.sbin/bhyve/mevent.c

223

kev->filter = mevent_kq_filter(mevp);

usr.sbin/bluetooth/hccontrol/hccontrol.c

104

struct ng_btsocket_hci_raw_filter filter;

usr.sbin/bluetooth/hccontrol/hccontrol.c

137

memset(&filter, 0, sizeof(filter));

usr.sbin/bluetooth/hccontrol/hccontrol.c

138

bit_set(filter.event_mask, NG_HCI_EVENT_COMMAND_COMPL - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

139

bit_set(filter.event_mask, NG_HCI_EVENT_COMMAND_STATUS - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

140

bit_set(filter.event_mask, NG_HCI_EVENT_INQUIRY_COMPL - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

141

bit_set(filter.event_mask, NG_HCI_EVENT_INQUIRY_RESULT - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

142

bit_set(filter.event_mask, NG_HCI_EVENT_CON_COMPL - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

143

bit_set(filter.event_mask, NG_HCI_EVENT_DISCON_COMPL - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

144

bit_set(filter.event_mask, NG_HCI_EVENT_REMOTE_NAME_REQ_COMPL - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

145

bit_set(filter.event_mask, NG_HCI_EVENT_READ_REMOTE_FEATURES_COMPL - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

146

bit_set(filter.event_mask, NG_HCI_EVENT_READ_REMOTE_VER_INFO_COMPL - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

147

bit_set(filter.event_mask, NG_HCI_EVENT_RETURN_LINK_KEYS - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

148

bit_set(filter.event_mask, NG_HCI_EVENT_READ_CLOCK_OFFSET_COMPL - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

149

bit_set(filter.event_mask, NG_HCI_EVENT_CON_PKT_TYPE_CHANGED - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

150

bit_set(filter.event_mask, NG_HCI_EVENT_ROLE_CHANGE - 1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

151

bit_set(filter.event_mask, NG_HCI_EVENT_LE -1);

usr.sbin/bluetooth/hccontrol/hccontrol.c

154

(void * const) &filter, sizeof(filter)) < 0)

usr.sbin/bluetooth/hcsecd/hcsecd.c

124

memset(&filter, 0, sizeof(filter));

usr.sbin/bluetooth/hcsecd/hcsecd.c

125

bit_set(filter.event_mask, NG_HCI_EVENT_PIN_CODE_REQ - 1);

usr.sbin/bluetooth/hcsecd/hcsecd.c

126

bit_set(filter.event_mask, NG_HCI_EVENT_LINK_KEY_REQ - 1);

usr.sbin/bluetooth/hcsecd/hcsecd.c

127

bit_set(filter.event_mask, NG_HCI_EVENT_LINK_KEY_NOTIFICATION - 1);

usr.sbin/bluetooth/hcsecd/hcsecd.c

130

(void * const) &filter, sizeof(filter)) < 0)

usr.sbin/bluetooth/hcsecd/hcsecd.c

74

struct ng_btsocket_hci_raw_filter filter;

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

1320

struct pfr_table filter;

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

1330

bzero(&filter, sizeof(filter));

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

1332

if (pfctl_get_tstats(pfh, &filter, pft_add_tstats, &i)) {

usr.sbin/camdd/camdd.c

1796

switch (ke.filter) {

usr.sbin/camdd/camdd.c

1862

__func__, ke.filter);

usr.sbin/ctld/conf.h

67

bool portal_group_set_filter(const char *filter);

usr.sbin/ctld/ctld.cc

2425

switch (kev.filter) {

usr.sbin/ctld/iscsi.cc

197

enum discovery_filter filter;

usr.sbin/ctld/iscsi.cc

200

filter = discovery_filter::NONE;

usr.sbin/ctld/iscsi.cc

202

filter = discovery_filter::PORTAL;

usr.sbin/ctld/iscsi.cc

204

filter = discovery_filter::PORTAL_NAME;

usr.sbin/ctld/iscsi.cc

206

filter = discovery_filter::PORTAL_NAME_AUTH;

usr.sbin/ctld/iscsi.cc

216

pg_discovery_filter != filter) {

usr.sbin/ctld/iscsi.cc

223

pg_discovery_filter = filter;

usr.sbin/ctld/nvmf.cc

263

enum discovery_filter filter;

usr.sbin/ctld/nvmf.cc

266

filter = discovery_filter::NONE;

usr.sbin/ctld/nvmf.cc

268

filter = discovery_filter::PORTAL;

usr.sbin/ctld/nvmf.cc

270

filter = discovery_filter::PORTAL_NAME;

usr.sbin/ctld/nvmf.cc

280

pg_discovery_filter != filter) {

usr.sbin/ctld/nvmf.cc

287

pg_discovery_filter = filter;

usr.sbin/daemon/daemon.c

476

switch (event.filter) {

usr.sbin/daemon/daemon.c

584

assert(event.filter == EVFILT_TIMER ||

usr.sbin/daemon/daemon.c

585

event.filter == EVFILT_SIGNAL);

usr.sbin/daemon/daemon.c

587

if (event.filter == EVFILT_TIMER) {

usr.sbin/mfiutil/mfi_evt.c

537

union mfi_evt filter;

usr.sbin/mfiutil/mfi_evt.c

54

union mfi_evt filter, uint32_t start_seq, uint8_t *statusp)

usr.sbin/mfiutil/mfi_evt.c

564

filter.members.reserved = 0;

usr.sbin/mfiutil/mfi_evt.c

565

filter.members.locale = MFI_EVT_LOCALE_ALL;

usr.sbin/mfiutil/mfi_evt.c

566

filter.members.evt_class = MFI_EVT_CLASS_WARNING;

usr.sbin/mfiutil/mfi_evt.c

576

if (parse_class(optarg, &filter.members.evt_class) < 0) {

usr.sbin/mfiutil/mfi_evt.c

590

filter.members.locale = locale;

usr.sbin/mfiutil/mfi_evt.c

60

mbox[1] = filter.word;

usr.sbin/mfiutil/mfi_evt.c

650

if (mfi_get_events(fd, list, num_events, filter, seq,

usr.sbin/moused/moused/moused.c

1017

if (c > 0 && ke[0].filter == EVFILT_READ) {

usr.sbin/moused/moused/moused.c

984

if (ke[0].filter == EVFILT_READ) {

usr.sbin/moused/moused/moused.c

991

} else if (ke[0].filter == EVFILT_TIMER) {

usr.sbin/moused/moused/moused.c

999

if (c > 0 && ke[0].filter == EVFILT_TIMER &&

usr.sbin/nscd/nscd.c

519

switch (event_data->filter) {

usr.sbin/nscd/nscdcli.c

108

if ((nevents == 1) && (eventlist.filter == EVFILT_READ)) {

usr.sbin/nscd/nscdcli.c

160

if ((nevents == 1) && (eventlist.filter == EVFILT_WRITE)) {

usr.sbin/nscd/nscdcli.c

71

if ((nevents == 1) && (eventlist.filter == EVFILT_WRITE)) {

usr.sbin/pmc/cmd_pmc_stat.c

423

switch (kev.filter) {

usr.sbin/pmcstat/pmcstat.c

1349

switch (kev.filter) {

usr.sbin/ppp/bundle.c

1860

filter_AdjustAddr(&bundle->filter.in, local, remote, NULL);

usr.sbin/ppp/bundle.c

1861

filter_AdjustAddr(&bundle->filter.out, local, remote, NULL);

usr.sbin/ppp/bundle.c

1862

filter_AdjustAddr(&bundle->filter.dial, local, remote, NULL);

usr.sbin/ppp/bundle.c

1863

filter_AdjustAddr(&bundle->filter.alive, local, remote, NULL);

usr.sbin/ppp/bundle.c

1871

filter_AdjustAddr(&bundle->filter.in, NULL, NULL, dns);

usr.sbin/ppp/bundle.c

1872

filter_AdjustAddr(&bundle->filter.out, NULL, NULL, dns);

usr.sbin/ppp/bundle.c

1873

filter_AdjustAddr(&bundle->filter.dial, NULL, NULL, dns);

usr.sbin/ppp/bundle.c

1874

filter_AdjustAddr(&bundle->filter.alive, NULL, NULL, dns);

usr.sbin/ppp/bundle.c

595

pri = PacketCheck(bundle, af, tun.data, n, &bundle->filter.in,

usr.sbin/ppp/bundle.c

617

pri = PacketCheck(bundle, af, tun.data, n, &bundle->filter.dial,

usr.sbin/ppp/bundle.c

633

pri = PacketCheck(bundle, af, tun.data, n, &bundle->filter.out,

usr.sbin/ppp/bundle.c

863

memset(&bundle.filter, '\0', sizeof bundle.filter);

usr.sbin/ppp/bundle.c

864

bundle.filter.in.fragok = bundle.filter.in.logok = 1;

usr.sbin/ppp/bundle.c

865

bundle.filter.in.name = "IN";

usr.sbin/ppp/bundle.c

866

bundle.filter.out.fragok = bundle.filter.out.logok = 1;

usr.sbin/ppp/bundle.c

867

bundle.filter.out.name = "OUT";

usr.sbin/ppp/bundle.c

868

bundle.filter.dial.name = "DIAL";

usr.sbin/ppp/bundle.c

869

bundle.filter.dial.logok = 1;

usr.sbin/ppp/bundle.c

870

bundle.filter.alive.name = "ALIVE";

usr.sbin/ppp/bundle.c

871

bundle.filter.alive.logok = 1;

usr.sbin/ppp/bundle.c

875

bundle.filter.in.rule[i].f_action = A_NONE;

usr.sbin/ppp/bundle.c

876

bundle.filter.out.rule[i].f_action = A_NONE;

usr.sbin/ppp/bundle.c

877

bundle.filter.dial.rule[i].f_action = A_NONE;

usr.sbin/ppp/bundle.c

878

bundle.filter.alive.rule[i].f_action = A_NONE;

usr.sbin/ppp/bundle.h

125

struct filter in; /* incoming packet filter */

usr.sbin/ppp/bundle.h

126

struct filter out; /* outgoing packet filter */

usr.sbin/ppp/bundle.h

127

struct filter dial; /* dial-out packet filter */

usr.sbin/ppp/bundle.h

128

struct filter alive; /* keep-alive packet filter */

usr.sbin/ppp/bundle.h

129

} filter;

usr.sbin/ppp/filter.c

411

struct filter *filter;

usr.sbin/ppp/filter.c

417

filter = &arg->bundle->filter.in;

usr.sbin/ppp/filter.c

419

filter = &arg->bundle->filter.out;

usr.sbin/ppp/filter.c

421

filter = &arg->bundle->filter.dial;

usr.sbin/ppp/filter.c

423

filter = &arg->bundle->filter.alive;

usr.sbin/ppp/filter.c

431

arg->argv + arg->argn + 1, filter->rule);

usr.sbin/ppp/filter.c

505

struct filter *filter;

usr.sbin/ppp/filter.c

508

filter = &arg->bundle->filter.in;

usr.sbin/ppp/filter.c

510

filter = &arg->bundle->filter.out;

usr.sbin/ppp/filter.c

512

filter = &arg->bundle->filter.dial;

usr.sbin/ppp/filter.c

514

filter = &arg->bundle->filter.alive;

usr.sbin/ppp/filter.c

517

doShowFilter(filter->rule, arg->prompt);

usr.sbin/ppp/filter.c

519

struct filter *filter[4];

usr.sbin/ppp/filter.c

522

filter[0] = &arg->bundle->filter.in;

usr.sbin/ppp/filter.c

523

filter[1] = &arg->bundle->filter.out;

usr.sbin/ppp/filter.c

524

filter[2] = &arg->bundle->filter.dial;

usr.sbin/ppp/filter.c

525

filter[3] = &arg->bundle->filter.alive;

usr.sbin/ppp/filter.c

529

prompt_Printf(arg->prompt, "%s:\n", filter[f]->name);

usr.sbin/ppp/filter.c

530

doShowFilter(filter[f]->rule, arg->prompt);

usr.sbin/ppp/filter.c

561

filter_AdjustAddr(struct filter *filter, struct ncpaddr *local,

usr.sbin/ppp/filter.c

567

for (fp = filter->rule, n = 0; n < MAXFILTERS; fp++, n++)

usr.sbin/ppp/filter.h

100

extern void filter_AdjustAddr(struct filter *, struct ncpaddr *,

usr.sbin/ppp/ip.c

215

const struct filter *filter, unsigned *psecs)

usr.sbin/ppp/ip.c

226

const struct filterent *fp = filter->rule;

usr.sbin/ppp/ip.c

264

if (!filter->fragok) {

usr.sbin/ppp/ip.c

290

log_Printf(LogDEBUG, "%s filter:\n", filter->name);

usr.sbin/ppp/ip.c

451

fp = &filter->rule[n = fp->f_action];

usr.sbin/ppp/ip.c

456

if (strcmp(filter->name, "DIAL") == 0) {

usr.sbin/ppp/ip.c

461

"src = %s:%d dst = %s:%d\n", filter->name, n,

usr.sbin/ppp/ip.c

472

filter->name, n, prototxt(cproto),

usr.sbin/ppp/ip.c

488

filter->name, prototxt(cproto), ncpaddr_ntoa(&srcaddr),

usr.sbin/ppp/ip.c

559

const unsigned char *packet, int nb, struct filter *filter,

usr.sbin/ppp/ip.c

579

(!filter || filter->logok);

usr.sbin/ppp/ip.c

613

else if (filter)

usr.sbin/ppp/ip.c

614

snprintf(logbuf + loglen, sizeof logbuf - loglen, "%s ", filter->name);

usr.sbin/ppp/ip.c

682

nb - (payload - packet) - sizeof *uh - 4, filter,

usr.sbin/ppp/ip.c

750

filter, logbuf, psecs);

usr.sbin/ppp/ip.c

771

filter, logbuf, psecs);

usr.sbin/ppp/ip.c

872

if (filter && FilterCheck(packet, family, filter, psecs)) {

usr.sbin/ppp/ip.c

882

if (filter &&

usr.sbin/ppp/ip.c

883

FilterCheck(packet, family, &bundle->filter.alive, &alivesecs))

usr.sbin/ppp/ip.c

901

if (filter && uh && ntohs(uh->uh_dport) == 53 && log_IsKept(LogDNS))

usr.sbin/ppp/ip.c

902

ip_LogDNS(uh, filter->name);

usr.sbin/ppp/ip.c

926

if (PacketCheck(bundle, af, tun.data, nb, &bundle->filter.in,

usr.sbin/ppp/ip.c

931

if (!FilterCheck(tun.data, af, &bundle->filter.alive, &alivesecs)) {

usr.sbin/ppp/ip.h

32

struct filter;

usr.sbin/ppp/ip.h

38

struct filter *, const char *, unsigned *secs);

usr.sbin/ppp/ip.h

39

extern int FilterCheck(const unsigned char *, u_int32_t, const struct filter *,

usr.sbin/ppp/ipcp.c

1469

if (!FilterCheck(MBUF_CTOP(bp), AF_INET, &bundle->filter.alive,

usr.sbin/ppp/ipv6cp.c

448

if (!FilterCheck(MBUF_CTOP(bp), AF_INET6, &bundle->filter.alive,

usr.sbin/rarpd/rarpd.c

416

static struct bpf_program filter = {

usr.sbin/rarpd/rarpd.c

450

if (ioctl(fd, BIOCSETF, (caddr_t)&filter) == -1) {

usr.sbin/route6d/route6d.c

171

static char *filter[MAXFILTER];

usr.sbin/route6d/route6d.c

304

filter[nfilter++] = allocopy(optarg);

usr.sbin/route6d/route6d.c

3175

ap = filter[i];

usr.sbin/rtadvd/if.c

160

#define FILTER_MATCH(type, filter) ((0x1 << type) & filter)

usr.sbin/rtadvd/if.c

164

get_next_msg(char *buf, char *lim, int ifindex, size_t *lenp, int filter)

usr.sbin/rtadvd/if.c

189

if (FILTER_MATCH(rtm->rtm_type, filter) == 0)

usr.sbin/syslogd/syslogd.c

1468

evaluate_prop_filter(const struct prop_filter *filter, const char *value)

usr.sbin/syslogd/syslogd.c

1471

const int exclude = ((filter->cmp_flags & FILT_FLAG_EXCLUDE) > 0);

usr.sbin/syslogd/syslogd.c

1477

if (filter->cmp_type == FILT_CMP_REGEX) {

usr.sbin/syslogd/syslogd.c

1478

if (regexec(filter->pflt_re, value, 0, NULL, 0) == 0)

usr.sbin/syslogd/syslogd.c

1487

if (filter->cmp_type == FILT_CMP_EQUAL &&

usr.sbin/syslogd/syslogd.c

1488

valuelen != strlen(filter->pflt_strval))

usr.sbin/syslogd/syslogd.c

1491

if (filter->cmp_flags & FILT_FLAG_ICASE)

usr.sbin/syslogd/syslogd.c

1492

s = strcasestr(value, filter->pflt_strval);

usr.sbin/syslogd/syslogd.c

1494

s = strstr(value, filter->pflt_strval);

usr.sbin/syslogd/syslogd.c

1505

switch (filter->cmp_type) {

usr.sbin/syslogd/syslogd.c

2757

char *filter, *filter_endpos, *filter_begpos, *p;

usr.sbin/syslogd/syslogd.c

2761

filter = strdup(cfilter);

usr.sbin/syslogd/syslogd.c

2762

if (filter == NULL)

usr.sbin/syslogd/syslogd.c

2764

filter_begpos = filter;

usr.sbin/syslogd/syslogd.c

2777

for (ap = argv; (*ap = strsep(&filter, ", \t\n")) != NULL;) {

usr.sbin/syslogd/syslogd.c

2835

filter += strspn(filter, ", \t\n");

usr.sbin/syslogd/syslogd.c

2836

if (*filter != '"' || strlen(filter) < 3) {

usr.sbin/syslogd/syslogd.c

2840

filter++;

usr.sbin/syslogd/syslogd.c

2845

filter_endpos = filter;

usr.sbin/syslogd/syslogd.c

2846

for (p = filter; *p != '\0'; p++) {

usr.sbin/syslogd/syslogd.c

2873

pfilter.pflt_strval = filter;

usr.sbin/syslogd/syslogd.c

358

static int evaluate_prop_filter(const struct prop_filter *filter,

usr.sbin/syslogd/syslogd.c

775

switch (ev.filter) {

usr.sbin/ypldap/aldap.c

151

aldap_search(struct aldap *ldap, char *basedn, enum scope scope, char *filter,

usr.sbin/ypldap/aldap.c

177

if ((ber = ldap_parse_search_filter(ber, filter)) == NULL) {

usr.sbin/ypldap/aldap.c

564

free(lu->filter);

usr.sbin/ypldap/aldap.c

659

lu->filter = p;

usr.sbin/ypldap/aldap.c

681

if (aldap_search(ldap, lu->dn, lu->scope, lu->filter, lu->attributes,

usr.sbin/ypldap/aldap.c

743

ldap_parse_search_filter(struct ber_element *ber, char *filter)

usr.sbin/ypldap/aldap.c

748

cp = filter;

usr.sbin/ypldap/aldap.h

82

char *filter;

usr.sbin/ypldap/ldapclient.c

503

char **attrs, char *filter, int min_attr, int max_attr,

usr.sbin/ypldap/ldapclient.c

518

filter, attrs, 0, 0, 0, pg) == -1) {