arch/arm/mm/cache-l2x0.c

1132

u32 filter[2] = { 0, 0 };

arch/arm/mm/cache-l2x0.c

1155

filter, ARRAY_SIZE(filter));

arch/arm/mm/cache-l2x0.c

1156

if (filter[1]) {

arch/arm/mm/cache-l2x0.c

1158

ALIGN(filter[0] + filter[1], SZ_1M);

arch/arm/mm/cache-l2x0.c

1159

l2x0_saved_regs.filter_start = (filter[0] & ~(SZ_1M - 1))

arch/arm64/include/asm/kvm_nested.h

340

struct s1_walk_filter *filter;

arch/arm64/kernel/pi/idreg-override.c

305

bool (*filter)(u64 val);

arch/arm64/kernel/pi/idreg-override.c

316

filter = prel64_pointer(reg->fields[f].filter);

arch/arm64/kernel/pi/idreg-override.c

317

if (filter && !filter(v)) {

arch/arm64/kernel/pi/idreg-override.c

35

PREL64(filter_t, filter);

arch/arm64/kernel/pi/idreg-override.c

39

#define FIELD(n, s, f) { .name = n, .shift = s, .width = 4, .filter = f }

arch/arm64/kvm/at.c

1641

.filter = &(struct s1_walk_filter){

arch/arm64/kvm/at.c

442

if (wi->filter) {

arch/arm64/kvm/at.c

443

ret = wi->filter->fn(&(struct s1_walk_context)

arch/arm64/kvm/at.c

448

}, wi->filter->priv);

arch/arm64/kvm/hypercalls.c

175

struct kvm_smccc_filter filter;

arch/arm64/kvm/hypercalls.c

179

if (copy_from_user(&filter, uaddr, sizeof(filter)))

arch/arm64/kvm/hypercalls.c

182

if (memcmp(filter.pad, zero_page, sizeof(filter.pad)))

arch/arm64/kvm/hypercalls.c

185

start = filter.base;

arch/arm64/kvm/hypercalls.c

186

end = start + filter.nr_functions - 1;

arch/arm64/kvm/hypercalls.c

188

if (end < start || filter.action >= NR_SMCCC_FILTER_ACTIONS)

arch/arm64/kvm/hypercalls.c

205

xa_mk_value(filter.action), GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/pmu-emul.c

1161

struct kvm_pmu_event_filter filter;

arch/arm64/kvm/pmu-emul.c

1173

if (copy_from_user(&filter, uaddr, sizeof(filter)))

arch/arm64/kvm/pmu-emul.c

1176

if (((u32)filter.base_event + filter.nevents) > nr_events ||

arch/arm64/kvm/pmu-emul.c

1177

(filter.action != KVM_PMU_EVENT_ALLOW &&

arch/arm64/kvm/pmu-emul.c

1178

filter.action != KVM_PMU_EVENT_DENY))

arch/arm64/kvm/pmu-emul.c

1195

if (filter.action == KVM_PMU_EVENT_ALLOW)

arch/arm64/kvm/pmu-emul.c

1201

if (filter.action == KVM_PMU_EVENT_ALLOW)

arch/arm64/kvm/pmu-emul.c

1202

bitmap_set(kvm->arch.pmu_filter, filter.base_event, filter.nevents);

arch/arm64/kvm/pmu-emul.c

1204

bitmap_clear(kvm->arch.pmu_filter, filter.base_event, filter.nevents);

arch/arm64/kvm/sys_regs.c

2560

#define SYS_REG_USER_FILTER(name, acc, rst, v, gu, su, filter) { \

arch/arm64/kvm/sys_regs.c

2567

.visibility = filter, \

arch/arm64/kvm/sys_regs.c

2571

#define EL2_REG_FILTERED(name, acc, rst, v, filter) \

arch/arm64/kvm/sys_regs.c

2572

SYS_REG_USER_FILTER(name, acc, rst, v, NULL, NULL, filter)

arch/mips/kernel/perf_event_mipsxx.c

101

#define M_PERFCTL_MT_EN(filter) 0

arch/mips/kernel/perf_event_mipsxx.c

103

#define M_PERFCTL_MT_EN(filter) (filter)

arch/powerpc/kernel/rtas.c

110

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

123

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

130

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

140

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

147

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

170

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

1789

f = func->filter;

arch/powerpc/kernel/rtas.c

180

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

197

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

204

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

218

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

225

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

239

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

255

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

262

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

286

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

310

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

329

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

344

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

370

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

380

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

402

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

409

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

420

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

433

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

443

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

457

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

471

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

480

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

515

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

522

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

529

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

536

.filter = &(const struct rtas_filter) {

arch/powerpc/kernel/rtas.c

87

const struct rtas_filter *filter;

arch/s390/kvm/kvm-s390.c

1573

unsigned long data, filter;

arch/s390/kvm/kvm-s390.c

1575

filter = uv_info.uv_feature_indications & KVM_S390_VM_CPU_UV_FEAT_GUEST_MASK;

arch/s390/kvm/kvm-s390.c

1578

if (!bitmap_subset(&data, &filter, KVM_S390_VM_CPU_UV_FEAT_NR_BITS))

arch/sparc/net/bpf_jit_comp_32.c

330

const struct sock_filter *filter = fp->insns;

arch/sparc/net/bpf_jit_comp_32.c

387

if (bpf_needs_clear_a(&filter[0]))

arch/sparc/net/bpf_jit_comp_32.c

391

unsigned int K = filter[i].k;

arch/sparc/net/bpf_jit_comp_32.c

395

u16 code = bpf_anc_helper(&filter[i]);

arch/sparc/net/bpf_jit_comp_32.c

652

cond_branch: f_offset = addrs[i + filter[i].jf];

arch/sparc/net/bpf_jit_comp_32.c

653

t_offset = addrs[i + filter[i].jt];

arch/sparc/net/bpf_jit_comp_32.c

656

if (filter[i].jt == filter[i].jf) {

arch/sparc/net/bpf_jit_comp_32.c

692

if (filter[i].jt != 0) {

arch/sparc/net/bpf_jit_comp_32.c

693

if (filter[i].jf)

arch/sparc/net/bpf_jit_comp_32.c

697

if (filter[i].jf) {

arch/um/drivers/vector_kern.c

1140

kfree(vp->bpf->filter);

arch/um/drivers/vector_kern.c

1379

kfree(vp->bpf->filter);

arch/um/drivers/vector_kern.c

1380

vp->bpf->filter = NULL;

arch/um/drivers/vector_kern.c

1394

vp->bpf->filter = kmemdup(fw->data, fw->size, GFP_ATOMIC);

arch/um/drivers/vector_kern.c

1395

if (!vp->bpf->filter)

arch/um/drivers/vector_kern.c

1411

kfree(vp->bpf->filter);

arch/um/drivers/vector_user.c

844

printk(KERN_ERR BPF_ATTACH_FAIL, prog->len, prog->filter, fd, -errno);

arch/um/drivers/vector_user.c

854

printk(KERN_ERR BPF_DETACH_FAIL, prog->len, prog->filter, fd, -errno);

arch/um/drivers/vector_user.c

867

bpf_prog->filter = NULL;

arch/um/drivers/vector_user.c

874

bpf_prog->filter = bpf;

arch/um/drivers/vector_user.c

916

bpf_prog->filter = NULL;

arch/um/drivers/vector_user.c

927

bpf_prog->filter = bpf;

arch/um/kernel/skas/stub_exe.c

133

struct sock_filter filter[] = {

arch/um/kernel/skas/stub_exe.c

196

.len = sizeof(filter) / sizeof(filter[0]),

arch/um/kernel/skas/stub_exe.c

197

.filter = filter,

arch/um/os-Linux/start_up.c

256

static struct sock_filter filter[] = {

arch/um/os-Linux/start_up.c

264

.len = ARRAY_SIZE(filter),

arch/um/os-Linux/start_up.c

265

.filter = filter,

arch/x86/events/core.c

2102

static_call_update(x86_pmu_filter, x86_pmu.filter);

arch/x86/events/core.c

2800

.filter = x86_pmu_filter,

arch/x86/events/core.c

99

DEFINE_STATIC_CALL_NULL(x86_pmu_filter, *x86_pmu.filter);

arch/x86/events/intel/core.c

7400

x86_pmu.filter = intel_pmu_filter;

arch/x86/events/intel/pt.c

1433

struct perf_addr_filter *filter;

arch/x86/events/intel/pt.c

1436

list_for_each_entry(filter, filters, entry) {

arch/x86/events/intel/pt.c

1441

if (!filter->size ||

arch/x86/events/intel/pt.c

1442

filter->action == PERF_ADDR_FILTER_ACTION_START)

arch/x86/events/intel/pt.c

1458

struct perf_addr_filter *filter;

arch/x86/events/intel/pt.c

1464

list_for_each_entry(filter, &head->list, entry) {

arch/x86/events/intel/pt.c

1465

if (filter->path.dentry && !fr[range].start) {

arch/x86/events/intel/pt.c

1490

filters->filter[range].msr_a = msr_a;

arch/x86/events/intel/pt.c

1491

filters->filter[range].msr_b = msr_b;

arch/x86/events/intel/pt.c

1492

if (filter->action == PERF_ADDR_FILTER_ACTION_FILTER)

arch/x86/events/intel/pt.c

1493

filters->filter[range].config = 1;

arch/x86/events/intel/pt.c

1495

filters->filter[range].config = 2;

arch/x86/events/intel/pt.c

477

struct pt_filter *filter = &filters->filter[range];

arch/x86/events/intel/pt.c

489

if (pt->filters.filter[range].msr_a != filter->msr_a) {

arch/x86/events/intel/pt.c

490

wrmsrq(pt_address_ranges[range].msr_a, filter->msr_a);

arch/x86/events/intel/pt.c

491

pt->filters.filter[range].msr_a = filter->msr_a;

arch/x86/events/intel/pt.c

494

if (pt->filters.filter[range].msr_b != filter->msr_b) {

arch/x86/events/intel/pt.c

495

wrmsrq(pt_address_ranges[range].msr_b, filter->msr_b);

arch/x86/events/intel/pt.c

496

pt->filters.filter[range].msr_b = filter->msr_b;

arch/x86/events/intel/pt.c

499

rtit_ctl |= (u64)filter->config << pt_address_ranges[range].reg_off;

arch/x86/events/intel/pt.h

109

struct pt_filter filter[PT_FILTERS_NUM];

arch/x86/events/intel/uncore_snbep.c

1770

u64 filter = uncore_shared_reg_config(box, 0);

arch/x86/events/intel/uncore_snbep.c

1771

wrmsrq(reg1->reg, filter & 0xffffffff);

arch/x86/events/intel/uncore_snbep.c

1772

wrmsrq(reg1->reg + 6, filter >> 32);

arch/x86/events/intel/uncore_snbep.c

2754

u64 filter = uncore_shared_reg_config(box, 0);

arch/x86/events/intel/uncore_snbep.c

2755

wrmsrq(reg1->reg, filter & 0xffffffff);

arch/x86/events/intel/uncore_snbep.c

2756

wrmsrq(reg1->reg + 1, filter >> 32);

arch/x86/events/perf_event.h

1035

void (*filter)(struct pmu *pmu, int cpu, bool *ret);

arch/x86/kvm/pmu.c

1143

static bool is_masked_filter_valid(const struct kvm_x86_pmu_event_filter *filter)

arch/x86/kvm/pmu.c

1151

for (i = 0; i < filter->nevents; i++) {

arch/x86/kvm/pmu.c

1152

if (filter->events[i] & ~mask)

arch/x86/kvm/pmu.c

1159

static void convert_to_masked_filter(struct kvm_x86_pmu_event_filter *filter)

arch/x86/kvm/pmu.c

1163

for (i = 0, j = 0; i < filter->nevents; i++) {

arch/x86/kvm/pmu.c

1170

if (filter->events[i] & ~(kvm_pmu_ops.EVENTSEL_EVENT |

arch/x86/kvm/pmu.c

1181

filter->events[j++] = filter->events[i] |

arch/x86/kvm/pmu.c

1185

filter->nevents = j;

arch/x86/kvm/pmu.c

1188

static int prepare_filter_lists(struct kvm_x86_pmu_event_filter *filter)

arch/x86/kvm/pmu.c

1192

if (!(filter->flags & KVM_PMU_EVENT_FLAG_MASKED_EVENTS))

arch/x86/kvm/pmu.c

1193

convert_to_masked_filter(filter);

arch/x86/kvm/pmu.c

1194

else if (!is_masked_filter_valid(filter))

arch/x86/kvm/pmu.c

1204

sort(&filter->events, filter->nevents, sizeof(filter->events[0]),

arch/x86/kvm/pmu.c

1207

i = filter->nevents;

arch/x86/kvm/pmu.c

1209

if (filter->flags & KVM_PMU_EVENT_FLAG_MASKED_EVENTS) {

arch/x86/kvm/pmu.c

1210

for (i = 0; i < filter->nevents; i++) {

arch/x86/kvm/pmu.c

1211

if (filter->events[i] & KVM_PMU_MASKED_ENTRY_EXCLUDE)

arch/x86/kvm/pmu.c

1216

filter->nr_includes = i;

arch/x86/kvm/pmu.c

1217

filter->nr_excludes = filter->nevents - filter->nr_includes;

arch/x86/kvm/pmu.c

1218

filter->includes = filter->events;

arch/x86/kvm/pmu.c

1219

filter->excludes = filter->events + filter->nr_includes;

arch/x86/kvm/pmu.c

1227

struct kvm_x86_pmu_event_filter *filter;

arch/x86/kvm/pmu.c

1247

size = struct_size(filter, events, tmp.nevents);

arch/x86/kvm/pmu.c

1248

filter = kzalloc(size, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/pmu.c

1249

if (!filter)

arch/x86/kvm/pmu.c

1252

filter->action = tmp.action;

arch/x86/kvm/pmu.c

1253

filter->nevents = tmp.nevents;

arch/x86/kvm/pmu.c

1254

filter->fixed_counter_bitmap = tmp.fixed_counter_bitmap;

arch/x86/kvm/pmu.c

1255

filter->flags = tmp.flags;

arch/x86/kvm/pmu.c

1258

if (copy_from_user(filter->events, user_filter->events,

arch/x86/kvm/pmu.c

1259

sizeof(filter->events[0]) * filter->nevents))

arch/x86/kvm/pmu.c

1262

r = prepare_filter_lists(filter);

arch/x86/kvm/pmu.c

1267

filter = rcu_replace_pointer(kvm->arch.pmu_event_filter, filter,

arch/x86/kvm/pmu.c

1282

kfree(filter);

arch/x86/kvm/pmu.c

493

static bool is_fixed_event_allowed(struct kvm_x86_pmu_event_filter *filter,

arch/x86/kvm/pmu.c

498

if (filter->action == KVM_PMU_EVENT_DENY &&

arch/x86/kvm/pmu.c

499

test_bit(fixed_idx, (ulong *)&filter->fixed_counter_bitmap))

arch/x86/kvm/pmu.c

501

if (filter->action == KVM_PMU_EVENT_ALLOW &&

arch/x86/kvm/pmu.c

502

!test_bit(fixed_idx, (ulong *)&filter->fixed_counter_bitmap))

arch/x86/kvm/pmu.c

510

struct kvm_x86_pmu_event_filter *filter;

arch/x86/kvm/pmu.c

513

filter = srcu_dereference(kvm->arch.pmu_event_filter, &kvm->srcu);

arch/x86/kvm/pmu.c

514

if (!filter)

arch/x86/kvm/pmu.c

518

return is_gp_event_allowed(filter, pmc->eventsel);

arch/x86/kvm/pmu.c

520

return is_fixed_event_allowed(filter, pmc->idx);

arch/x86/kvm/x86.c

7052

struct kvm_msr_filter *filter)

arch/x86/kvm/x86.c

7060

if (filter->flags & ~KVM_MSR_FILTER_VALID_MASK)

arch/x86/kvm/x86.c

7063

for (i = 0; i < ARRAY_SIZE(filter->ranges); i++)

arch/x86/kvm/x86.c

7064

empty &= !filter->ranges[i].nmsrs;

arch/x86/kvm/x86.c

7066

default_allow = !(filter->flags & KVM_MSR_FILTER_DEFAULT_DENY);

arch/x86/kvm/x86.c

7074

for (i = 0; i < ARRAY_SIZE(filter->ranges); i++) {

arch/x86/kvm/x86.c

7075

r = kvm_add_msr_filter(new_filter, &filter->ranges[i]);

arch/x86/kvm/x86.c

7126

struct kvm_msr_filter filter;

arch/x86/kvm/x86.c

7133

filter.flags = filter_compat.flags;

arch/x86/kvm/x86.c

7134

for (i = 0; i < ARRAY_SIZE(filter.ranges); i++) {

arch/x86/kvm/x86.c

7138

filter.ranges[i] = (struct kvm_msr_filter_range) {

arch/x86/kvm/x86.c

7146

r = kvm_vm_ioctl_set_msr_filter(kvm, &filter);

arch/x86/kvm/x86.c

7604

struct kvm_msr_filter filter;

arch/x86/kvm/x86.c

7606

if (copy_from_user(&filter, user_msr_filter, sizeof(filter)))

arch/x86/kvm/x86.c

7609

r = kvm_vm_ioctl_set_msr_filter(kvm, &filter);

drivers/acpi/ec.c

216

#define ec_log(filter, fmt, ...) \

drivers/acpi/ec.c

217

ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)

drivers/acpi/ec.c

218

#define ec_dbg(filter, fmt, ...) \

drivers/acpi/ec.c

219

ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)

drivers/ata/ahci.c

1594

unsigned int filter;

drivers/ata/ahci.c

1600

filter = (unsigned long)dmi->driver_data;

drivers/ata/ahci.c

1602

filter, dmi->ident);

drivers/ata/ahci.c

1611

dev->gtf_filter |= filter;

drivers/base/bus.c

231

.filter = bus_uevent_filter,

drivers/base/core.c

2721

.filter = dev_uevent_filter,

drivers/base/core.c

2748

if (kset->uevent_ops && kset->uevent_ops->filter)

drivers/base/core.c

2749

if (!kset->uevent_ops->filter(&dev->kobj))

drivers/clk/clk-axi-clkgen.c

353

u32 power = 0, filter, lock;

drivers/clk/clk-axi-clkgen.c

368

filter = axi_clkgen_lookup_filter(m - 1);

drivers/clk/clk-axi-clkgen.c

389

axi_clkgen_mmcm_write(axi_clkgen, MMCM_REG_FILTER1, filter >> 16, 0x9900);

drivers/clk/clk-axi-clkgen.c

390

axi_clkgen_mmcm_write(axi_clkgen, MMCM_REG_FILTER2, filter, 0x9900);

drivers/clk/clk-vt8500.c

454

u32 *filter, u32 *multiplier, u32 *divisor1, u32 *divisor2)

drivers/clk/clk-vt8500.c

472

*filter = wm8750_get_filter(parent_rate, div1);

drivers/clk/clk-vt8500.c

496

*filter = wm8750_get_filter(parent_rate, *divisor1);

drivers/clk/clk-vt8500.c

551

u32 filter, mul, div1, div2;

drivers/clk/clk-vt8500.c

570

ret = wm8750_find_pll_bits(rate, parent_rate, &filter, &mul, &div1, &div2);

drivers/clk/clk-vt8500.c

572

pll_val = WM8750_BITS_TO_VAL(filter, mul, div1, div2);

drivers/clk/clk-vt8500.c

602

u32 filter, mul, div1, div2;

drivers/clk/clk-vt8500.c

623

&filter, &mul, &div1, &div2);

drivers/comedi/drivers/jr3_pci.c

214

unsigned int filter = chan / 8;

drivers/comedi/drivers/jr3_pci.c

218

val = get_s16(&spriv->sensor->filter[filter].fx);

drivers/comedi/drivers/jr3_pci.c

221

val = get_s16(&spriv->sensor->filter[filter].fy);

drivers/comedi/drivers/jr3_pci.c

224

val = get_s16(&spriv->sensor->filter[filter].fz);

drivers/comedi/drivers/jr3_pci.c

227

val = get_s16(&spriv->sensor->filter[filter].mx);

drivers/comedi/drivers/jr3_pci.c

230

val = get_s16(&spriv->sensor->filter[filter].my);

drivers/comedi/drivers/jr3_pci.c

233

val = get_s16(&spriv->sensor->filter[filter].mz);

drivers/comedi/drivers/jr3_pci.c

236

val = get_s16(&spriv->sensor->filter[filter].v1);

drivers/comedi/drivers/jr3_pci.c

239

val = get_s16(&spriv->sensor->filter[filter].v2);

drivers/comedi/drivers/jr3_pci.h

457

struct force_array filter[7]; /*

drivers/comedi/drivers/ni_mio_common.c

4660

enum ni_pfi_filter_select filter)

drivers/comedi/drivers/ni_mio_common.c

4675

bits |= NI_M_PFI_FILTER_SEL(chan, filter);

drivers/connector/connector.c

115

gfp_mask, filter,

drivers/connector/connector.c

62

gfp_t gfp_mask, netlink_filter_fn filter,

drivers/dma-buf/selftest.c

49

char *filter, *sep, *tok;

drivers/dma-buf/selftest.c

52

filter = kstrdup(__st_filter, GFP_KERNEL);

drivers/dma-buf/selftest.c

53

for (sep = filter; (tok = strsep(&sep, ","));) {

drivers/dma-buf/selftest.c

85

kfree(filter);

drivers/dma/amba-pl08x.c

2811

pl08x->slave.filter.map = pl08x->pd->slave_map;

drivers/dma/amba-pl08x.c

2812

pl08x->slave.filter.mapcnt = pl08x->pd->slave_map_len;

drivers/dma/amba-pl08x.c

2813

pl08x->slave.filter.fn = pl08x_filter_fn;

drivers/dma/amd/qdma/qdma.c

1104

qdev->dma_dev.filter.map = pdata->device_map;

drivers/dma/amd/qdma/qdma.c

1105

qdev->dma_dev.filter.mapcnt = qdev->chan_num * 2;

drivers/dma/amd/qdma/qdma.c

1106

qdev->dma_dev.filter.fn = qdma_filter_fn;

drivers/dma/dmaengine.c

794

if (!device->filter.mapcnt)

drivers/dma/dmaengine.c

797

for (i = 0; i < device->filter.mapcnt; i++) {

drivers/dma/dmaengine.c

798

const struct dma_slave_map *map = &device->filter.map[i];

drivers/dma/dmaengine.c

844

chan = find_candidate(d, &mask, d->filter.fn, map->param);

drivers/dma/dmatest.c

1091

chan = dma_request_channel(mask, filter, params);

drivers/dma/idxd/perfmon.c

541

idxd_pmu->supported_filters = perfcap.filter;

drivers/dma/idxd/perfmon.c

542

if (perfcap.filter)

drivers/dma/idxd/perfmon.c

543

idxd_pmu->n_filters = hweight8(perfcap.filter);

drivers/dma/idxd/registers.h

475

u64 filter:8;

drivers/dma/mcf-edma-main.c

237

mcf_edma->dma_dev.filter.fn = mcf_edma_filter_fn;

drivers/dma/mcf-edma-main.c

238

mcf_edma->dma_dev.filter.map = pdata->slave_map;

drivers/dma/mcf-edma-main.c

239

mcf_edma->dma_dev.filter.mapcnt = pdata->slavecnt;

drivers/dma/pxa_dma.c

1394

pdev->slave.filter.map = slave_map;

drivers/dma/pxa_dma.c

1395

pdev->slave.filter.mapcnt = slave_map_cnt;

drivers/dma/pxa_dma.c

1396

pdev->slave.filter.fn = pxad_filter_fn;

drivers/dma/sa11x0-dma.c

919

d->slave.filter.fn = sa11x0_dma_filter_fn;

drivers/dma/sa11x0-dma.c

920

d->slave.filter.mapcnt = ARRAY_SIZE(sa11x0_dma_map);

drivers/dma/sa11x0-dma.c

921

d->slave.filter.map = sa11x0_dma_map;

drivers/dma/ti/edma.c

2521

ecc->dma_slave.filter.map = info->slave_map;

drivers/dma/ti/edma.c

2522

ecc->dma_slave.filter.mapcnt = info->slavecnt;

drivers/dma/ti/edma.c

2523

ecc->dma_slave.filter.fn = edma_filter_fn;

drivers/dma/ti/omap-dma.c

1791

od->ddev.filter.map = od->plat->slave_map;

drivers/dma/ti/omap-dma.c

1792

od->ddev.filter.mapcnt = od->plat->slavecnt;

drivers/dma/ti/omap-dma.c

1793

od->ddev.filter.fn = omap_dma_filter_fn;

drivers/dma/xilinx/xdma.c

1272

xdev->dma_dev.filter.map = pdata->device_map;

drivers/dma/xilinx/xdma.c

1273

xdev->dma_dev.filter.mapcnt = pdata->device_map_cnt;

drivers/dma/xilinx/xdma.c

1274

xdev->dma_dev.filter.fn = xdma_filter_fn;

drivers/dpll/dpll_netlink.c

20

#define xa_for_each_marked_start(xa, index, entry, filter, start) \

drivers/dpll/dpll_netlink.c

21

for (index = start, entry = xa_find(xa, &index, ULONG_MAX, filter); \

drivers/dpll/dpll_netlink.c

22

entry; entry = xa_find_after(xa, &index, ULONG_MAX, filter))

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c

2375

enum kfd_unmap_queues_filter filter,

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c

2398

retval = pm_send_unmap_queue(&dqm->packet_mgr, filter, filter_param, reset);

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c

2468

enum kfd_unmap_queues_filter filter,

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c

2476

retval = unmap_queues_cpsch(dqm, filter, filter_param, grace_period, false);

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c

2782

enum kfd_unmap_queues_filter filter =

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c

2794

filter = KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES;

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c

2830

retval = execute_queues_cpsch(dqm, filter, 0, USE_DEFAULT_GRACE_PERIOD);

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c

53

enum kfd_unmap_queues_filter filter,

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c

57

enum kfd_unmap_queues_filter filter,

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c

493

enum kfd_unmap_queues_filter filter,

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c

511

retval = pm->pmf->unmap_queues(pm, buffer, filter, filter_param, reset);

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager_v9.c

391

enum kfd_unmap_queues_filter filter,

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager_v9.c

417

switch (filter) {

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager_v9.c

433

WARN(1, "filter %d", filter);

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager_vi.c

197

enum kfd_unmap_queues_filter filter,

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager_vi.c

218

switch (filter) {

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager_vi.c

234

WARN(1, "filter %d", filter);

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_dwb_scl.c

686

const uint16_t *filter)

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_dwb_scl.c

693

if (!filter)

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_dwb_scl.c

698

even_coef = filter[phase * taps + 2 * pair];

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_dwb_scl.c

700

odd_coef = filter[phase * taps + 2 * pair + 1];

drivers/gpu/drm/amd/display/dc/dpp/dcn10/dcn10_dpp_dscl.c

244

const uint16_t *filter)

drivers/gpu/drm/amd/display/dc/dpp/dcn10/dcn10_dpp_dscl.c

258

even_coef = filter[phase * taps + 2 * pair];

drivers/gpu/drm/amd/display/dc/dpp/dcn10/dcn10_dpp_dscl.c

260

odd_coef = filter[phase * taps + 2 * pair + 1];

drivers/gpu/drm/amd/display/dc/dpp/dcn401/dcn401_dpp_dscl.c

236

const uint16_t *filter)

drivers/gpu/drm/amd/display/dc/dpp/dcn401/dcn401_dpp_dscl.c

250

even_coef = filter[phase * taps + 2 * pair];

drivers/gpu/drm/amd/display/dc/dpp/dcn401/dcn401_dpp_dscl.c

252

odd_coef = filter[phase * taps + 2 * pair + 1];

drivers/gpu/drm/amd/display/dc/dpp/dcn401/dcn401_dpp_dscl.c

921

struct dcn401_dpp *dpp, const uint32_t *filter)

drivers/gpu/drm/amd/display/dc/dpp/dcn401/dcn401_dpp_dscl.c

925

if (filter == NULL)

drivers/gpu/drm/amd/display/dc/dpp/dcn401/dcn401_dpp_dscl.c

934

filter_data = filter[level];

drivers/gpu/drm/bridge/cros-ec-anx7688.c

151

anx7688->filter = true;

drivers/gpu/drm/bridge/cros-ec-anx7688.c

39

bool filter;

drivers/gpu/drm/bridge/cros-ec-anx7688.c

58

if (!anx->filter)

drivers/gpu/drm/i915/display/skl_scaler.c

728

static u32 skl_scaler_get_filter_select(enum drm_scaling_filter filter)

drivers/gpu/drm/i915/display/skl_scaler.c

730

if (filter == DRM_SCALING_FILTER_NEAREST_NEIGHBOR)

drivers/gpu/drm/i915/display/skl_scaler.c

742

int id, int set, enum drm_scaling_filter filter)

drivers/gpu/drm/i915/display/skl_scaler.c

744

switch (filter) {

drivers/gpu/drm/i915/display/skl_scaler.c

751

MISSING_CASE(filter);

drivers/gpu/drm/i915/gt/selftest_execlists.c

3842

bool (*filter)(const struct intel_engine_cs *))

drivers/gpu/drm/i915/gt/selftest_execlists.c

3851

if (filter && !filter(gt->engine_class[class][inst]))

drivers/gpu/drm/i915/i915_selftest.h

38

char *filter;

drivers/gpu/drm/i915/selftests/i915_selftest.c

324

char *filter, *sep, *tok;

drivers/gpu/drm/i915/selftests/i915_selftest.c

327

filter = kstrdup(i915_selftest.filter, GFP_KERNEL);

drivers/gpu/drm/i915/selftests/i915_selftest.c

328

for (sep = filter; (tok = strsep(&sep, ","));) {

drivers/gpu/drm/i915/selftests/i915_selftest.c

360

kfree(filter);

drivers/gpu/drm/i915/selftests/i915_selftest.c

509

module_param_named(st_filter, i915_selftest.filter, charp, 0400);

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

122

int i, j, filter;

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

171

for (filter = 0; filter < QSEED3_FILTERS; filter++) {

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

172

if (!lut[filter])

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

177

+ off_tbl[filter][i][1];

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

178

lut_len = off_tbl[filter][i][0] << 2;

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

182

(lut[filter])[lut_offset++]);

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

197

int j, filter;

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

226

for (filter = 0; filter < QSEED3LITE_FILTERS; filter++) {

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

227

if (!lut[filter])

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

230

lut_addr = QSEED3_COEF_LUT + offset + off_tbl[filter];

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

234

(lut[filter])[lut_offset++]);

drivers/gpu/drm/tegra/sor.c

108

.filter = 0x0,

drivers/gpu/drm/tegra/sor.c

123

.filter = 0x0,

drivers/gpu/drm/tegra/sor.c

142

.filter = 0x0,

drivers/gpu/drm/tegra/sor.c

157

.filter = 0x0,

drivers/gpu/drm/tegra/sor.c

172

.filter = 0x0,

drivers/gpu/drm/tegra/sor.c

187

.filter = 0x0,

drivers/gpu/drm/tegra/sor.c

207

.filter = 5,

drivers/gpu/drm/tegra/sor.c

222

.filter = 5,

drivers/gpu/drm/tegra/sor.c

237

.filter = 5,

drivers/gpu/drm/tegra/sor.c

2499

value |= SOR_PLL0_FILTER(settings->filter);

drivers/gpu/drm/tegra/sor.c

252

.filter = 5,

drivers/gpu/drm/tegra/sor.c

267

.filter = 5,

drivers/gpu/drm/tegra/sor.c

286

.filter = 5,

drivers/gpu/drm/tegra/sor.c

301

.filter = 5,

drivers/gpu/drm/tegra/sor.c

316

.filter = 5,

drivers/gpu/drm/tegra/sor.c

331

.filter = 5,

drivers/gpu/drm/tegra/sor.c

346

.filter = 5,

drivers/gpu/drm/tegra/sor.c

43

u8 filter;

drivers/gpu/drm/tegra/sor.c

63

.filter = 0x0,

drivers/gpu/drm/tegra/sor.c

78

.filter = 0x0,

drivers/gpu/drm/tegra/sor.c

93

.filter = 0x0,

drivers/gpu/drm/vmwgfx/device_include/svga3d_cmd.h

833

SVGA3dTextureFilter filter;

drivers/gpu/drm/vmwgfx/device_include/svga3d_dx.h

1325

SVGA3dFilter filter;

drivers/gpu/drm/vmwgfx/device_include/svga3d_dx.h

1344

SVGA3dFilter filter;

drivers/hid/hid-uclogic-core-test.c

67

struct uclogic_raw_event_hook *filter;

drivers/hid/hid-uclogic-core-test.c

77

filter = kunit_kzalloc(test, sizeof(*filter), GFP_KERNEL);

drivers/hid/hid-uclogic-core-test.c

78

KUNIT_ASSERT_NOT_ERR_OR_NULL(test, filter);

drivers/hid/hid-uclogic-core-test.c

80

filter->size = hook_events[n].size;

drivers/hid/hid-uclogic-core-test.c

81

filter->event = kunit_kzalloc(test, filter->size, GFP_KERNEL);

drivers/hid/hid-uclogic-core-test.c

82

KUNIT_ASSERT_NOT_ERR_OR_NULL(test, filter->event);

drivers/hid/hid-uclogic-core-test.c

83

memcpy(filter->event, &hook_events[n].event[0], filter->size);

drivers/hid/hid-uclogic-core-test.c

85

INIT_WORK(&filter->work, fake_work);

drivers/hid/hid-uclogic-core-test.c

87

list_add_tail(&filter->list, &p.event_hooks->list);

drivers/hwtracing/coresight/coresight-etm-perf.c

753

struct perf_addr_filter *filter;

drivers/hwtracing/coresight/coresight-etm-perf.c

755

list_for_each_entry(filter, filters, entry) {

drivers/hwtracing/coresight/coresight-etm-perf.c

764

if (filter->size) {

drivers/hwtracing/coresight/coresight-etm-perf.c

769

if (filter->action == PERF_ADDR_FILTER_ACTION_START ||

drivers/hwtracing/coresight/coresight-etm-perf.c

770

filter->action == PERF_ADDR_FILTER_ACTION_STOP)

drivers/hwtracing/coresight/coresight-etm-perf.c

795

struct perf_addr_filter *filter;

drivers/hwtracing/coresight/coresight-etm-perf.c

798

list_for_each_entry(filter, &head->list, entry) {

drivers/hwtracing/coresight/coresight-etm-perf.c

803

switch (filter->action) {

drivers/hwtracing/coresight/coresight-etm4x-core.c

1746

struct etm_filter *filter = &filters->etm_filter[i];

drivers/hwtracing/coresight/coresight-etm4x-core.c

1747

enum etm_addr_type type = filter->type;

drivers/hwtracing/coresight/coresight-etm4x-core.c

1759

filter->start_addr,

drivers/hwtracing/coresight/coresight-etm4x-core.c

1760

filter->stop_addr,

drivers/hwtracing/coresight/coresight-etm4x-core.c

1775

filter->start_addr :

drivers/hwtracing/coresight/coresight-etm4x-core.c

1776

filter->stop_addr);

drivers/hwtracing/ptt/hisi_ptt.c

233

val |= FIELD_PREP(HISI_PTT_TRACE_CTRL_TARGET_SEL, hisi_ptt->trace_ctrl.filter);

drivers/hwtracing/ptt/hisi_ptt.c

361

struct hisi_ptt_filter_desc *filter)

drivers/hwtracing/ptt/hisi_ptt.c

363

if (filter->is_port)

drivers/hwtracing/ptt/hisi_ptt.c

364

hisi_ptt->port_mask &= ~hisi_ptt_get_filter_val(filter->devid, true);

drivers/hwtracing/ptt/hisi_ptt.c

366

list_del(&filter->list);

drivers/hwtracing/ptt/hisi_ptt.c

367

kfree(filter->name);

drivers/hwtracing/ptt/hisi_ptt.c

368

kfree(filter);

drivers/hwtracing/ptt/hisi_ptt.c

374

struct hisi_ptt_filter_desc *filter;

drivers/hwtracing/ptt/hisi_ptt.c

387

filter = kzalloc_obj(*filter);

drivers/hwtracing/ptt/hisi_ptt.c

388

if (!filter) {

drivers/hwtracing/ptt/hisi_ptt.c

395

filter->name = filter_name;

drivers/hwtracing/ptt/hisi_ptt.c

396

filter->is_port = is_port;

drivers/hwtracing/ptt/hisi_ptt.c

397

filter->devid = devid;

drivers/hwtracing/ptt/hisi_ptt.c

399

if (filter->is_port) {

drivers/hwtracing/ptt/hisi_ptt.c

400

list_add_tail(&filter->list, &hisi_ptt->port_filters);

drivers/hwtracing/ptt/hisi_ptt.c

403

hisi_ptt->port_mask |= hisi_ptt_get_filter_val(filter->devid, true);

drivers/hwtracing/ptt/hisi_ptt.c

405

list_add_tail(&filter->list, &hisi_ptt->req_filters);

drivers/hwtracing/ptt/hisi_ptt.c

408

return filter;

drivers/hwtracing/ptt/hisi_ptt.c

414

struct hisi_ptt_filter_desc *filter;

drivers/hwtracing/ptt/hisi_ptt.c

417

filter = container_of(attr, struct hisi_ptt_filter_desc, attr);

drivers/hwtracing/ptt/hisi_ptt.c

418

filter_val = hisi_ptt_get_filter_val(filter->devid, filter->is_port) |

drivers/hwtracing/ptt/hisi_ptt.c

419

(filter->is_port ? HISI_PTT_PMU_FILTER_IS_PORT : 0);

drivers/hwtracing/ptt/hisi_ptt.c

425

struct hisi_ptt_filter_desc *filter)

drivers/hwtracing/ptt/hisi_ptt.c

429

sysfs_attr_init(&filter->attr.attr);

drivers/hwtracing/ptt/hisi_ptt.c

430

filter->attr.attr.name = filter->name;

drivers/hwtracing/ptt/hisi_ptt.c

431

filter->attr.attr.mode = 0400; /* DEVICE_ATTR_ADMIN_RO */

drivers/hwtracing/ptt/hisi_ptt.c

432

filter->attr.show = hisi_ptt_filter_show;

drivers/hwtracing/ptt/hisi_ptt.c

434

return sysfs_add_file_to_group(kobj, &filter->attr.attr,

drivers/hwtracing/ptt/hisi_ptt.c

439

struct hisi_ptt_filter_desc *filter)

drivers/hwtracing/ptt/hisi_ptt.c

443

sysfs_remove_file_from_group(kobj, &filter->attr.attr,

drivers/hwtracing/ptt/hisi_ptt.c

448

struct hisi_ptt_filter_desc *filter)

drivers/hwtracing/ptt/hisi_ptt.c

452

sysfs_attr_init(&filter->attr.attr);

drivers/hwtracing/ptt/hisi_ptt.c

453

filter->attr.attr.name = filter->name;

drivers/hwtracing/ptt/hisi_ptt.c

454

filter->attr.attr.mode = 0400; /* DEVICE_ATTR_ADMIN_RO */

drivers/hwtracing/ptt/hisi_ptt.c

455

filter->attr.show = hisi_ptt_filter_show;

drivers/hwtracing/ptt/hisi_ptt.c

457

return sysfs_add_file_to_group(kobj, &filter->attr.attr,

drivers/hwtracing/ptt/hisi_ptt.c

462

struct hisi_ptt_filter_desc *filter)

drivers/hwtracing/ptt/hisi_ptt.c

466

sysfs_remove_file_from_group(kobj, &filter->attr.attr,

drivers/hwtracing/ptt/hisi_ptt.c

471

struct hisi_ptt_filter_desc *filter)

drivers/hwtracing/ptt/hisi_ptt.c

475

if (filter->is_port)

drivers/hwtracing/ptt/hisi_ptt.c

476

ret = hisi_ptt_create_rp_filter_attr(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

478

ret = hisi_ptt_create_req_filter_attr(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

482

filter->name);

drivers/hwtracing/ptt/hisi_ptt.c

488

struct hisi_ptt_filter_desc *filter)

drivers/hwtracing/ptt/hisi_ptt.c

490

if (filter->is_port)

drivers/hwtracing/ptt/hisi_ptt.c

491

hisi_ptt_remove_rp_filter_attr(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

493

hisi_ptt_remove_req_filter_attr(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

498

struct hisi_ptt_filter_desc *filter;

drivers/hwtracing/ptt/hisi_ptt.c

503

list_for_each_entry(filter, &hisi_ptt->req_filters, list)

drivers/hwtracing/ptt/hisi_ptt.c

504

hisi_ptt_remove_filter_attr(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

506

list_for_each_entry(filter, &hisi_ptt->port_filters, list)

drivers/hwtracing/ptt/hisi_ptt.c

507

hisi_ptt_remove_filter_attr(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

515

struct hisi_ptt_filter_desc *filter;

drivers/hwtracing/ptt/hisi_ptt.c

531

list_for_each_entry(filter, &hisi_ptt->port_filters, list) {

drivers/hwtracing/ptt/hisi_ptt.c

532

ret = hisi_ptt_create_filter_attr(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

537

list_for_each_entry(filter, &hisi_ptt->req_filters, list) {

drivers/hwtracing/ptt/hisi_ptt.c

538

ret = hisi_ptt_create_filter_attr(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

553

struct hisi_ptt_filter_desc *filter;

drivers/hwtracing/ptt/hisi_ptt.c

570

filter = hisi_ptt_alloc_add_filter(hisi_ptt, info.devid, info.is_port);

drivers/hwtracing/ptt/hisi_ptt.c

571

if (!filter)

drivers/hwtracing/ptt/hisi_ptt.c

581

hisi_ptt_create_filter_attr(hisi_ptt, filter)) {

drivers/hwtracing/ptt/hisi_ptt.c

582

hisi_ptt_del_free_filter(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

592

list_for_each_entry_safe(filter, tmp, target_list, list)

drivers/hwtracing/ptt/hisi_ptt.c

593

if (filter->devid == info.devid) {

drivers/hwtracing/ptt/hisi_ptt.c

595

hisi_ptt_remove_filter_attr(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

597

hisi_ptt_del_free_filter(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

663

struct hisi_ptt_filter_desc *filter;

drivers/hwtracing/ptt/hisi_ptt.c

680

filter = hisi_ptt_alloc_add_filter(hisi_ptt, pci_dev_id(pdev),

drivers/hwtracing/ptt/hisi_ptt.c

682

if (!filter)

drivers/hwtracing/ptt/hisi_ptt.c

690

struct hisi_ptt_filter_desc *filter, *tmp;

drivers/hwtracing/ptt/hisi_ptt.c

693

list_for_each_entry_safe(filter, tmp, &hisi_ptt->req_filters, list)

drivers/hwtracing/ptt/hisi_ptt.c

694

hisi_ptt_del_free_filter(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

696

list_for_each_entry_safe(filter, tmp, &hisi_ptt->port_filters, list)

drivers/hwtracing/ptt/hisi_ptt.c

697

hisi_ptt_del_free_filter(hisi_ptt, filter);

drivers/hwtracing/ptt/hisi_ptt.c

804

PMU_FORMAT_ATTR(filter, "config:0-19");

drivers/hwtracing/ptt/hisi_ptt.c

946

struct hisi_ptt_filter_desc *filter;

drivers/hwtracing/ptt/hisi_ptt.c

963

list_for_each_entry(filter, &hisi_ptt->req_filters, list) {

drivers/hwtracing/ptt/hisi_ptt.c

964

if (val == hisi_ptt_get_filter_val(filter->devid, filter->is_port))

drivers/hwtracing/ptt/hisi_ptt.c

983

hisi_ptt->trace_ctrl.filter = val;

drivers/hwtracing/ptt/hisi_ptt.h

139

u32 filter:16;

drivers/iio/accel/mma9553.c

165

u16 filter;

drivers/iio/accel/mma9553.c

571

*val = mma9553_get_bits(data->conf.filter,

drivers/iio/accel/mma9553.c

580

*val = mma9553_get_bits(data->conf.filter,

drivers/iio/accel/mma9553.c

657

&data->conf.filter, val,

drivers/iio/accel/mma9553.c

671

&data->conf.filter, val,

drivers/iio/accel/mma9553.c

857

gender = mma9553_get_bits(data->conf.filter, MMA9553_MASK_CONF_MALE);

drivers/iio/accel/mma9553.c

877

&data->conf.filter, gender,

drivers/iio/adc/ad4170-4.c

1319

f_type = __ad4170_get_filter_type(setup->filter);

drivers/iio/adc/ad4170-4.c

1484

enum ad4170_filter_type f_type = __ad4170_get_filter_type(setup->filter);

drivers/iio/adc/ad4170-4.c

410

u16 filter;

drivers/iio/adc/ad4170-4.c

597

a->filter != b->filter ||

drivers/iio/adc/ad4170-4.c

709

setup->filter);

drivers/iio/adc/ad4170-4.c

830

static int __ad4170_get_filter_type(unsigned int filter)

drivers/iio/adc/ad4170-4.c

832

u16 f_conf = FIELD_GET(AD4170_FILTER_FILTER_TYPE_MSK, filter);

drivers/iio/adc/ad4170-4.c

889

setup->filter &= ~AD4170_FILTER_FILTER_TYPE_MSK;

drivers/iio/adc/ad4170-4.c

890

setup->filter |= FIELD_PREP(AD4170_FILTER_FILTER_TYPE_MSK,

drivers/iio/adc/ad4170-4.c

907

return __ad4170_get_filter_type(setup->filter);

drivers/iio/adc/ad7124.c

450

unsigned int val, filter;

drivers/iio/adc/ad7124.c

477

filter = AD7124_FILTER_FILTER_SINC3;

drivers/iio/adc/ad7124.c

480

filter = AD7124_FILTER_FILTER_SINC3_PF;

drivers/iio/adc/ad7124.c

484

filter = AD7124_FILTER_FILTER_SINC3_PF;

drivers/iio/adc/ad7124.c

488

filter = AD7124_FILTER_FILTER_SINC3_PF;

drivers/iio/adc/ad7124.c

492

filter = AD7124_FILTER_FILTER_SINC3_PF;

drivers/iio/adc/ad7124.c

496

filter = AD7124_FILTER_FILTER_SINC3;

drivers/iio/adc/ad7124.c

500

filter = AD7124_FILTER_FILTER_SINC3_SINC1;

drivers/iio/adc/ad7124.c

503

filter = AD7124_FILTER_FILTER_SINC4;

drivers/iio/adc/ad7124.c

506

filter = AD7124_FILTER_FILTER_SINC4;

drivers/iio/adc/ad7124.c

510

filter = AD7124_FILTER_FILTER_SINC4_SINC1;

drivers/iio/adc/ad7124.c

525

FIELD_PREP(AD7124_FILTER_FILTER, filter) |

drivers/iio/adc/ad7768-1.c

882

unsigned int filter)

drivers/iio/adc/ad7768-1.c

887

ret = ad7768_configure_dig_fil(dev, filter, st->oversampling_ratio);

drivers/iio/adc/ad7791.c

197

uint8_t filter;

drivers/iio/adc/ad7791.c

304

rate = st->filter & AD7791_FILTER_RATE_MASK;

drivers/iio/adc/ad7791.c

330

st->filter &= ~AD7791_FILTER_RATE_MASK;

drivers/iio/adc/ad7791.c

331

st->filter |= i;

drivers/iio/adc/ad7791.c

333

sizeof(st->filter),

drivers/iio/adc/ad7791.c

334

st->filter);

drivers/iio/adc/ad7791.c

384

st->filter = AD7791_FILTER_RATE_16_6;

drivers/iio/adc/max11410.c

303

int ret, reg, rate, filter;

drivers/iio/adc/max11410.c

312

filter = max11410_sampling_rates[MAX11410_FILTER_SINC4][rate][0];

drivers/iio/adc/max11410.c

314

return sysfs_emit(buf, "%d\n", filter);

drivers/iio/adc/max11410.c

459

int ret, reg_val, filter, rate;

drivers/iio/adc/max11410.c

496

filter = FIELD_GET(MAX11410_FILTER_LINEF_MASK, reg_val);

drivers/iio/adc/max11410.c

498

if (rate >= max11410_sampling_len[filter])

drivers/iio/adc/max11410.c

499

rate = max11410_sampling_len[filter] - 1;

drivers/iio/adc/max11410.c

501

*val = max11410_sampling_rates[filter][rate][0];

drivers/iio/adc/max11410.c

502

*val2 = max11410_sampling_rates[filter][rate][1];

drivers/iio/adc/max11410.c

512

int ret, i, reg_val, filter;

drivers/iio/adc/max11410.c

520

filter = FIELD_GET(MAX11410_FILTER_LINEF_MASK, reg_val);

drivers/iio/adc/max11410.c

522

for (i = 0; i < max11410_sampling_len[filter]; ++i) {

drivers/iio/adc/max11410.c

523

if (val == max11410_sampling_rates[filter][i][0] &&

drivers/iio/adc/max11410.c

524

val2 == max11410_sampling_rates[filter][i][1])

drivers/iio/adc/max11410.c

527

if (i == max11410_sampling_len[filter])

drivers/iio/adc/max11410.c

585

int ret, reg_val, filter;

drivers/iio/adc/max11410.c

593

filter = FIELD_GET(MAX11410_FILTER_LINEF_MASK, reg_val);

drivers/iio/adc/max11410.c

595

*vals = (const int *)max11410_sampling_rates[filter];

drivers/iio/adc/max11410.c

596

*length = max11410_sampling_len[filter] * 2;

drivers/iio/gyro/bmg160_core.c

119

int filter;

drivers/iio/gyro/bmg160_core.c

204

*val = bmg160_samp_freq_table[i].filter;

drivers/iio/gyro/bmg160_core.c

217

if (bmg160_samp_freq_table[i].filter == val)

drivers/iio/imu/adis16475.c

417

static int adis16475_get_filter(struct adis16475 *st, u32 *filter)

drivers/iio/imu/adis16475.c

427

*filter = adis16475_3db_freqs[filter_sz & mask];

drivers/iio/imu/adis16475.c

432

static int adis16475_set_filter(struct adis16475 *st, const u32 filter)

drivers/iio/imu/adis16475.c

438

if (adis16475_3db_freqs[i] >= filter)

drivers/iio/imu/inv_icm42600/inv_icm42600.h

122

int filter;

drivers/iio/imu/inv_icm42600/inv_icm42600.h

199

enum inv_icm42600_filter filter;

drivers/iio/imu/inv_icm42600/inv_icm42600_accel.c

1170

accel_st->filter = INV_ICM42600_FILTER_AVG_16X;

drivers/iio/imu/inv_icm42600/inv_icm42600_accel.c

122

accel_st->filter = filter;

drivers/iio/imu/inv_icm42600/inv_icm42600_accel.c

249

conf.filter = accel_st->filter;

drivers/iio/imu/inv_icm42600/inv_icm42600_accel.c

302

conf.filter = accel_st->filter;

drivers/iio/imu/inv_icm42600/inv_icm42600_accel.c

393

conf.filter = accel_st->filter;

drivers/iio/imu/inv_icm42600/inv_icm42600_accel.c

90

int power_mode, filter;

drivers/iio/imu/inv_icm42600/inv_icm42600_accel.c

99

filter = inv_icm42600_accel_filter_values[idx];

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

117

.filter = INV_ICM42600_FILTER_BW_ODR_DIV_2,

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

123

.filter = INV_ICM42600_FILTER_BW_ODR_DIV_2,

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

133

.filter = INV_ICM42600_FILTER_BW_ODR_DIV_2,

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

139

.filter = INV_ICM42600_FILTER_BW_ODR_DIV_2,

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

307

if (conf->filter < 0)

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

308

conf->filter = oldconf->filter;

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

316

conf->filter = INV_ICM42600_FILTER_BW_ODR_DIV_2;

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

320

conf->filter = INV_ICM42600_FILTER_AVG_16X;

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

339

if (conf->filter != oldconf->filter) {

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

340

val = INV_ICM42600_GYRO_ACCEL_CONFIG0_ACCEL_FILT(conf->filter) |

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

341

INV_ICM42600_GYRO_ACCEL_CONFIG0_GYRO_FILT(st->conf.gyro.filter);

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

345

oldconf->filter = conf->filter;

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

368

if (conf->filter < 0)

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

369

conf->filter = oldconf->filter;

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

383

if (conf->filter != oldconf->filter) {

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

384

val = INV_ICM42600_GYRO_ACCEL_CONFIG0_ACCEL_FILT(st->conf.accel.filter) |

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

385

INV_ICM42600_GYRO_ACCEL_CONFIG0_GYRO_FILT(conf->filter);

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

389

oldconf->filter = conf->filter;

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

481

val = INV_ICM42600_GYRO_ACCEL_CONFIG0_ACCEL_FILT(conf->accel.filter) |

drivers/iio/imu/inv_icm42600/inv_icm42600_core.c

482

INV_ICM42600_GYRO_ACCEL_CONFIG0_GYRO_FILT(conf->gyro.filter);

drivers/iio/imu/inv_icm45600/inv_icm45600.h

97

u8 filter;

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

145

.filter = INV_ICM45600_GYRO_LP_AVG_SEL_8X,

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

151

.filter = INV_ICM45600_ACCEL_LP_AVG_SEL_4X,

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

160

.filter = INV_ICM45600_GYRO_LP_AVG_SEL_8X,

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

166

.filter = INV_ICM45600_ACCEL_LP_AVG_SEL_4X,

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

344

if (conf->filter == U8_MAX)

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

345

conf->filter = oldconf->filter;

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

367

conf->filter = INV_ICM45600_ACCEL_LP_AVG_SEL_1X;

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

369

conf->filter = INV_ICM45600_ACCEL_LP_AVG_SEL_4X;

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

385

if (conf->filter != oldconf->filter) {

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

387

conf->filter);

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

390

oldconf->filter = conf->filter;

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

412

conf->filter = INV_ICM45600_GYRO_LP_AVG_SEL_8X;

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

430

if (conf->filter != oldconf->filter) {

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

431

val = FIELD_PREP(INV_ICM45600_IPREG_SYS1_170_GYRO_LP_AVG_MASK, conf->filter);

drivers/iio/imu/inv_icm45600/inv_icm45600_core.c

436

oldconf->filter = conf->filter;

drivers/infiniband/core/cache.c

737

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

drivers/infiniband/core/cache.c

761

if (filter(gid, &entry->attr, context)) {

drivers/infiniband/core/cma.c

258

struct cma_device *cma_enum_devices_by_ibdev(cma_device_filter filter,

drivers/infiniband/core/cma.c

267

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

drivers/infiniband/core/cma_priv.h

132

struct cma_device *cma_enum_devices_by_ibdev(cma_device_filter filter,

drivers/infiniband/core/core_priv.h

94

roce_netdev_filter filter,

drivers/infiniband/core/core_priv.h

98

void ib_enum_all_roce_netdevs(roce_netdev_filter filter,

drivers/infiniband/core/device.c

184

xa_mark_t filter)

drivers/infiniband/core/device.c

191

entry = xas_find_marked(&xas, ULONG_MAX, filter);

drivers/infiniband/core/device.c

205

#define xan_for_each_marked(xa, index, entry, filter) \

drivers/infiniband/core/device.c

206

for (index = 0, entry = xan_find_marked(xa, &(index), filter); \

drivers/infiniband/core/device.c

208

(index)++, entry = xan_find_marked(xa, &(index), filter))

drivers/infiniband/core/device.c

2378

roce_netdev_filter filter,

drivers/infiniband/core/device.c

2390

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

drivers/infiniband/core/device.c

2407

void ib_enum_all_roce_netdevs(roce_netdev_filter filter,

drivers/infiniband/core/device.c

2417

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

drivers/infiniband/core/roce_gid_mgmt.c

62

roce_netdev_filter filter;

drivers/infiniband/core/roce_gid_mgmt.c

648

ib_enum_all_roce_netdevs(work->cmds[i].filter,

drivers/infiniband/core/roce_gid_mgmt.c

686

.filter = is_eth_port_of_netdev_filter

drivers/infiniband/core/roce_gid_mgmt.c

691

.filter = is_eth_port_of_netdev_filter

drivers/infiniband/core/roce_gid_mgmt.c

701

.filter = upper_device_filter

drivers/infiniband/core/roce_gid_mgmt.c

711

.filter = is_upper_ndev_bond_master_filter

drivers/infiniband/core/roce_gid_mgmt.c

722

.filter = is_upper_ndev_bond_master_filter

drivers/infiniband/core/roce_gid_mgmt.c

755

.filter = is_ndev_for_default_gid_filter,

drivers/infiniband/core/roce_gid_mgmt.c

762

.cb = del_netdev_ips, .filter = pass_all_filter};

drivers/infiniband/core/roce_gid_mgmt.c

766

.filter = is_eth_port_inactive_slave_filter

drivers/infiniband/core/roce_gid_mgmt.c

771

.filter = is_eth_port_of_netdev_filter

drivers/infiniband/core/roce_gid_mgmt.c

774

.cb = del_netdev_upper_ips, .filter = upper_device_filter};

drivers/infiniband/hw/cxgb4/cm.c

1976

req->le.filter = cpu_to_be32(cxgb4_select_ntuple(

drivers/infiniband/hw/cxgb4/cm.c

4000

u32 rcv_isn, u32 filter, u16 window,

drivers/infiniband/hw/cxgb4/cm.c

4015

req->le.filter = (__force __be32) filter;

drivers/infiniband/hw/cxgb4/cm.c

4063

unsigned int filter;

drivers/infiniband/hw/cxgb4/cm.c

4183

filter = (__force unsigned int) cpu_to_be32(cxgb4_select_ntuple(

drivers/infiniband/hw/cxgb4/cm.c

4194

tcph->source, ntohl(tcph->seq), filter, window,

drivers/infiniband/hw/hfi1/mmu_rb.c

167

if (!handler->ops->filter) {

drivers/infiniband/hw/hfi1/mmu_rb.c

176

if (handler->ops->filter(node, addr, len))

drivers/infiniband/hw/hfi1/mmu_rb.h

24

bool (*filter)(struct mmu_rb_node *node, unsigned long addr,

drivers/infiniband/hw/hfi1/pin_system.c

30

.filter = sdma_rb_filter,

drivers/infiniband/hw/mlx4/main.c

1337

#define FIELDS_NOT_SUPPORTED(filter, field)\

drivers/infiniband/hw/mlx4/main.c

1338

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

drivers/infiniband/hw/mlx4/main.c

1339

sizeof(filter.field), 0,\

drivers/infiniband/hw/mlx4/main.c

1340

sizeof(filter) -\

drivers/infiniband/hw/mlx4/main.c

1341

offsetof(typeof(filter), field) -\

drivers/infiniband/hw/mlx4/main.c

1342

sizeof(filter.field))

drivers/infiniband/hw/mlx5/fs.c

145

#define FIELDS_NOT_SUPPORTED(filter, field) \

drivers/infiniband/hw/mlx5/fs.c

146

memchr_inv((void *)&filter.field + sizeof(filter.field), 0, \

drivers/infiniband/hw/mlx5/fs.c

147

sizeof(filter) - offsetofend(typeof(filter), field))

drivers/infiniband/hw/usnic/usnic_fwd.c

160

struct filter *filter)

drivers/infiniband/hw/usnic/usnic_fwd.c

165

if (filter->type == FILTER_IPV4_5TUPLE) {

drivers/infiniband/hw/usnic/usnic_fwd.c

166

if (!(filter->u.ipv4.flags & FILTER_FIELD_5TUP_DST_AD))

drivers/infiniband/hw/usnic/usnic_fwd.c

168

if (!(filter->u.ipv4.flags & FILTER_FIELD_5TUP_DST_PT))

drivers/infiniband/hw/usnic/usnic_fwd.c

172

else if (filter->u.ipv4.dst_port == 0)

drivers/infiniband/hw/usnic/usnic_fwd.c

174

else if (ntohl(ufdev->inaddr) != filter->u.ipv4.dst_addr)

drivers/infiniband/hw/usnic/usnic_fwd.c

183

static void fill_tlv(struct filter_tlv *tlv, struct filter *filter,

drivers/infiniband/hw/usnic/usnic_fwd.c

187

tlv->length = sizeof(struct filter);

drivers/infiniband/hw/usnic/usnic_fwd.c

188

*((struct filter *)&tlv->val) = *filter;

drivers/infiniband/hw/usnic/usnic_fwd.c

191

sizeof(struct filter));

drivers/infiniband/hw/usnic/usnic_fwd.c

198

usnic_fwd_alloc_flow(struct usnic_fwd_dev *ufdev, struct filter *filter,

drivers/infiniband/hw/usnic/usnic_fwd.c

210

tlv_size = (2*sizeof(struct filter_tlv) + sizeof(struct filter) +

drivers/infiniband/hw/usnic/usnic_fwd.c

224

fill_tlv(tlv, filter, &uaction->action);

drivers/infiniband/hw/usnic/usnic_fwd.c

234

status = validate_filter_locked(ufdev, filter);

drivers/infiniband/hw/usnic/usnic_fwd.h

100

filter->type = FILTER_USNIC_ID;

drivers/infiniband/hw/usnic/usnic_fwd.h

101

filter->u.usnic.ethtype = ETH_P_IBOE;

drivers/infiniband/hw/usnic/usnic_fwd.h

102

filter->u.usnic.flags = FILTER_FIELD_USNIC_ETHTYPE |

drivers/infiniband/hw/usnic/usnic_fwd.h

105

filter->u.usnic.proto_version = (USNIC_ROCE_GRH_VER <<

drivers/infiniband/hw/usnic/usnic_fwd.h

108

filter->u.usnic.usnic_id = usnic_id;

drivers/infiniband/hw/usnic/usnic_fwd.h

111

static inline void usnic_fwd_init_udp_filter(struct filter *filter,

drivers/infiniband/hw/usnic/usnic_fwd.h

114

filter->type = FILTER_IPV4_5TUPLE;

drivers/infiniband/hw/usnic/usnic_fwd.h

115

filter->u.ipv4.flags = FILTER_FIELD_5TUP_PROTO;

drivers/infiniband/hw/usnic/usnic_fwd.h

116

filter->u.ipv4.protocol = PROTO_UDP;

drivers/infiniband/hw/usnic/usnic_fwd.h

119

filter->u.ipv4.flags |= FILTER_FIELD_5TUP_DST_AD;

drivers/infiniband/hw/usnic/usnic_fwd.h

120

filter->u.ipv4.dst_addr = daddr;

drivers/infiniband/hw/usnic/usnic_fwd.h

124

filter->u.ipv4.flags |= FILTER_FIELD_5TUP_DST_PT;

drivers/infiniband/hw/usnic/usnic_fwd.h

125

filter->u.ipv4.dst_port = dport;

drivers/infiniband/hw/usnic/usnic_fwd.h

91

usnic_fwd_alloc_flow(struct usnic_fwd_dev *ufdev, struct filter *filter,

drivers/infiniband/hw/usnic/usnic_fwd.h

97

static inline void usnic_fwd_init_usnic_filter(struct filter *filter,

drivers/infiniband/hw/usnic/usnic_ib_qp_grp.c

208

struct filter filter;

drivers/infiniband/hw/usnic/usnic_ib_qp_grp.c

223

usnic_fwd_init_usnic_filter(&filter, port_num);

drivers/infiniband/hw/usnic/usnic_ib_qp_grp.c

228

flow = usnic_fwd_alloc_flow(qp_grp->ufdev, &filter, &uaction);

drivers/infiniband/hw/usnic/usnic_ib_qp_grp.c

268

struct filter filter;

drivers/infiniband/hw/usnic/usnic_ib_qp_grp.c

296

usnic_fwd_init_udp_filter(&filter, addr, port_num);

drivers/infiniband/hw/usnic/usnic_ib_qp_grp.c

301

flow = usnic_fwd_alloc_flow(qp_grp->ufdev, &filter, &uaction);

drivers/input/input.c

1186

if (handler->filter)

drivers/input/input.c

2428

if (handler->filter)

drivers/input/input.c

2560

if (handler->filter(handle, v->type, v->code, v->value))

drivers/input/input.c

2588

if (handler->filter)

drivers/input/input.c

2624

if (handler->filter)

drivers/input/keyboard/tegra-kbc.c

303

static void tegra_kbc_setup_wakekeys(struct tegra_kbc *kbc, bool filter)

drivers/input/keyboard/tegra-kbc.c

309

rst_val = (filter && !kbc->wakeup) ? ~0 : 0;

drivers/input/misc/iqs269a.c

287

u8 filter;

drivers/input/misc/iqs269a.c

824

sys_reg->filter &= ~IQS269_FILT_STR_LP_LTA_MASK;

drivers/input/misc/iqs269a.c

825

sys_reg->filter |= (val << IQS269_FILT_STR_LP_LTA_SHIFT);

drivers/input/misc/iqs269a.c

836

sys_reg->filter &= ~IQS269_FILT_STR_LP_CNT_MASK;

drivers/input/misc/iqs269a.c

837

sys_reg->filter |= (val << IQS269_FILT_STR_LP_CNT_SHIFT);

drivers/input/misc/iqs269a.c

848

sys_reg->filter &= ~IQS269_FILT_STR_NP_LTA_MASK;

drivers/input/misc/iqs269a.c

849

sys_reg->filter |= (val << IQS269_FILT_STR_NP_LTA_SHIFT);

drivers/input/misc/iqs269a.c

860

sys_reg->filter &= ~IQS269_FILT_STR_NP_CNT_MASK;

drivers/input/misc/iqs269a.c

861

sys_reg->filter |= val;

drivers/input/misc/iqs626a.c

1061

filter = &sys_reg->ch_reg_ulp.filter;

drivers/input/misc/iqs626a.c

1067

filter = &sys_reg->ch_reg_gen[i].filter;

drivers/input/misc/iqs626a.c

1082

*filter &= ~IQS626_FILT_STR_NP_CNT_MASK;

drivers/input/misc/iqs626a.c

1083

*filter |= (val << IQS626_FILT_STR_NP_CNT_SHIFT);

drivers/input/misc/iqs626a.c

1095

*filter &= ~IQS626_FILT_STR_LP_CNT_MASK;

drivers/input/misc/iqs626a.c

1096

*filter |= (val << IQS626_FILT_STR_LP_CNT_SHIFT);

drivers/input/misc/iqs626a.c

1108

*filter &= ~IQS626_FILT_STR_NP_LTA_MASK;

drivers/input/misc/iqs626a.c

1109

*filter |= (val << IQS626_FILT_STR_NP_LTA_SHIFT);

drivers/input/misc/iqs626a.c

1121

*filter &= ~IQS626_FILT_STR_LP_LTA_MASK;

drivers/input/misc/iqs626a.c

1122

*filter |= val;

drivers/input/misc/iqs626a.c

290

u8 filter;

drivers/input/misc/iqs626a.c

319

u8 filter;

drivers/input/misc/iqs626a.c

877

u8 *engine, *filter, *rx_enable, *tx_enable;

drivers/input/serio/i8042.c

198

int i8042_install_filter(i8042_filter_t filter, void *context)

drivers/input/serio/i8042.c

205

i8042_platform_filter = filter;

drivers/input/serio/i8042.c

211

int i8042_remove_filter(i8042_filter_t filter)

drivers/input/serio/i8042.c

215

if (i8042_platform_filter != filter)

drivers/input/serio/i8042.h

70

#define filter_dbg(filter, data, format, args...) \

drivers/input/serio/i8042.h

75

if (!filter || i8042_unmask_kbd_data) \

drivers/input/serio/i8042.h

88

#define filter_dbg(filter, data, format, args...) do { } while (0)

drivers/input/touchscreen/ads7846.c

1286

ts->filter = ads7846_debounce_filter;

drivers/input/touchscreen/ads7846.c

1289

ts->filter = ads7846_no_filter;

drivers/input/touchscreen/ads7846.c

137

int (*filter)(void *data, int data_idx, int *val);

drivers/input/touchscreen/ads7846.c

783

action = ts->filter(ts->filter_data, cmd_idx, &val);

drivers/iommu/intel/iommu.h

669

u32 filter; /* Bitmask of filter support */

drivers/iommu/intel/perfmon.c

101

if ((iommu_pmu->filter & _filter) && iommu_pmu_en_##_name(_econfig)) { \

drivers/iommu/intel/perfmon.c

111

if (iommu_pmu->filter & _filter) { \

drivers/iommu/intel/perfmon.c

606

iommu_pmu->filter = pcap_filters_mask(perfcap);

drivers/iommu/intel/perfmon.c

68

return (iommu_pmu->filter & _filter) ? attr->mode : 0; \

drivers/iommu/intel/perfmon.c

93

#define iommu_pmu_get_requester_id(filter) (((filter) >> 16) & 0xffff)

drivers/iommu/intel/perfmon.c

94

#define iommu_pmu_get_domain(filter) (((filter) >> 32) & 0xffff)

drivers/iommu/intel/perfmon.c

95

#define iommu_pmu_get_pasid(filter) ((filter) & 0x3fffff)

drivers/iommu/intel/perfmon.c

96

#define iommu_pmu_get_ats(filter) (((filter) >> 24) & 0x1f)

drivers/iommu/intel/perfmon.c

97

#define iommu_pmu_get_page_table(filter) (((filter) >> 32) & 0x1f)

drivers/macintosh/mac_hid.c

156

.filter = mac_hid_emumouse_filter,

drivers/md/bcache/bset.h

364

#define for_each_key_filter(b, k, stack_iter, filter) \

drivers/md/bcache/bset.h

367

filter));)

drivers/md/dm-vdo/vdo.c

101

static struct vdo * __must_check filter_vdos_locked(vdo_filter_fn filter,

drivers/md/dm-vdo/vdo.c

107

if (filter(vdo, context))

drivers/md/dm-vdo/vdo.c

119

struct vdo *vdo_find_matching(vdo_filter_fn filter, const void *context)

drivers/md/dm-vdo/vdo.c

124

vdo = filter_vdos_locked(filter, context);

drivers/md/dm-vdo/vdo.h

290

struct vdo * __must_check vdo_find_matching(vdo_filter_fn filter, const void *context);

drivers/media/dvb-core/dmxdev.c

1413

dmxdev->filter = vmalloc_array(dmxdev->filternum,

drivers/media/dvb-core/dmxdev.c

1415

if (!dmxdev->filter)

drivers/media/dvb-core/dmxdev.c

1421

dmxdev->filter[i].dev = dmxdev;

drivers/media/dvb-core/dmxdev.c

1422

dmxdev->filter[i].buffer.data = NULL;

drivers/media/dvb-core/dmxdev.c

1423

dvb_dmxdev_filter_state_set(&dmxdev->filter[i],

drivers/media/dvb-core/dmxdev.c

1444

vfree(dmxdev->filter);

drivers/media/dvb-core/dmxdev.c

1445

dmxdev->filter = NULL;

drivers/media/dvb-core/dmxdev.c

1469

vfree(dmxdev->filter);

drivers/media/dvb-core/dmxdev.c

1470

dmxdev->filter = NULL;

drivers/media/dvb-core/dmxdev.c

382

struct dmx_section_filter *filter,

drivers/media/dvb-core/dmxdev.c

385

struct dmxdev_filter *dmxdevfilter = filter->priv;

drivers/media/dvb-core/dmxdev.c

503

static int dvb_dmxdev_feed_start(struct dmxdev_filter *filter)

drivers/media/dvb-core/dmxdev.c

508

dvb_dmxdev_filter_state_set(filter, DMXDEV_STATE_GO);

drivers/media/dvb-core/dmxdev.c

510

switch (filter->type) {

drivers/media/dvb-core/dmxdev.c

512

return filter->feed.sec->start_filtering(filter->feed.sec);

drivers/media/dvb-core/dmxdev.c

514

list_for_each_entry(feed, &filter->feed.ts, next) {

drivers/media/dvb-core/dmxdev.c

517

dvb_dmxdev_feed_stop(filter);

drivers/media/dvb-core/dmxdev.c

531

static int dvb_dmxdev_feed_restart(struct dmxdev_filter *filter)

drivers/media/dvb-core/dmxdev.c

534

struct dmxdev *dmxdev = filter->dev;

drivers/media/dvb-core/dmxdev.c

535

u16 pid = filter->params.sec.pid;

drivers/media/dvb-core/dmxdev.c

538

if (dmxdev->filter[i].state >= DMXDEV_STATE_GO &&

drivers/media/dvb-core/dmxdev.c

539

dmxdev->filter[i].type == DMXDEV_TYPE_SEC &&

drivers/media/dvb-core/dmxdev.c

540

dmxdev->filter[i].params.sec.pid == pid) {

drivers/media/dvb-core/dmxdev.c

541

dvb_dmxdev_feed_start(&dmxdev->filter[i]);

drivers/media/dvb-core/dmxdev.c

545

filter->dev->demux->release_section_feed(dmxdev->demux,

drivers/media/dvb-core/dmxdev.c

546

filter->feed.sec);

drivers/media/dvb-core/dmxdev.c

564

if (dmxdevfilter->filter.sec)

drivers/media/dvb-core/dmxdev.c

567

dmxdevfilter->filter.sec);

drivers/media/dvb-core/dmxdev.c

616

struct dmxdev_filter *filter,

drivers/media/dvb-core/dmxdev.c

620

struct dmx_pes_filter_params *para = &filter->params.pes;

drivers/media/dvb-core/dmxdev.c

650

tsfeed->priv = filter;

drivers/media/dvb-core/dmxdev.c

667

static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)

drivers/media/dvb-core/dmxdev.c

669

struct dmxdev *dmxdev = filter->dev;

drivers/media/dvb-core/dmxdev.c

674

if (filter->state < DMXDEV_STATE_SET)

drivers/media/dvb-core/dmxdev.c

677

if (filter->state >= DMXDEV_STATE_GO)

drivers/media/dvb-core/dmxdev.c

678

dvb_dmxdev_filter_stop(filter);

drivers/media/dvb-core/dmxdev.c

680

if (!filter->buffer.data) {

drivers/media/dvb-core/dmxdev.c

681

mem = vmalloc(filter->buffer.size);

drivers/media/dvb-core/dmxdev.c

684

spin_lock_irq(&filter->dev->lock);

drivers/media/dvb-core/dmxdev.c

685

filter->buffer.data = mem;

drivers/media/dvb-core/dmxdev.c

686

spin_unlock_irq(&filter->dev->lock);

drivers/media/dvb-core/dmxdev.c

689

dvb_ringbuffer_flush(&filter->buffer);

drivers/media/dvb-core/dmxdev.c

691

switch (filter->type) {

drivers/media/dvb-core/dmxdev.c

694

struct dmx_sct_filter_params *para = &filter->params.sec;

drivers/media/dvb-core/dmxdev.c

695

struct dmx_section_filter **secfilter = &filter->filter.sec;

drivers/media/dvb-core/dmxdev.c

696

struct dmx_section_feed **secfeed = &filter->feed.sec;

drivers/media/dvb-core/dmxdev.c

704

if (dmxdev->filter[i].state >= DMXDEV_STATE_GO &&

drivers/media/dvb-core/dmxdev.c

705

dmxdev->filter[i].type == DMXDEV_TYPE_SEC &&

drivers/media/dvb-core/dmxdev.c

706

dmxdev->filter[i].params.sec.pid == para->pid) {

drivers/media/dvb-core/dmxdev.c

707

*secfeed = dmxdev->filter[i].feed.sec;

drivers/media/dvb-core/dmxdev.c

728

dvb_dmxdev_feed_restart(filter);

drivers/media/dvb-core/dmxdev.c

732

dvb_dmxdev_feed_stop(filter);

drivers/media/dvb-core/dmxdev.c

737

dvb_dmxdev_feed_restart(filter);

drivers/media/dvb-core/dmxdev.c

743

(*secfilter)->priv = filter;

drivers/media/dvb-core/dmxdev.c

746

&(para->filter.filter[1]), DMX_FILTER_SIZE - 1);

drivers/media/dvb-core/dmxdev.c

748

&para->filter.mask[1], DMX_FILTER_SIZE - 1);

drivers/media/dvb-core/dmxdev.c

750

&para->filter.mode[1], DMX_FILTER_SIZE - 1);

drivers/media/dvb-core/dmxdev.c

752

(*secfilter)->filter_value[0] = para->filter.filter[0];

drivers/media/dvb-core/dmxdev.c

753

(*secfilter)->filter_mask[0] = para->filter.mask[0];

drivers/media/dvb-core/dmxdev.c

754

(*secfilter)->filter_mode[0] = para->filter.mode[0];

drivers/media/dvb-core/dmxdev.c

758

filter->todo = 0;

drivers/media/dvb-core/dmxdev.c

760

ret = filter->feed.sec->start_filtering(filter->feed.sec);

drivers/media/dvb-core/dmxdev.c

764

dvb_dmxdev_filter_timer(filter);

drivers/media/dvb-core/dmxdev.c

768

list_for_each_entry(feed, &filter->feed.ts, next) {

drivers/media/dvb-core/dmxdev.c

769

ret = dvb_dmxdev_start_feed(dmxdev, filter, feed);

drivers/media/dvb-core/dmxdev.c

771

dvb_dmxdev_filter_stop(filter);

drivers/media/dvb-core/dmxdev.c

780

dvb_dmxdev_filter_state_set(filter, DMXDEV_STATE_GO);

drivers/media/dvb-core/dmxdev.c

791

if (!dmxdev->filter)

drivers/media/dvb-core/dmxdev.c

803

if (dmxdev->filter[i].state == DMXDEV_STATE_FREE)

drivers/media/dvb-core/dmxdev.c

811

dmxdevfilter = &dmxdev->filter[i];

drivers/media/dvb-core/dmxdev.c

875

static inline void invert_mode(struct dmx_filter *filter)

drivers/media/dvb-core/dmxdev.c

880

filter->mode[i] ^= 0xff;

drivers/media/dvb-core/dmxdev.c

884

struct dmxdev_filter *filter, u16 pid)

drivers/media/dvb-core/dmxdev.c

888

if ((filter->type != DMXDEV_TYPE_PES) ||

drivers/media/dvb-core/dmxdev.c

889

(filter->state < DMXDEV_STATE_SET))

drivers/media/dvb-core/dmxdev.c

893

if ((filter->params.pes.output != DMX_OUT_TSDEMUX_TAP) &&

drivers/media/dvb-core/dmxdev.c

894

(!list_empty(&filter->feed.ts)))

drivers/media/dvb-core/dmxdev.c

902

list_add(&feed->next, &filter->feed.ts);

drivers/media/dvb-core/dmxdev.c

904

if (filter->state >= DMXDEV_STATE_GO)

drivers/media/dvb-core/dmxdev.c

905

return dvb_dmxdev_start_feed(dmxdev, filter, feed);

drivers/media/dvb-core/dmxdev.c

911

struct dmxdev_filter *filter, u16 pid)

drivers/media/dvb-core/dmxdev.c

915

if ((filter->type != DMXDEV_TYPE_PES) ||

drivers/media/dvb-core/dmxdev.c

916

(filter->state < DMXDEV_STATE_SET))

drivers/media/dvb-core/dmxdev.c

919

list_for_each_entry_safe(feed, tmp, &filter->feed.ts, next) {

drivers/media/dvb-core/dmxdev.c

922

filter->dev->demux->release_ts_feed(filter->dev->demux,

drivers/media/dvb-core/dmxdev.c

944

invert_mode(&dmxdevfilter->params.sec.filter);

drivers/media/dvb-core/dvb_demux.c

1017

struct dmx_section_filter *filter)

drivers/media/dvb-core/dvb_demux.c

1019

struct dvb_demux_filter *dvbdmxfilter = (struct dvb_demux_filter *)filter, *f;

drivers/media/dvb-core/dvb_demux.c

1039

f = dvbdmxfeed->filter;

drivers/media/dvb-core/dvb_demux.c

1042

dvbdmxfeed->filter = dvbdmxfilter->next;

drivers/media/dvb-core/dvb_demux.c

1079

dvbdmxfeed->filter = NULL;

drivers/media/dvb-core/dvb_demux.c

1247

dvbdemux->filter = vmalloc_array(dvbdemux->filternum,

drivers/media/dvb-core/dvb_demux.c

1250

if (!dvbdemux->filter)

drivers/media/dvb-core/dvb_demux.c

1256

vfree(dvbdemux->filter);

drivers/media/dvb-core/dvb_demux.c

1257

dvbdemux->filter = NULL;

drivers/media/dvb-core/dvb_demux.c

1261

dvbdemux->filter[i].state = DMX_STATE_FREE;

drivers/media/dvb-core/dvb_demux.c

1262

dvbdemux->filter[i].index = i;

drivers/media/dvb-core/dvb_demux.c

1320

vfree(dvbdemux->filter);

drivers/media/dvb-core/dvb_demux.c

141

u8 xor = f->filter.filter_value[i] ^ feed->feed.sec.secbuf[i];

drivers/media/dvb-core/dvb_demux.c

153

NULL, 0, &f->filter, &feed->buffer_flags);

drivers/media/dvb-core/dvb_demux.c

159

struct dvb_demux_filter *f = feed->filter;

drivers/media/dvb-core/dvb_demux.c

621

if (demux->filter[i].state == DMX_STATE_FREE)

drivers/media/dvb-core/dvb_demux.c

627

demux->filter[i].state = DMX_STATE_ALLOCATED;

drivers/media/dvb-core/dvb_demux.c

629

return &demux->filter[i];

drivers/media/dvb-core/dvb_demux.c

822

feed->filter = dvb_dmx_filter_alloc(demux);

drivers/media/dvb-core/dvb_demux.c

823

if (!feed->filter) {

drivers/media/dvb-core/dvb_demux.c

829

feed->filter->type = DMX_TYPE_TS;

drivers/media/dvb-core/dvb_demux.c

830

feed->filter->feed = feed;

drivers/media/dvb-core/dvb_demux.c

831

feed->filter->state = DMX_STATE_READY;

drivers/media/dvb-core/dvb_demux.c

852

feed->filter->state = DMX_STATE_FREE;

drivers/media/dvb-core/dvb_demux.c

870

struct dmx_section_filter **filter)

drivers/media/dvb-core/dvb_demux.c

886

*filter = &dvbdmxfilter->filter;

drivers/media/dvb-core/dvb_demux.c

887

(*filter)->parent = feed;

drivers/media/dvb-core/dvb_demux.c

888

(*filter)->priv = NULL;

drivers/media/dvb-core/dvb_demux.c

892

dvbdmxfilter->next = dvbdmxfeed->filter;

drivers/media/dvb-core/dvb_demux.c

893

dvbdmxfeed->filter = dvbdmxfilter;

drivers/media/dvb-core/dvb_demux.c

929

f = dvbdmxfeed->filter;

drivers/media/dvb-core/dvb_demux.c

933

sf = &f->filter;

drivers/media/dvb-core/dvb_demux.c

959

if (!dvbdmxfeed->filter) {

drivers/media/dvb-core/dvb_net.c

989

struct dmx_section_filter *filter, u32 *buffer_flags)

drivers/media/dvb-core/dvb_net.c

991

struct net_device *dev = filter->priv;

drivers/media/dvb-frontends/tda8083.c

126

u8 filter;

drivers/media/dvb-frontends/tda8083.c

133

filter = 0;

drivers/media/dvb-frontends/tda8083.c

135

filter = 2;

drivers/media/dvb-frontends/tda8083.c

137

filter = 3;

drivers/media/dvb-frontends/tda8083.c

150

tda8083_writereg (state, 0x05, filter);

drivers/media/i2c/cx25840/cx25840-core.c

1756

int filter;

drivers/media/i2c/cx25840/cx25840-core.c

1825

filter = 0;

drivers/media/i2c/cx25840/cx25840-core.c

1827

filter = 1;

drivers/media/i2c/cx25840/cx25840-core.c

1829

filter = 2;

drivers/media/i2c/cx25840/cx25840-core.c

1831

filter = 3;

drivers/media/i2c/cx25840/cx25840-core.c

1842

cx25840_write4(client, 0x438, vsc | (1 << 19) | (filter << 16));

drivers/media/i2c/cx25840/cx25840-core.c

1851

cx25840_write(client, 0x41e, 0x8 | filter);

drivers/media/pci/cx18/cx18-av-core.c

1005

cx18_av_write(cx, 0x41e, 0x8 | filter);

drivers/media/pci/cx18/cx18-av-core.c

939

int HSC, VSC, Vsrc, Hsrc, filter, Vlines;

drivers/media/pci/cx18/cx18-av-core.c

985

filter = 0;

drivers/media/pci/cx18/cx18-av-core.c

987

filter = 1;

drivers/media/pci/cx18/cx18-av-core.c

989

filter = 2;

drivers/media/pci/cx18/cx18-av-core.c

991

filter = 3;

drivers/media/pci/saa7134/saa7134-dvb.c

278

u8 band, cp, filter;

drivers/media/pci/saa7134/saa7134-dvb.c

320

filter = 0;

drivers/media/pci/saa7134/saa7134-dvb.c

324

filter = 0;

drivers/media/pci/saa7134/saa7134-dvb.c

328

filter = 1;

drivers/media/pci/saa7134/saa7134-dvb.c

344

tuner_buf[3] = (cp << 5) | (filter << 3) | band;

drivers/media/pci/ttpci/budget-av.c

697

u8 band, cp, filter;

drivers/media/pci/ttpci/budget-av.c

739

filter = 0;

drivers/media/pci/ttpci/budget-av.c

743

filter = 0;

drivers/media/pci/ttpci/budget-av.c

747

filter = 1;

drivers/media/pci/ttpci/budget-av.c

762

tuner_buf[3] = (cp << 5) | (filter << 3) | band;

drivers/media/pci/ttpci/budget-ci.c

735

u8 band, cp, filter;

drivers/media/pci/ttpci/budget-ci.c

778

filter = 0;

drivers/media/pci/ttpci/budget-ci.c

783

filter = 0;

drivers/media/pci/ttpci/budget-ci.c

788

filter = 1;

drivers/media/pci/ttpci/budget-ci.c

803

tuner_buf[3] = (cp << 5) | (filter << 3) | band;

drivers/media/pci/ttpci/budget-ci.c

854

u8 band, cp, filter;

drivers/media/pci/ttpci/budget-ci.c

892

filter = 1;

drivers/media/pci/ttpci/budget-ci.c

901

tuner_buf[3] = (cp << 5) | (filter << 3) | band;

drivers/media/platform/mediatek/mdp3/mdp_sm_mt8183.h

92

u32 filter;

drivers/media/platform/mediatek/mdp3/mdp_sm_mt8195.h

215

u32 filter;

drivers/media/platform/mediatek/mdp3/mtk-mdp3-comp.c

755

reg = CFG_COMP(MT8183, ctx->param, wrot.filter);

drivers/media/platform/mediatek/mdp3/mtk-mdp3-comp.c

757

reg = CFG_COMP(MT8195, ctx->param, wrot.filter);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

1256

for (i = 0; i < ARRAY_SIZE(counts_map->filter); i++)

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

1257

memcpy(counts_map->filter[i], counts->switchable_interp[i],

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

1258

sizeof(counts_map->filter[0]));

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

1259

counts_helper->filter = &counts_map->filter;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

156

u32 filter[4][3];

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

115

u32 filter[4][3];

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

924

vp9_ctx->inter_cnts.filter = &inter_cnts->filter;

drivers/media/platform/verisilicon/hantro_vp9.c

140

vp9_ctx->cnts.filter = &cnts->switchable_interp_counts;

drivers/media/rc/img-ir/img-ir-hw.c

261

static u32 img_ir_free_timing_dynamic(u32 st_ft, struct img_ir_filter *filter)

drivers/media/rc/img-ir/img-ir-hw.c

266

newminlen = filter->minlen & -2;

drivers/media/rc/img-ir/img-ir-hw.c

267

newmaxlen = (filter->maxlen + 1) & -2;

drivers/media/rc/img-ir/img-ir-hw.c

394

struct img_ir_filter *filter)

drivers/media/rc/img-ir/img-ir-hw.c

396

if (filter) {

drivers/media/rc/img-ir/img-ir-hw.c

398

(unsigned long long)filter->data,

drivers/media/rc/img-ir/img-ir-hw.c

399

(unsigned long long)filter->mask);

drivers/media/rc/img-ir/img-ir-hw.c

400

img_ir_write(priv, IMG_IR_IRQ_MSG_DATA_LW, (u32)filter->data);

drivers/media/rc/img-ir/img-ir-hw.c

401

img_ir_write(priv, IMG_IR_IRQ_MSG_DATA_UP, (u32)(filter->data

drivers/media/rc/img-ir/img-ir-hw.c

403

img_ir_write(priv, IMG_IR_IRQ_MSG_MASK_LW, (u32)filter->mask);

drivers/media/rc/img-ir/img-ir-hw.c

404

img_ir_write(priv, IMG_IR_IRQ_MSG_MASK_UP, (u32)(filter->mask

drivers/media/rc/img-ir/img-ir-hw.c

415

struct img_ir_filter *filter)

drivers/media/rc/img-ir/img-ir-hw.c

421

if (filter) {

drivers/media/rc/img-ir/img-ir-hw.c

423

hw->filters[RC_FILTER_NORMAL] = *filter;

drivers/media/rc/img-ir/img-ir-hw.c

435

img_ir_write_filter(priv, filter);

drivers/media/rc/img-ir/img-ir-hw.c

443

struct img_ir_filter *filter)

drivers/media/rc/img-ir/img-ir-hw.c

446

if (filter) {

drivers/media/rc/img-ir/img-ir-hw.c

448

hw->filters[RC_FILTER_WAKEUP] = *filter;

drivers/media/rc/img-ir/img-ir-hw.c

462

struct img_ir_filter filter, *filter_ptr = &filter;

drivers/media/rc/img-ir/img-ir-hw.c

479

if (!hw->decoder || !hw->decoder->filter) {

drivers/media/rc/img-ir/img-ir-hw.c

485

filter.minlen = 0;

drivers/media/rc/img-ir/img-ir-hw.c

486

filter.maxlen = ~0;

drivers/media/rc/img-ir/img-ir-hw.c

489

ret = hw->decoder->filter(sc_filter, &filter,

drivers/media/rc/img-ir/img-ir-hw.c

493

ret = hw->decoder->filter(sc_filter, &filter,

drivers/media/rc/img-ir/img-ir-hw.c

500

(unsigned long long)filter.data,

drivers/media/rc/img-ir/img-ir-hw.c

501

(unsigned long long)filter.mask);

drivers/media/rc/img-ir/img-ir-hw.c

690

if (!hw->decoder || !hw->decoder->filter)

drivers/media/rc/img-ir/img-ir-hw.h

177

int (*filter)(const struct rc_scancode_filter *in,

drivers/media/rc/img-ir/img-ir-jvc.c

83

.filter = img_ir_jvc_filter,

drivers/media/rc/img-ir/img-ir-nec.c

172

.filter = img_ir_nec_filter,

drivers/media/rc/img-ir/img-ir-rc5.c

83

.filter = img_ir_rc5_filter,

drivers/media/rc/img-ir/img-ir-rc6.c

112

.filter = img_ir_rc6_filter,

drivers/media/rc/img-ir/img-ir-sanyo.c

124

.filter = img_ir_sanyo_filter,

drivers/media/rc/img-ir/img-ir-sharp.c

101

.filter = img_ir_sharp_filter,

drivers/media/rc/img-ir/img-ir-sony.c

160

.filter = img_ir_sony_filter,

drivers/media/rc/rc-main.c

1282

struct rc_scancode_filter *filter;

drivers/media/rc/rc-main.c

1288

filter = &dev->scancode_filter;

drivers/media/rc/rc-main.c

1330

if (dev->s_filter && filter->mask) {

drivers/media/rc/rc-main.c

1332

rc = dev->s_filter(dev, filter);

drivers/media/rc/rc-main.c

1337

filter->data = 0;

drivers/media/rc/rc-main.c

1338

filter->mask = 0;

drivers/media/rc/rc-main.c

1339

dev->s_filter(dev, filter);

drivers/media/rc/rc-main.c

1373

struct rc_scancode_filter *filter;

drivers/media/rc/rc-main.c

1379

filter = &dev->scancode_filter;

drivers/media/rc/rc-main.c

1381

filter = &dev->scancode_wakeup_filter;

drivers/media/rc/rc-main.c

1384

val = filter->mask;

drivers/media/rc/rc-main.c

1386

val = filter->data;

drivers/media/rc/rc-main.c

1417

struct rc_scancode_filter new_filter, *filter;

drivers/media/rc/rc-main.c

1420

int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter);

drivers/media/rc/rc-main.c

1428

filter = &dev->scancode_filter;

drivers/media/rc/rc-main.c

1431

filter = &dev->scancode_wakeup_filter;

drivers/media/rc/rc-main.c

1443

new_filter = *filter;

drivers/media/rc/rc-main.c

1474

*filter = new_filter;

drivers/media/rc/rc-main.c

1647

static RC_FILTER_ATTR(filter, S_IRUGO|S_IWUSR,

drivers/media/rc/rc-main.c

945

struct rc_scancode_filter *filter)

drivers/media/rc/rc-main.c

947

u32 mask, s = filter->data;

drivers/media/rc/rc-main.c

958

filter->data &= mask;

drivers/media/rc/rc-main.c

959

filter->mask &= mask;

drivers/media/rc/rc-main.c

964

if (dev->encode_wakeup && filter->mask != 0 && filter->mask != mask)

drivers/media/rc/winbond-cir.c

869

wbcir_set_wakeup_filter(struct rc_dev *rc, struct rc_scancode_filter *filter)

drivers/media/usb/as102/as102_drv.c

115

struct as10x_ts_filter filter;

drivers/media/usb/as102/as102_drv.c

117

filter.type = TS_PID_TYPE_TS;

drivers/media/usb/as102/as102_drv.c

118

filter.idx = 0xFF;

drivers/media/usb/as102/as102_drv.c

119

filter.pid = pid;

drivers/media/usb/as102/as102_drv.c

121

ret = as10x_cmd_add_PID_filter(bus_adap, &filter);

drivers/media/usb/as102/as102_drv.c

124

index, filter.idx, filter.pid, ret);

drivers/media/usb/as102/as10x_cmd.h

497

struct as10x_ts_filter *filter);

drivers/media/usb/as102/as10x_cmd_stream.c

19

struct as10x_ts_filter *filter)

drivers/media/usb/as102/as10x_cmd_stream.c

34

pcmd->body.add_pid_filter.req.pid = cpu_to_le16(filter->pid);

drivers/media/usb/as102/as10x_cmd_stream.c

35

pcmd->body.add_pid_filter.req.stream_type = filter->type;

drivers/media/usb/as102/as10x_cmd_stream.c

37

if (filter->idx < 16)

drivers/media/usb/as102/as10x_cmd_stream.c

38

pcmd->body.add_pid_filter.req.idx = filter->idx;

drivers/media/usb/as102/as10x_cmd_stream.c

61

filter->idx = prsp->body.add_pid_filter.rsp.filter_id;

drivers/media/usb/dvb-usb/m920x.c

350

int i, ret = 0, filter = 0;

drivers/media/usb/dvb-usb/m920x.c

371

if ((ret = m920x_set_filter(adap->dev, ep, filter + 2, m->filters[adap->id][i])) != 0)

drivers/media/usb/dvb-usb/m920x.c

374

filter++;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1032

u8 band, cp, filter;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1063

filter = 0;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1068

filter = 0;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1073

filter = 1;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1088

tuner_buf[3] = (cp << 5) | (filter << 3) | band;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1359

u8 band, cp, filter;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1376

filter = 1;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1386

tuner_buf[3] = (cp << 5) | (filter << 3) | band;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

357

int associated_chan, u8 filter[8], u8 mask[8])

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

362

filter[0], filter[1], filter[2], filter[3],

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

363

filter[4], filter[5], filter[6], filter[7],

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

364

filter[8], filter[9], filter[10], filter[11],

drivers/media/usb/ttusb-dec/ttusb_dec.c

1056

memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1);

drivers/media/usb/ttusb-dec/ttusb_dec.c

1067

finfo->filter = dvbdmxfeed->filter;

drivers/media/usb/ttusb-dec/ttusb_dec.c

165

struct dvb_demux_filter *filter;

drivers/media/usb/ttusb-dec/ttusb_dec.c

563

struct dvb_demux_filter *filter = NULL;

drivers/media/usb/ttusb-dec/ttusb_dec.c

573

filter = finfo->filter;

drivers/media/usb/ttusb-dec/ttusb_dec.c

579

if (filter)

drivers/media/usb/ttusb-dec/ttusb_dec.c

580

filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,

drivers/media/usb/ttusb-dec/ttusb_dec.c

581

&filter->filter, NULL);

drivers/media/usb/ttusb-dec/ttusb_dec.c

992

dec->video_filter = dvbdmxfeed->filter;

drivers/media/usb/ttusb-dec/ttusb_dec.c

999

dec->audio_filter = dvbdmxfeed->filter;

drivers/media/v4l2-core/v4l2-ctrls-core.c

2419

bool (*filter)(const struct v4l2_ctrl *ctrl),

drivers/media/v4l2-core/v4l2-ctrls-core.c

2441

if (filter && !filter(ctrl))

drivers/media/v4l2-core/v4l2-vp9.c

1798

adapt_probs_variant_f(probs->interp_filter[i], (*counts->filter)[i]);

drivers/mmc/host/mxcmmc.c

1124

host->dma = dma_request_channel(mask, filter, host);

drivers/mmc/host/renesas_sdhi.h

69

dma_filter_fn filter;

drivers/mmc/host/renesas_sdhi_core.c

1175

dma_priv->filter = shdma_chan_filter;

drivers/mmc/host/renesas_sdhi_sys_dmac.c

363

priv->dma_priv.filter, pdata->chan_priv_tx,

drivers/mmc/host/renesas_sdhi_sys_dmac.c

383

priv->dma_priv.filter, pdata->chan_priv_rx,

drivers/mtd/nand/raw/fsmc_nand.c

1112

host->read_dma_chan = dma_request_channel(mask, filter, NULL);

drivers/mtd/nand/raw/fsmc_nand.c

1118

host->write_dma_chan = dma_request_channel(mask, filter, NULL);

drivers/net/amt.c

131

enum amt_filter filter)

drivers/net/amt.c

135

switch (filter) {

drivers/net/amt.c

1477

enum amt_filter filter,

drivers/net/amt.c

1516

snode = amt_lookup_src(tunnel, gnode, filter, &src);

drivers/net/amt.c

1527

if (amt_status_filter(snode, filter))

drivers/net/amt.c

1539

snode = amt_lookup_src(tunnel, gnode, filter, &src);

drivers/net/amt.c

1550

if (!amt_status_filter(snode, filter))

drivers/net/amt.c

1585

filter, &src);

drivers/net/amt.c

186

enum amt_filter filter,

drivers/net/amt.c

193

if (amt_status_filter(snode, filter) &&

drivers/net/can/usb/esd_usb.c

251

struct esd_usb_id_filter_msg filter;

drivers/net/can/usb/esd_usb.c

745

msg->filter.net = priv->index;

drivers/net/can/usb/esd_usb.c

746

msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */

drivers/net/can/usb/esd_usb.c

748

msg->filter.mask[i] = cpu_to_le32(GENMASK(31, 0));

drivers/net/can/usb/esd_usb.c

750

msg->filter.mask[ESD_USB_MAX_ID_SEGMENT] = cpu_to_le32(BIT(0));

drivers/net/can/usb/esd_usb.c

968

msg->filter.net = priv->index;

drivers/net/can/usb/esd_usb.c

969

msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */

drivers/net/can/usb/esd_usb.c

971

msg->filter.mask[i] = 0;

drivers/net/ethernet/3com/typhoon.c

858

__le16 filter;

drivers/net/ethernet/3com/typhoon.c

860

filter = TYPHOON_RX_FILTER_DIRECTED | TYPHOON_RX_FILTER_BROADCAST;

drivers/net/ethernet/3com/typhoon.c

862

filter |= TYPHOON_RX_FILTER_PROMISCOUS;

drivers/net/ethernet/3com/typhoon.c

866

filter |= TYPHOON_RX_FILTER_ALL_MCAST;

drivers/net/ethernet/3com/typhoon.c

883

filter |= TYPHOON_RX_FILTER_MCAST_HASH;

drivers/net/ethernet/3com/typhoon.c

887

xp_cmd.parm1 = filter;

drivers/net/ethernet/agere/et131x.c

3685

int filter = adapter->packet_filter;

drivers/net/ethernet/agere/et131x.c

3698

if ((filter & ET131X_PACKET_TYPE_PROMISCUOUS) || filter == 0)

drivers/net/ethernet/agere/et131x.c

3705

if (filter & ET131X_PACKET_TYPE_ALL_MULTICAST)

drivers/net/ethernet/agere/et131x.c

3714

if (filter & ET131X_PACKET_TYPE_DIRECTED) {

drivers/net/ethernet/agere/et131x.c

3721

if (filter & ET131X_PACKET_TYPE_BROADCAST) {

drivers/net/ethernet/amd/7990.c

223

ib->filter[0] = 0;

drivers/net/ethernet/amd/7990.c

224

ib->filter[1] = 0;

drivers/net/ethernet/amd/7990.c

602

volatile u16 *mcast_table = (u16 *)&ib->filter;

drivers/net/ethernet/amd/7990.c

608

ib->filter[0] = 0xffffffff;

drivers/net/ethernet/amd/7990.c

609

ib->filter[1] = 0xffffffff;

drivers/net/ethernet/amd/7990.c

613

ib->filter[0] = 0;

drivers/net/ethernet/amd/7990.c

614

ib->filter[1] = 0;

drivers/net/ethernet/amd/7990.h

76

volatile unsigned filter[2]; /* Multicast filter (64 bits) */

drivers/net/ethernet/amd/a2065.c

214

ib->filter[0] = 0;

drivers/net/ethernet/amd/a2065.c

215

ib->filter[1] = 0;

drivers/net/ethernet/amd/a2065.c

583

volatile u16 *mcast_table = (u16 *)&ib->filter;

drivers/net/ethernet/amd/a2065.c

589

ib->filter[0] = 0xffffffff;

drivers/net/ethernet/amd/a2065.c

590

ib->filter[1] = 0xffffffff;

drivers/net/ethernet/amd/a2065.c

594

ib->filter[0] = 0;

drivers/net/ethernet/amd/a2065.c

595

ib->filter[1] = 0;

drivers/net/ethernet/amd/a2065.c

87

unsigned filter[2]; /* Multicast filter. */

drivers/net/ethernet/amd/atarilance.c

149

unsigned filter[2]; /* Multicast filter (unused). */

drivers/net/ethernet/amd/atarilance.c

615

MEM->init.filter[0] = 0x00000000;

drivers/net/ethernet/amd/atarilance.c

616

MEM->init.filter[1] = 0x00000000;

drivers/net/ethernet/amd/declance.c

211

unsigned short filter[4]; /* multicast filter */

drivers/net/ethernet/amd/declance.c

798

*lib_ptr(ib, filter[0], lp->type) = 0;

drivers/net/ethernet/amd/declance.c

799

*lib_ptr(ib, filter[1], lp->type) = 0;

drivers/net/ethernet/amd/declance.c

800

*lib_ptr(ib, filter[2], lp->type) = 0;

drivers/net/ethernet/amd/declance.c

801

*lib_ptr(ib, filter[3], lp->type) = 0;

drivers/net/ethernet/amd/declance.c

952

*lib_ptr(ib, filter[0], lp->type) = 0xffff;

drivers/net/ethernet/amd/declance.c

953

*lib_ptr(ib, filter[1], lp->type) = 0xffff;

drivers/net/ethernet/amd/declance.c

954

*lib_ptr(ib, filter[2], lp->type) = 0xffff;

drivers/net/ethernet/amd/declance.c

955

*lib_ptr(ib, filter[3], lp->type) = 0xffff;

drivers/net/ethernet/amd/declance.c

959

*lib_ptr(ib, filter[0], lp->type) = 0;

drivers/net/ethernet/amd/declance.c

960

*lib_ptr(ib, filter[1], lp->type) = 0;

drivers/net/ethernet/amd/declance.c

961

*lib_ptr(ib, filter[2], lp->type) = 0;

drivers/net/ethernet/amd/declance.c

962

*lib_ptr(ib, filter[3], lp->type) = 0;

drivers/net/ethernet/amd/declance.c

968

*lib_ptr(ib, filter[crc >> 4], lp->type) |= 1 << (crc & 0xf);

drivers/net/ethernet/amd/lance.c

230

u32 filter[2]; /* Multicast filter (unused). */

drivers/net/ethernet/amd/lance.c

578

lp->init_block.filter[0] = 0x00000000;

drivers/net/ethernet/amd/lance.c

579

lp->init_block.filter[1] = 0x00000000;

drivers/net/ethernet/amd/lance.c

901

lp->init_block.filter[0] = 0x00000000;

drivers/net/ethernet/amd/lance.c

902

lp->init_block.filter[1] = 0x00000000;

drivers/net/ethernet/amd/pcnet32.c

1912

lp->init_block->filter[0] = 0x00000000;

drivers/net/ethernet/amd/pcnet32.c

1913

lp->init_block->filter[1] = 0x00000000;

drivers/net/ethernet/amd/pcnet32.c

234

__le32 filter[2];

drivers/net/ethernet/amd/pcnet32.c

2683

volatile __le16 *mcast_table = (__le16 *)ib->filter;

drivers/net/ethernet/amd/pcnet32.c

2691

ib->filter[0] = cpu_to_le32(~0U);

drivers/net/ethernet/amd/pcnet32.c

2692

ib->filter[1] = cpu_to_le32(~0U);

drivers/net/ethernet/amd/pcnet32.c

2700

ib->filter[0] = 0;

drivers/net/ethernet/amd/pcnet32.c

2701

ib->filter[1] = 0;

drivers/net/ethernet/amd/sun3lance.c

131

unsigned int filter[2]; /* Multicast filter (unused). */

drivers/net/ethernet/amd/sun3lance.c

389

MEM->init.filter[0] = 0x00000000;

drivers/net/ethernet/amd/sun3lance.c

390

MEM->init.filter[1] = 0x00000000;

drivers/net/ethernet/amd/sun3lance.c

487

MEM->init.filter[0] = 0x00000000;

drivers/net/ethernet/amd/sun3lance.c

488

MEM->init.filter[1] = 0x00000000;

drivers/net/ethernet/amd/sunlance.c

1174

sbus_writel(val, &ib->filter[0]);

drivers/net/ethernet/amd/sunlance.c

1175

sbus_writel(val, &ib->filter[1]);

drivers/net/ethernet/amd/sunlance.c

1178

ib->filter [0] = val;

drivers/net/ethernet/amd/sunlance.c

1179

ib->filter [1] = val;

drivers/net/ethernet/amd/sunlance.c

1191

u16 __iomem *mcast_table = (u16 __iomem *) &ib->filter;

drivers/net/ethernet/amd/sunlance.c

1197

u16 *mcast_table = (u16 *) &ib->filter;

drivers/net/ethernet/amd/sunlance.c

213

u32 filter[2]; /* Multicast filter. */

drivers/net/ethernet/amd/sunlance.c

938

sbus_writel(0, &ib->filter[0]);

drivers/net/ethernet/amd/sunlance.c

939

sbus_writel(0, &ib->filter[1]);

drivers/net/ethernet/amd/sunlance.c

943

ib->filter [0] = 0;

drivers/net/ethernet/amd/sunlance.c

944

ib->filter [1] = 0;

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1001

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_ACT_F_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1008

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1010

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_ID_F_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1017

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1019

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_RXQ_EN_F_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1026

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1028

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_RXQ_F_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1035

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1037

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_ENF_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1043

u32 etht_user_priority_en, u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1045

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_UPFEN_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1052

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1054

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_RXQFEN_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1062

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1064

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_UPF_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1070

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1072

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_RXQF_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1078

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1080

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_MNG_RXQF_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1087

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1089

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_ACTF_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1094

void hw_atl_rpf_etht_flr_set(struct aq_hw_s *aq_hw, u32 etht_flr, u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1096

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_VALF_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1101

void hw_atl_rpf_l4_spd_set(struct aq_hw_s *aq_hw, u32 val, u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1103

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_SPD_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1108

void hw_atl_rpf_l4_dpd_set(struct aq_hw_s *aq_hw, u32 val, u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

1110

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_DPD_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

581

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

583

aq_hw_write_reg(aq_hw, HW_ATL_RX_FLR_MCST_FLR_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

777

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

779

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPFL2MC_ENF_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

802

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

804

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPFL2UC_ACTF_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

810

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

812

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPFL2UC_ENF_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

819

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

821

aq_hw_write_reg(aq_hw, HW_ATL_RPFL2UC_DAFLSW_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

827

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

829

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPFL2UC_DAFMSW_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

990

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

992

aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_EN_F_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c

999

u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

283

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

390

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

402

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

406

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

411

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

416

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

479

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

483

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

487

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

491

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

495

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

499

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

504

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

509

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

513

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

518

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

522

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

526

u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

529

void hw_atl_rpf_etht_flr_set(struct aq_hw_s *aq_hw, u32 etht_flr, u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

532

void hw_atl_rpf_l4_spd_set(struct aq_hw_s *aq_hw, u32 val, u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h

535

void hw_atl_rpf_l4_dpd_set(struct aq_hw_s *aq_hw, u32 val, u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1152

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1171

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1190

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1209

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1228

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1247

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1266

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1285

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1304

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1323

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1342

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1361

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1380

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1398

#define HW_ATL_RPF_L3_REG_CTRL_ADR(filter) (0x00005380 + (filter) * 0x4)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1407

#define HW_ATL_RPF_L3_SRCA_ADR(filter) (0x000053B0 + (filter) * 0x4)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

1426

#define HW_ATL_RPF_L3_DSTA_ADR(filter) (0x000053D0 + (filter) * 0x4)

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

554

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

829

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

866

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

885

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

898

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h

900

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

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils_fw2x.c

77

struct fw2x_msg_wol_pattern filter[HAL_ATLANTIC_WOL_FILTERS_COUNT];

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh.c

36

void hw_atl2_rpfl2_uc_flr_tag_set(struct aq_hw_s *aq_hw, u32 tag, u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh.c

38

aq_hw_write_reg_bit(aq_hw, HW_ATL2_RPFL2UC_TAG_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh.c

61

void hw_atl2_rpf_vlan_flr_tag_set(struct aq_hw_s *aq_hw, u32 tag, u32 filter)

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh.c

63

aq_hw_write_reg_bit(aq_hw, HW_ATL2_RPF_VL_TAG_ADR(filter),

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh.h

29

void hw_atl2_rpfl2_uc_flr_tag_set(struct aq_hw_s *aq_hw, u32 tag, u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh.h

39

void hw_atl2_rpf_vlan_flr_tag_set(struct aq_hw_s *aq_hw, u32 tag, u32 filter);

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh_internal.h

106

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

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh_internal.h

285

#define HW_ATL2_RPF_ACT_RSLVR_REQ_TAG_ADR(filter) \

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh_internal.h

286

(0x00014000u + (filter) * 0x10)

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh_internal.h

299

#define HW_ATL2_RPF_ACT_RSLVR_TAG_MASK_ADR(filter) \

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh_internal.h

300

(0x00014004u + (filter) * 0x10)

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh_internal.h

313

#define HW_ATL2_RPF_ACT_RSLVR_ACTN_ADR(filter) \

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh_internal.h

314

(0x00014008u + (filter) * 0x10)

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_llh_internal.h

52

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

drivers/net/ethernet/arc/emac_main.c

528

unsigned int filter[2] = { 0, 0 };

drivers/net/ethernet/arc/emac_main.c

533

filter[bit >> 5] |= 1 << (bit & 31);

drivers/net/ethernet/arc/emac_main.c

536

arc_reg_set(priv, R_LAFL, filter[0]);

drivers/net/ethernet/arc/emac_main.c

537

arc_reg_set(priv, R_LAFH, filter[1]);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c

3483

#define BNX2X_57711_SET_MC_FILTER(filter, bit) \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c

3485

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

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

380

struct bnx2x_vf_mac_vlan_filter *filter,

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

387

vf->abs_vfid, filter->add ? "Adding" : "Deleting",

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

388

(filter->type == BNX2X_VF_FILTER_VLAN_MAC) ? "VLAN-MAC" :

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

389

(filter->type == BNX2X_VF_FILTER_MAC) ? "MAC" : "VLAN");

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

393

if (filter->type == BNX2X_VF_FILTER_VLAN_MAC) {

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

395

ramrod.user_req.u.vlan.vlan = filter->vid;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

396

memcpy(&ramrod.user_req.u.mac.mac, filter->mac, ETH_ALEN);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

398

} else if (filter->type == BNX2X_VF_FILTER_VLAN) {

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

400

ramrod.user_req.u.vlan.vlan = filter->vid;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

404

memcpy(&ramrod.user_req.u.mac.mac, filter->mac, ETH_ALEN);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

406

ramrod.user_req.cmd = filter->add ? BNX2X_VLAN_MAC_ADD :

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

421

filter->add ? "add" : "delete",

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

422

(filter->type == BNX2X_VF_FILTER_VLAN_MAC) ?

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

424

(filter->type == BNX2X_VF_FILTER_MAC) ?

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

429

filter->applied = true;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1700

struct vfpf_q_mac_vlan_filter *filter)

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1702

DP(msglvl, "MAC-VLAN[%d] -- flags=0x%x\n", idx, filter->flags);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1703

if (filter->flags & VFPF_Q_FILTER_VLAN_TAG_VALID)

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1704

DP_CONT(msglvl, ", vlan=%d", filter->vlan_tag);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1705

if (filter->flags & VFPF_Q_FILTER_DEST_MAC_VALID)

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1706

DP_CONT(msglvl, ", MAC=%pM", filter->mac);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1851

struct vfpf_q_mac_vlan_filter *filter = NULL;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1862

if (filter) {

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1870

filter = &filters->filters[i];

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1874

if (filter &&

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

1875

!ether_addr_equal(filter->mac, bulletin->mac)) {

drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h

587

__be32 filter;

drivers/net/ethernet/cisco/enic/enic_clsf.c

24

struct filter data;

drivers/net/ethernet/cisco/enic/vnic_dev.c

1188

struct filter *data)

drivers/net/ethernet/cisco/enic/vnic_dev.c

1199

tlv_size = sizeof(struct filter) +

drivers/net/ethernet/cisco/enic/vnic_dev.c

1211

tlv->length = sizeof(struct filter);

drivers/net/ethernet/cisco/enic/vnic_dev.c

1212

*(struct filter *)&tlv->val = *data;

drivers/net/ethernet/cisco/enic/vnic_dev.c

1216

sizeof(struct filter));

drivers/net/ethernet/cisco/enic/vnic_dev.h

172

struct filter *data);

drivers/net/ethernet/cortina/gemini.c

1894

union gmac_rx_fltr filter = { .bits = {

drivers/net/ethernet/cortina/gemini.c

1907

filter.bits.error = 1;

drivers/net/ethernet/cortina/gemini.c

1908

filter.bits.promiscuous = 1;

drivers/net/ethernet/cortina/gemini.c

1923

writel(filter.bits32, port->gmac_base + GMAC_RX_FLTR);

drivers/net/ethernet/engleder/tsnep.h

57

struct tsnep_rxnfc_filter filter;

drivers/net/ethernet/engleder/tsnep_rxnfc.c

114

if (rule->filter.type == TSNEP_RXNFC_ETHER_TYPE) {

drivers/net/ethernet/engleder/tsnep_rxnfc.c

115

fsp->h_u.ether_spec.h_proto = htons(rule->filter.ether_type);

drivers/net/ethernet/engleder/tsnep_rxnfc.c

179

rule->filter.type = TSNEP_RXNFC_ETHER_TYPE;

drivers/net/ethernet/engleder/tsnep_rxnfc.c

180

rule->filter.ether_type = ntohs(fsp->h_u.ether_spec.h_proto);

drivers/net/ethernet/engleder/tsnep_rxnfc.c

190

if (!memcmp(&rule->filter, &tmp->filter, sizeof(rule->filter)) &&

drivers/net/ethernet/engleder/tsnep_rxnfc.c

20

iowrite16(rule->filter.ether_type, addr);

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

432

if (entry->cfg.filter == DPSW_REFLECTION_FILTER_INGRESS_VLAN &&

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

628

if (tmp->cfg.filter == DPSW_REFLECTION_FILTER_INGRESS_VLAN &&

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

640

mirror_entry->cfg.filter = DPSW_REFLECTION_FILTER_INGRESS_VLAN;

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

776

if (tmp->cfg.filter == DPSW_REFLECTION_FILTER_INGRESS_ALL) {

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

787

mirror_entry->cfg.filter = DPSW_REFLECTION_FILTER_INGRESS_ALL;

drivers/net/ethernet/freescale/dpaa2/dpsw-cmd.h

553

u8 filter;

drivers/net/ethernet/freescale/dpaa2/dpsw.c

1631

dpsw_set_field(cmd_params->filter, FILTER, cfg->filter);

drivers/net/ethernet/freescale/dpaa2/dpsw.c

1658

dpsw_set_field(cmd_params->filter, FILTER, cfg->filter);

drivers/net/ethernet/freescale/dpaa2/dpsw.h

779

enum dpsw_reflection_filter filter;

drivers/net/ethernet/freescale/enetc/enetc.c

64

void enetc_add_mac_addr_ht_filter(struct enetc_mac_filter *filter,

drivers/net/ethernet/freescale/enetc/enetc.c

70

__set_bit(idx, filter->mac_hash_table);

drivers/net/ethernet/freescale/enetc/enetc.c

71

filter->mac_addr_cnt++;

drivers/net/ethernet/freescale/enetc/enetc.c

75

void enetc_reset_mac_addr_filter(struct enetc_mac_filter *filter)

drivers/net/ethernet/freescale/enetc/enetc.c

77

filter->mac_addr_cnt = 0;

drivers/net/ethernet/freescale/enetc/enetc.c

79

bitmap_zero(filter->mac_hash_table,

drivers/net/ethernet/freescale/enetc/enetc.h

515

void enetc_add_mac_addr_ht_filter(struct enetc_mac_filter *filter,

drivers/net/ethernet/freescale/enetc/enetc.h

517

void enetc_reset_mac_addr_filter(struct enetc_mac_filter *filter);

drivers/net/ethernet/freescale/enetc/enetc_pf.c

164

struct enetc_mac_filter *filter;

drivers/net/ethernet/freescale/enetc/enetc_pf.c

183

filter = &pf->mac_filter[UC];

drivers/net/ethernet/freescale/enetc/enetc_pf.c

184

enetc_reset_mac_addr_filter(filter);

drivers/net/ethernet/freescale/enetc/enetc_pf.c

189

enetc_add_mac_addr_em_filter(filter, ha->addr);

drivers/net/ethernet/freescale/enetc/enetc_pf.c

193

enetc_add_mac_addr_ht_filter(filter, ha->addr);

drivers/net/ethernet/freescale/enetc/enetc_pf.c

199

filter = &pf->mac_filter[MC];

drivers/net/ethernet/freescale/enetc/enetc_pf.c

200

enetc_reset_mac_addr_filter(filter);

drivers/net/ethernet/freescale/enetc/enetc_pf.c

206

enetc_add_mac_addr_ht_filter(filter, ha->addr);

drivers/net/ethernet/freescale/enetc/enetc_pf.c

75

static void enetc_add_mac_addr_em_filter(struct enetc_mac_filter *filter,

drivers/net/ethernet/freescale/enetc/enetc_pf.c

79

ether_addr_copy(filter->mac_addr, addr);

drivers/net/ethernet/freescale/enetc/enetc_pf.c

80

filter->mac_addr_cnt++;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1020

struct enetc_stream_filter *filter)

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1022

if (filter->flags & ENETC_PSFP_FLAGS_FMI)

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1023

flow_meter_unref(priv, filter->fmi_index);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1025

stream_gate_unref(priv, filter->sgi_index);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1026

stream_filter_unref(priv, filter->sfi_index);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1028

hlist_del(&filter->node);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1029

kfree(filter);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1131

struct enetc_stream_filter *filter, *old_filter;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1156

filter = kzalloc_obj(*filter);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1157

if (!filter)

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1160

filter->sid.index = f->common.chain_index;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1182

ether_addr_copy(filter->sid.dst_mac, match.key->dst);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1183

filter->sid.filtertype = STREAMID_TYPE_NULL;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1193

ether_addr_copy(filter->sid.src_mac, match.key->src);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1194

filter->sid.filtertype = STREAMID_TYPE_SMAC;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1222

filter->sid.vid = match.key->vlan_id;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1223

if (!filter->sid.vid)

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1224

filter->sid.tagged = STREAMID_VLAN_UNTAGGED;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1226

filter->sid.tagged = STREAMID_VLAN_TAGGED;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1229

filter->sid.tagged = STREAMID_VLAN_ALL;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1267

filter->sgi_index = sgi->index;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1295

filter->flags |= ENETC_PSFP_FLAGS_FMI;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1296

filter->fmi_index = fmi->index;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1324

filter->sid.handle = sfi->handle;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1325

filter->sfi_index = sfi->index;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1328

filter->sfi_index = old_sfi->index;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1329

filter->sid.handle = old_sfi->handle;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1333

err = enetc_psfp_hw_set(priv, &filter->sid,

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1339

if (filter->flags & ENETC_PSFP_FLAGS_FMI) {

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1340

old_fmi = enetc_get_meter_by_index(filter->fmi_index);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1352

old_sgi = enetc_get_gate_by_index(filter->sgi_index);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1370

old_filter = enetc_get_stream_by_index(filter->sid.index);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1374

filter->stats.lastused = jiffies;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1375

hlist_add_head(&filter->node, &epsfp.stream_list);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1388

kfree(filter);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1436

struct enetc_stream_filter *filter;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1445

filter = enetc_get_stream_by_index(f->common.chain_index);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1446

if (!filter)

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1449

err = enetc_streamid_hw_set(priv, &filter->sid, false);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1453

remove_one_chain(priv, filter);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1468

struct enetc_stream_filter *filter;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1472

filter = enetc_get_stream_by_index(f->common.chain_index);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1473

if (!filter)

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1476

err = enetc_streamcounter_hw_get(priv, filter->sfi_index, &counters);

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1483

filter->stats.pkts;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1487

filter->stats.drops;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1488

stats.lastused = filter->stats.lastused;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1489

filter->stats.pkts += stats.pkts;

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1490

filter->stats.drops += stats.drops;

drivers/net/ethernet/hisilicon/hibmcge/hbg_common.h

283

struct hbg_mac_filter filter;

drivers/net/ethernet/hisilicon/hibmcge/hbg_debugfs.c

86

struct hbg_mac_filter *filter;

drivers/net/ethernet/hisilicon/hibmcge/hbg_debugfs.c

89

filter = &priv->filter;

drivers/net/ethernet/hisilicon/hibmcge/hbg_debugfs.c

90

seq_printf(s, "mac addr max count: %u\n", filter->table_max_len);

drivers/net/ethernet/hisilicon/hibmcge/hbg_debugfs.c

91

seq_printf(s, "filter enabled: %s\n", str_true_false(filter->enabled));

drivers/net/ethernet/hisilicon/hibmcge/hbg_debugfs.c

93

for (i = 0; i < filter->table_max_len; i++) {

drivers/net/ethernet/hisilicon/hibmcge/hbg_debugfs.c

94

if (is_zero_ether_addr(filter->mac_table[i].addr))

drivers/net/ethernet/hisilicon/hibmcge/hbg_debugfs.c

97

seq_printf(s, "[%u] %pM\n", i, filter->mac_table[i].addr);

drivers/net/ethernet/hisilicon/hibmcge/hbg_err.c

14

struct hbg_mac_filter *filter = &priv->filter;

drivers/net/ethernet/hisilicon/hibmcge/hbg_err.c

18

for (i = 0; i < filter->table_max_len; i++)

drivers/net/ethernet/hisilicon/hibmcge/hbg_err.c

19

if (!is_zero_ether_addr(filter->mac_table[i].addr)) {

drivers/net/ethernet/hisilicon/hibmcge/hbg_err.c

20

addr = ether_addr_to_u64(filter->mac_table[i].addr);

drivers/net/ethernet/hisilicon/hibmcge/hbg_err.c

24

hbg_hw_set_mac_filter_enable(priv, priv->filter.enabled);

drivers/net/ethernet/hisilicon/hibmcge/hbg_err.c

30

u64 rx_pause_addr = ether_addr_to_u64(priv->filter.mac_table[0].addr);

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

107

for (i = 0; i < priv->filter.table_max_len; i++)

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

108

if (ether_addr_equal(priv->filter.mac_table[i].addr, addr)) {

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

124

for (index = 0; index < priv->filter.table_max_len; index++)

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

125

if (is_zero_ether_addr(priv->filter.mac_table[index].addr)) {

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

339

struct hbg_mac_filter *filter = &priv->filter;

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

347

filter->mac_table = tmp_table;

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

348

filter->table_max_len = dev_specs->uc_mac_num;

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

349

filter->enabled = true;

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

351

hbg_hw_set_mac_filter_enable(priv, filter->enabled);

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

86

priv->filter.enabled = !(overflow || (netdev->flags & IFF_PROMISC));

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

87

hbg_hw_set_mac_filter_enable(priv, priv->filter.enabled);

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

94

ether_addr_copy(priv->filter.mac_table[index].addr, addr);

drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c

97

eth_zero_addr(priv->filter.mac_table[index].addr);

drivers/net/ethernet/huawei/hinic3/hinic3_filter.c

317

struct hinic3_mac_filter *filter;

drivers/net/ethernet/huawei/hinic3/hinic3_filter.c

325

filter = hinic3_find_mac(filter_list, ha->addr);

drivers/net/ethernet/huawei/hinic3/hinic3_filter.c

326

if (!filter)

drivers/net/ethernet/huawei/hinic3/hinic3_filter.c

328

else if (filter->state == HINIC3_MAC_WAIT_HW_UNSYNC)

drivers/net/ethernet/huawei/hinic3/hinic3_filter.c

329

filter->state = HINIC3_MAC_HW_SYNCED;

drivers/net/ethernet/intel/i40e/i40e.h

1337

struct i40e_cloud_filter *filter,

drivers/net/ethernet/intel/i40e/i40e.h

1340

struct i40e_cloud_filter *filter,

drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h

387

u8 filter[128];

drivers/net/ethernet/intel/i40e/i40e_main.c

3838

struct i40e_fdir_filter *filter;

drivers/net/ethernet/intel/i40e/i40e_main.c

3848

hlist_for_each_entry_safe(filter, node,

drivers/net/ethernet/intel/i40e/i40e_main.c

3850

i40e_add_del_fdir(vsi, filter, true);

drivers/net/ethernet/intel/i40e/i40e_main.c

8343

i40e_set_cld_element(struct i40e_cloud_filter *filter,

drivers/net/ethernet/intel/i40e/i40e_main.c

8350

ether_addr_copy(cld->outer_mac, filter->dst_mac);

drivers/net/ethernet/intel/i40e/i40e_main.c

8351

ether_addr_copy(cld->inner_mac, filter->src_mac);

drivers/net/ethernet/intel/i40e/i40e_main.c

8353

if (filter->n_proto != ETH_P_IP && filter->n_proto != ETH_P_IPV6)

drivers/net/ethernet/intel/i40e/i40e_main.c

8356

if (filter->n_proto == ETH_P_IPV6) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8357

#define IPV6_MAX_INDEX (ARRAY_SIZE(filter->dst_ipv6) - 1)

drivers/net/ethernet/intel/i40e/i40e_main.c

8358

for (i = 0; i < ARRAY_SIZE(filter->dst_ipv6); i++) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8359

ipa = be32_to_cpu(filter->dst_ipv6[IPV6_MAX_INDEX - i]);

drivers/net/ethernet/intel/i40e/i40e_main.c

8364

ipa = be32_to_cpu(filter->dst_ipv4);

drivers/net/ethernet/intel/i40e/i40e_main.c

8369

cld->inner_vlan = cpu_to_le16(ntohs(filter->vlan_id));

drivers/net/ethernet/intel/i40e/i40e_main.c

8374

if (filter->tenant_id)

drivers/net/ethernet/intel/i40e/i40e_main.c

8388

struct i40e_cloud_filter *filter, bool add)

drivers/net/ethernet/intel/i40e/i40e_main.c

8410

if (filter->flags >= ARRAY_SIZE(flag_table))

drivers/net/ethernet/intel/i40e/i40e_main.c

8416

i40e_set_cld_element(filter, &cld_filter);

drivers/net/ethernet/intel/i40e/i40e_main.c

8418

if (filter->tunnel_type != I40E_CLOUD_TNL_TYPE_NONE)

drivers/net/ethernet/intel/i40e/i40e_main.c

8419

cld_filter.flags = cpu_to_le16(filter->tunnel_type <<

drivers/net/ethernet/intel/i40e/i40e_main.c

8422

if (filter->n_proto == ETH_P_IPV6)

drivers/net/ethernet/intel/i40e/i40e_main.c

8423

cld_filter.flags |= cpu_to_le16(flag_table[filter->flags] |

drivers/net/ethernet/intel/i40e/i40e_main.c

8426

cld_filter.flags |= cpu_to_le16(flag_table[filter->flags] |

drivers/net/ethernet/intel/i40e/i40e_main.c

8430

ret = i40e_aq_add_cloud_filters(&pf->hw, filter->seid,

drivers/net/ethernet/intel/i40e/i40e_main.c

8433

ret = i40e_aq_rem_cloud_filters(&pf->hw, filter->seid,

drivers/net/ethernet/intel/i40e/i40e_main.c

8438

add ? "add" : "delete", filter->dst_port, ret,

drivers/net/ethernet/intel/i40e/i40e_main.c

8443

add ? "Added" : "Deleted", filter->seid);

drivers/net/ethernet/intel/i40e/i40e_main.c

8457

struct i40e_cloud_filter *filter,

drivers/net/ethernet/intel/i40e/i40e_main.c

8465

if ((is_valid_ether_addr(filter->dst_mac) &&

drivers/net/ethernet/intel/i40e/i40e_main.c

8466

is_valid_ether_addr(filter->src_mac)) ||

drivers/net/ethernet/intel/i40e/i40e_main.c

8467

(is_multicast_ether_addr(filter->dst_mac) &&

drivers/net/ethernet/intel/i40e/i40e_main.c

8468

is_multicast_ether_addr(filter->src_mac)))

drivers/net/ethernet/intel/i40e/i40e_main.c

8474

if (!filter->dst_port || filter->ip_proto == IPPROTO_UDP)

drivers/net/ethernet/intel/i40e/i40e_main.c

8478

if (filter->src_port ||

drivers/net/ethernet/intel/i40e/i40e_main.c

8479

(filter->src_ipv4 && filter->n_proto != ETH_P_IPV6) ||

drivers/net/ethernet/intel/i40e/i40e_main.c

8480

!ipv6_addr_any(&filter->ip.v6.src_ip6))

drivers/net/ethernet/intel/i40e/i40e_main.c

8486

i40e_set_cld_element(filter, &cld_filter.element);

drivers/net/ethernet/intel/i40e/i40e_main.c

8488

if (is_valid_ether_addr(filter->dst_mac) ||

drivers/net/ethernet/intel/i40e/i40e_main.c

8489

is_valid_ether_addr(filter->src_mac) ||

drivers/net/ethernet/intel/i40e/i40e_main.c

8490

is_multicast_ether_addr(filter->dst_mac) ||

drivers/net/ethernet/intel/i40e/i40e_main.c

8491

is_multicast_ether_addr(filter->src_mac)) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8493

if (filter->dst_ipv4)

drivers/net/ethernet/intel/i40e/i40e_main.c

8503

if (filter->vlan_id) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8508

} else if ((filter->dst_ipv4 && filter->n_proto != ETH_P_IPV6) ||

drivers/net/ethernet/intel/i40e/i40e_main.c

8509

!ipv6_addr_any(&filter->ip.v6.dst_ip6)) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8512

if (filter->n_proto == ETH_P_IPV6)

drivers/net/ethernet/intel/i40e/i40e_main.c

8526

be16_to_cpu(filter->dst_port);

drivers/net/ethernet/intel/i40e/i40e_main.c

8538

ret = i40e_aq_add_cloud_filters_bb(&pf->hw, filter->seid,

drivers/net/ethernet/intel/i40e/i40e_main.c

8541

ret = i40e_aq_rem_cloud_filters_bb(&pf->hw, filter->seid,

drivers/net/ethernet/intel/i40e/i40e_main.c

8552

add ? "add" : "delete", filter->seid,

drivers/net/ethernet/intel/i40e/i40e_main.c

8553

ntohs(filter->dst_port));

drivers/net/ethernet/intel/i40e/i40e_main.c

8566

struct i40e_cloud_filter *filter)

drivers/net/ethernet/intel/i40e/i40e_main.c

8595

filter->tenant_id = be32_to_cpu(match.key->keyid);

drivers/net/ethernet/intel/i40e/i40e_main.c

8609

filter->n_proto = n_proto_key & n_proto_mask;

drivers/net/ethernet/intel/i40e/i40e_main.c

8610

filter->ip_proto = match.key->ip_proto;

drivers/net/ethernet/intel/i40e/i40e_main.c

8638

ether_addr_copy(filter->dst_mac, match.key->dst);

drivers/net/ethernet/intel/i40e/i40e_main.c

8639

ether_addr_copy(filter->src_mac, match.key->src);

drivers/net/ethernet/intel/i40e/i40e_main.c

8657

filter->vlan_id = cpu_to_be16(match.key->vlan_id);

drivers/net/ethernet/intel/i40e/i40e_main.c

8699

filter->dst_ipv4 = match.key->dst;

drivers/net/ethernet/intel/i40e/i40e_main.c

8700

filter->src_ipv4 = match.key->src;

drivers/net/ethernet/intel/i40e/i40e_main.c

8721

memcpy(&filter->src_ipv6, &match.key->src.s6_addr32,

drivers/net/ethernet/intel/i40e/i40e_main.c

8722

sizeof(filter->src_ipv6));

drivers/net/ethernet/intel/i40e/i40e_main.c

8723

memcpy(&filter->dst_ipv6, &match.key->dst.s6_addr32,

drivers/net/ethernet/intel/i40e/i40e_main.c

8724

sizeof(filter->dst_ipv6));

drivers/net/ethernet/intel/i40e/i40e_main.c

8751

filter->dst_port = match.key->dst;

drivers/net/ethernet/intel/i40e/i40e_main.c

8752

filter->src_port = match.key->src;

drivers/net/ethernet/intel/i40e/i40e_main.c

8754

switch (filter->ip_proto) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8764

filter->flags = field_flags;

drivers/net/ethernet/intel/i40e/i40e_main.c

8776

struct i40e_cloud_filter *filter)

drivers/net/ethernet/intel/i40e/i40e_main.c

8782

filter->seid = vsi->seid;

drivers/net/ethernet/intel/i40e/i40e_main.c

8785

if (!filter->dst_port) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8795

filter->seid = ch->seid;

drivers/net/ethernet/intel/i40e/i40e_main.c

8813

struct i40e_cloud_filter *filter = NULL;

drivers/net/ethernet/intel/i40e/i40e_main.c

8845

filter = kzalloc_obj(*filter);

drivers/net/ethernet/intel/i40e/i40e_main.c

8846

if (!filter)

drivers/net/ethernet/intel/i40e/i40e_main.c

8849

filter->cookie = cls_flower->cookie;

drivers/net/ethernet/intel/i40e/i40e_main.c

8851

err = i40e_parse_cls_flower(vsi, cls_flower, filter);

drivers/net/ethernet/intel/i40e/i40e_main.c

8855

err = i40e_handle_tclass(vsi, tc, filter);

drivers/net/ethernet/intel/i40e/i40e_main.c

8860

if (filter->dst_port)

drivers/net/ethernet/intel/i40e/i40e_main.c

8861

err = i40e_add_del_cloud_filter_big_buf(vsi, filter, true);

drivers/net/ethernet/intel/i40e/i40e_main.c

8863

err = i40e_add_del_cloud_filter(vsi, filter, true);

drivers/net/ethernet/intel/i40e/i40e_main.c

8872

INIT_HLIST_NODE(&filter->cloud_node);

drivers/net/ethernet/intel/i40e/i40e_main.c

8874

hlist_add_head(&filter->cloud_node, &pf->cloud_filter_list);

drivers/net/ethernet/intel/i40e/i40e_main.c

8880

kfree(filter);

drivers/net/ethernet/intel/i40e/i40e_main.c

8893

struct i40e_cloud_filter *filter = NULL;

drivers/net/ethernet/intel/i40e/i40e_main.c

8896

hlist_for_each_entry_safe(filter, node2,

drivers/net/ethernet/intel/i40e/i40e_main.c

8898

if (!memcmp(cookie, &filter->cookie, sizeof(filter->cookie)))

drivers/net/ethernet/intel/i40e/i40e_main.c

8899

return filter;

drivers/net/ethernet/intel/i40e/i40e_main.c

8912

struct i40e_cloud_filter *filter = NULL;

drivers/net/ethernet/intel/i40e/i40e_main.c

8916

filter = i40e_find_cloud_filter(vsi, &cls_flower->cookie);

drivers/net/ethernet/intel/i40e/i40e_main.c

8918

if (!filter)

drivers/net/ethernet/intel/i40e/i40e_main.c

8921

hash_del(&filter->cloud_node);

drivers/net/ethernet/intel/i40e/i40e_main.c

8923

if (filter->dst_port)

drivers/net/ethernet/intel/i40e/i40e_main.c

8924

err = i40e_add_del_cloud_filter_big_buf(vsi, filter, false);

drivers/net/ethernet/intel/i40e/i40e_main.c

8926

err = i40e_add_del_cloud_filter(vsi, filter, false);

drivers/net/ethernet/intel/i40e/i40e_main.c

8928

kfree(filter);

drivers/net/ethernet/intel/i40e/i40e_main.c

9153

struct i40e_fdir_filter *filter;

drivers/net/ethernet/intel/i40e/i40e_main.c

9157

hlist_for_each_entry_safe(filter, node2,

drivers/net/ethernet/intel/i40e/i40e_main.c

9159

hlist_del(&filter->fdir_node);

drivers/net/ethernet/intel/i40e/i40e_main.c

9160

kfree(filter);

drivers/net/ethernet/intel/i40e/i40e_main.c

9660

struct i40e_fdir_filter *filter)

drivers/net/ethernet/intel/i40e/i40e_main.c

9666

switch (filter->flow_type) {

drivers/net/ethernet/intel/i40e/i40e_main.c

9686

switch (filter->ipl4_proto) {

drivers/net/ethernet/intel/i40e/i40e_main.c

9702

switch (filter->ipl4_proto) {

drivers/net/ethernet/intel/i40e/i40e_main.c

9720

hlist_del(&filter->fdir_node);

drivers/net/ethernet/intel/i40e/i40e_main.c

9721

kfree(filter);

drivers/net/ethernet/intel/i40e/i40e_main.c

9730

struct i40e_fdir_filter *filter;

drivers/net/ethernet/intel/i40e/i40e_main.c

9755

hlist_for_each_entry_safe(filter, node,

drivers/net/ethernet/intel/i40e/i40e_main.c

9757

if (filter->fd_id == pf->fd_inv)

drivers/net/ethernet/intel/i40e/i40e_main.c

9758

i40e_delete_invalid_filter(pf, filter);

drivers/net/ethernet/intel/iavf/iavf_main.c

3811

struct iavf_cloud_filter *filter)

drivers/net/ethernet/intel/iavf/iavf_main.c

3821

struct virtchnl_filter *vf = &filter->f;

drivers/net/ethernet/intel/iavf/iavf_main.c

4062

struct iavf_cloud_filter *filter)

drivers/net/ethernet/intel/iavf/iavf_main.c

4067

if (!filter->f.data.tcp_spec.dst_port) {

drivers/net/ethernet/intel/iavf/iavf_main.c

4074

filter->f.action = VIRTCHNL_ACTION_TC_REDIRECT;

drivers/net/ethernet/intel/iavf/iavf_main.c

4075

filter->f.action_meta = tc;

drivers/net/ethernet/intel/iavf/iavf_main.c

4090

struct iavf_cloud_filter *filter = NULL;

drivers/net/ethernet/intel/iavf/iavf_main.c

4095

list_for_each_entry(filter, &adapter->cloud_filter_list, list) {

drivers/net/ethernet/intel/iavf/iavf_main.c

4096

if (!memcmp(cookie, &filter->cookie, sizeof(filter->cookie)))

drivers/net/ethernet/intel/iavf/iavf_main.c

4097

return filter;

drivers/net/ethernet/intel/iavf/iavf_main.c

4111

struct iavf_cloud_filter *filter;

drivers/net/ethernet/intel/iavf/iavf_main.c

4119

filter = kzalloc_obj(*filter);

drivers/net/ethernet/intel/iavf/iavf_main.c

4120

if (!filter)

drivers/net/ethernet/intel/iavf/iavf_main.c

4122

filter->cookie = cls_flower->cookie;

drivers/net/ethernet/intel/iavf/iavf_main.c

4136

memset(&filter->f.mask.tcp_spec, 0, sizeof(struct virtchnl_l4_spec));

drivers/net/ethernet/intel/iavf/iavf_main.c

4138

filter->f.flow_type = VIRTCHNL_TCP_V4_FLOW;

drivers/net/ethernet/intel/iavf/iavf_main.c

4139

err = iavf_parse_cls_flower(adapter, cls_flower, filter);

drivers/net/ethernet/intel/iavf/iavf_main.c

4143

err = iavf_handle_tclass(adapter, tc, filter);

drivers/net/ethernet/intel/iavf/iavf_main.c

4149

list_add_tail(&filter->list, &adapter->cloud_filter_list);

drivers/net/ethernet/intel/iavf/iavf_main.c

4151

filter->add = true;

drivers/net/ethernet/intel/iavf/iavf_main.c

4157

kfree(filter);

drivers/net/ethernet/intel/iavf/iavf_main.c

4171

struct iavf_cloud_filter *filter = NULL;

drivers/net/ethernet/intel/iavf/iavf_main.c

4175

filter = iavf_find_cf(adapter, &cls_flower->cookie);

drivers/net/ethernet/intel/iavf/iavf_main.c

4176

if (filter) {

drivers/net/ethernet/intel/iavf/iavf_main.c

4177

filter->del = true;

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

546

const struct iavf_mac_filter *filter)

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

548

virtchnl_ether_addr->type = filter->is_primary ?

drivers/net/ethernet/intel/igb/igb.h

524

struct igb_nfc_input filter;

drivers/net/ethernet/intel/igb/igb_ethtool.c

2444

if (rule->filter.match_flags) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2447

if (rule->filter.match_flags & IGB_FILTER_FLAG_ETHER_TYPE) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2448

fsp->h_u.ether_spec.h_proto = rule->filter.etype;

drivers/net/ethernet/intel/igb/igb_ethtool.c

2451

if (rule->filter.match_flags & IGB_FILTER_FLAG_VLAN_TCI) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2453

fsp->h_ext.vlan_tci = rule->filter.vlan_tci;

drivers/net/ethernet/intel/igb/igb_ethtool.c

2456

if (rule->filter.match_flags & IGB_FILTER_FLAG_DST_MAC_ADDR) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2458

rule->filter.dst_addr);

drivers/net/ethernet/intel/igb/igb_ethtool.c

2464

if (rule->filter.match_flags & IGB_FILTER_FLAG_SRC_MAC_ADDR) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2466

rule->filter.src_addr);

drivers/net/ethernet/intel/igb/igb_ethtool.c

2702

etype = ntohs(input->filter.etype & ETHER_TYPE_FULL_MASK);

drivers/net/ethernet/intel/igb/igb_ethtool.c

2729

ntohs(input->filter.vlan_tci));

drivers/net/ethernet/intel/igb/igb_ethtool.c

2753

!(input->filter.match_flags & ~IGB_FILTER_FLAG_SRC_MAC_ADDR)) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2759

if (input->filter.match_flags & IGB_FILTER_FLAG_ETHER_TYPE) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2765

if (input->filter.match_flags & IGB_FILTER_FLAG_DST_MAC_ADDR) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2767

input->filter.dst_addr,

drivers/net/ethernet/intel/igb/igb_ethtool.c

2774

if (input->filter.match_flags & IGB_FILTER_FLAG_SRC_MAC_ADDR) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2776

input->filter.src_addr,

drivers/net/ethernet/intel/igb/igb_ethtool.c

2784

if (input->filter.match_flags & IGB_FILTER_FLAG_VLAN_TCI)

drivers/net/ethernet/intel/igb/igb_ethtool.c

2824

if (input->filter.match_flags & IGB_FILTER_FLAG_ETHER_TYPE)

drivers/net/ethernet/intel/igb/igb_ethtool.c

2828

if (input->filter.match_flags & IGB_FILTER_FLAG_VLAN_TCI)

drivers/net/ethernet/intel/igb/igb_ethtool.c

2830

ntohs(input->filter.vlan_tci));

drivers/net/ethernet/intel/igb/igb_ethtool.c

2832

if (input->filter.match_flags & IGB_FILTER_FLAG_SRC_MAC_ADDR)

drivers/net/ethernet/intel/igb/igb_ethtool.c

2833

igb_del_mac_steering_filter(adapter, input->filter.src_addr,

drivers/net/ethernet/intel/igb/igb_ethtool.c

2837

if (input->filter.match_flags & IGB_FILTER_FLAG_DST_MAC_ADDR)

drivers/net/ethernet/intel/igb/igb_ethtool.c

2838

igb_del_mac_steering_filter(adapter, input->filter.dst_addr,

drivers/net/ethernet/intel/igb/igb_ethtool.c

2927

input->filter.etype = fsp->h_u.ether_spec.h_proto;

drivers/net/ethernet/intel/igb/igb_ethtool.c

2928

input->filter.match_flags = IGB_FILTER_FLAG_ETHER_TYPE;

drivers/net/ethernet/intel/igb/igb_ethtool.c

2933

input->filter.match_flags |= IGB_FILTER_FLAG_SRC_MAC_ADDR;

drivers/net/ethernet/intel/igb/igb_ethtool.c

2934

ether_addr_copy(input->filter.src_addr,

drivers/net/ethernet/intel/igb/igb_ethtool.c

2940

input->filter.match_flags |= IGB_FILTER_FLAG_DST_MAC_ADDR;

drivers/net/ethernet/intel/igb/igb_ethtool.c

2941

ether_addr_copy(input->filter.dst_addr,

drivers/net/ethernet/intel/igb/igb_ethtool.c

2950

input->filter.vlan_tci = fsp->h_ext.vlan_tci;

drivers/net/ethernet/intel/igb/igb_ethtool.c

2951

input->filter.match_flags |= IGB_FILTER_FLAG_VLAN_TCI;

drivers/net/ethernet/intel/igb/igb_ethtool.c

2960

if (!memcmp(&input->filter, &rule->filter,

drivers/net/ethernet/intel/igb/igb_ethtool.c

2961

sizeof(input->filter))) {

drivers/net/ethernet/intel/igb/igb_main.c

2647

input->filter.match_flags |=

drivers/net/ethernet/intel/igb/igb_main.c

2649

ether_addr_copy(input->filter.dst_addr, match.key->dst);

drivers/net/ethernet/intel/igb/igb_main.c

2658

input->filter.match_flags |=

drivers/net/ethernet/intel/igb/igb_main.c

2660

ether_addr_copy(input->filter.src_addr, match.key->src);

drivers/net/ethernet/intel/igb/igb_main.c

2674

input->filter.match_flags |= IGB_FILTER_FLAG_ETHER_TYPE;

drivers/net/ethernet/intel/igb/igb_main.c

2675

input->filter.etype = match.key->n_proto;

drivers/net/ethernet/intel/igb/igb_main.c

2689

input->filter.match_flags |= IGB_FILTER_FLAG_VLAN_TCI;

drivers/net/ethernet/intel/igb/igb_main.c

2690

input->filter.vlan_tci =

drivers/net/ethernet/intel/igb/igb_main.c

2705

struct igb_nfc_filter *filter, *f;

drivers/net/ethernet/intel/igb/igb_main.c

2714

filter = kzalloc_obj(*filter);

drivers/net/ethernet/intel/igb/igb_main.c

2715

if (!filter)

drivers/net/ethernet/intel/igb/igb_main.c

2718

err = igb_parse_cls_flower(adapter, cls_flower, tc, filter);

drivers/net/ethernet/intel/igb/igb_main.c

2725

if (!memcmp(&f->filter, &filter->filter, sizeof(f->filter))) {

drivers/net/ethernet/intel/igb/igb_main.c

2734

if (!memcmp(&f->filter, &filter->filter, sizeof(f->filter))) {

drivers/net/ethernet/intel/igb/igb_main.c

2742

err = igb_add_filter(adapter, filter);

drivers/net/ethernet/intel/igb/igb_main.c

2748

hlist_add_head(&filter->nfc_node, &adapter->cls_flower_list);

drivers/net/ethernet/intel/igb/igb_main.c

2758

kfree(filter);

drivers/net/ethernet/intel/igb/igb_main.c

2766

struct igb_nfc_filter *filter;

drivers/net/ethernet/intel/igb/igb_main.c

2771

hlist_for_each_entry(filter, &adapter->cls_flower_list, nfc_node)

drivers/net/ethernet/intel/igb/igb_main.c

2772

if (filter->cookie == cls_flower->cookie)

drivers/net/ethernet/intel/igb/igb_main.c

2775

if (!filter) {

drivers/net/ethernet/intel/igb/igb_main.c

2780

err = igb_erase_filter(adapter, filter);

drivers/net/ethernet/intel/igb/igb_main.c

2784

hlist_del(&filter->nfc_node);

drivers/net/ethernet/intel/igb/igb_main.c

2785

kfree(filter);

drivers/net/ethernet/intel/igc/igc.h

657

struct igc_nfc_filter filter;

drivers/net/ethernet/intel/igc/igc_ethtool.c

1003

if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) {

drivers/net/ethernet/intel/igc/igc_ethtool.c

1005

rule->filter.src_addr);

drivers/net/ethernet/intel/igc/igc_ethtool.c

1009

if (rule->filter.match_flags & IGC_FILTER_FLAG_USER_DATA) {

drivers/net/ethernet/intel/igc/igc_ethtool.c

1011

memcpy(fsp->h_ext.data, rule->filter.user_data, sizeof(fsp->h_ext.data));

drivers/net/ethernet/intel/igc/igc_ethtool.c

1012

memcpy(fsp->m_ext.data, rule->filter.user_mask, sizeof(fsp->m_ext.data));

drivers/net/ethernet/intel/igc/igc_ethtool.c

1234

rule->filter.vlan_tci = ntohs(fsp->h_ext.vlan_tci);

drivers/net/ethernet/intel/igc/igc_ethtool.c

1235

rule->filter.vlan_tci_mask = ntohs(fsp->m_ext.vlan_tci);

drivers/net/ethernet/intel/igc/igc_ethtool.c

1236

rule->filter.match_flags |= IGC_FILTER_FLAG_VLAN_TCI;

drivers/net/ethernet/intel/igc/igc_ethtool.c

1240

rule->filter.etype = ntohs(fsp->h_u.ether_spec.h_proto);

drivers/net/ethernet/intel/igc/igc_ethtool.c

1241

rule->filter.match_flags = IGC_FILTER_FLAG_ETHER_TYPE;

drivers/net/ethernet/intel/igc/igc_ethtool.c

1248

rule->filter.match_flags |= IGC_FILTER_FLAG_SRC_MAC_ADDR;

drivers/net/ethernet/intel/igc/igc_ethtool.c

1249

ether_addr_copy(rule->filter.src_addr,

drivers/net/ethernet/intel/igc/igc_ethtool.c

1254

rule->filter.match_flags |= IGC_FILTER_FLAG_DST_MAC_ADDR;

drivers/net/ethernet/intel/igc/igc_ethtool.c

1255

ether_addr_copy(rule->filter.dst_addr,

drivers/net/ethernet/intel/igc/igc_ethtool.c

1261

rule->filter.vlan_etype = ntohs(fsp->h_ext.vlan_etype);

drivers/net/ethernet/intel/igc/igc_ethtool.c

1262

rule->filter.match_flags |= IGC_FILTER_FLAG_VLAN_ETYPE;

drivers/net/ethernet/intel/igc/igc_ethtool.c

1268

rule->filter.match_flags |= IGC_FILTER_FLAG_USER_DATA;

drivers/net/ethernet/intel/igc/igc_ethtool.c

1269

memcpy(rule->filter.user_data, fsp->h_ext.data, sizeof(fsp->h_ext.data));

drivers/net/ethernet/intel/igc/igc_ethtool.c

1270

memcpy(rule->filter.user_mask, fsp->m_ext.data, sizeof(fsp->m_ext.data));

drivers/net/ethernet/intel/igc/igc_ethtool.c

1282

if ((rule->filter.match_flags & IGC_FILTER_FLAG_USER_DATA) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1283

(rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_ETYPE) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1284

((rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) &&

drivers/net/ethernet/intel/igc/igc_ethtool.c

1285

rule->filter.vlan_tci_mask == ntohs(VLAN_TCI_FULL_MASK)) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1286

(rule->filter.match_flags & (rule->filter.match_flags - 1)))

drivers/net/ethernet/intel/igc/igc_ethtool.c

1302

if (!rule->filter.match_flags &&

drivers/net/ethernet/intel/igc/igc_ethtool.c

1307

rule->filter.match_flags = IGC_FILTER_FLAG_DEFAULT_QUEUE;

drivers/net/ethernet/intel/igc/igc_ethtool.c

1329

u8 flags = rule->filter.match_flags;

drivers/net/ethernet/intel/igc/igc_ethtool.c

1338

if (!memcmp(&rule->filter, &tmp->filter,

drivers/net/ethernet/intel/igc/igc_ethtool.c

1339

sizeof(rule->filter)) &&

drivers/net/ethernet/intel/igc/igc_ethtool.c

980

if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) {

drivers/net/ethernet/intel/igc/igc_ethtool.c

981

fsp->h_u.ether_spec.h_proto = htons(rule->filter.etype);

drivers/net/ethernet/intel/igc/igc_ethtool.c

985

if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_ETYPE) {

drivers/net/ethernet/intel/igc/igc_ethtool.c

987

fsp->h_ext.vlan_etype = htons(rule->filter.vlan_etype);

drivers/net/ethernet/intel/igc/igc_ethtool.c

991

if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) {

drivers/net/ethernet/intel/igc/igc_ethtool.c

993

fsp->h_ext.vlan_tci = htons(rule->filter.vlan_tci);

drivers/net/ethernet/intel/igc/igc_ethtool.c

994

fsp->m_ext.vlan_tci = htons(rule->filter.vlan_tci_mask);

drivers/net/ethernet/intel/igc/igc_ethtool.c

997

if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) {

drivers/net/ethernet/intel/igc/igc_ethtool.c

999

rule->filter.dst_addr);

drivers/net/ethernet/intel/igc/igc_main.c

3775

struct igc_nfc_filter *filter = &rule->filter;

drivers/net/ethernet/intel/igc/igc_main.c

3798

vlan = rule->filter.vlan_tci || rule->filter.vlan_etype;

drivers/net/ethernet/intel/igc/igc_main.c

3803

if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR)

drivers/net/ethernet/intel/igc/igc_main.c

3804

igc_flex_filter_add_field(&flex, &filter->dst_addr, 0,

drivers/net/ethernet/intel/igc/igc_main.c

3808

if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR)

drivers/net/ethernet/intel/igc/igc_main.c

3809

igc_flex_filter_add_field(&flex, &filter->src_addr, 6,

drivers/net/ethernet/intel/igc/igc_main.c

3813

if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_ETYPE) {

drivers/net/ethernet/intel/igc/igc_main.c

3814

__be16 vlan_etype = cpu_to_be16(filter->vlan_etype);

drivers/net/ethernet/intel/igc/igc_main.c

3821

if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI)

drivers/net/ethernet/intel/igc/igc_main.c

3822

igc_flex_filter_add_field(&flex, &filter->vlan_tci, 14,

drivers/net/ethernet/intel/igc/igc_main.c

3823

sizeof(filter->vlan_tci), NULL);

drivers/net/ethernet/intel/igc/igc_main.c

3826

if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) {

drivers/net/ethernet/intel/igc/igc_main.c

3827

__be16 etype = cpu_to_be16(filter->etype);

drivers/net/ethernet/intel/igc/igc_main.c

3834

if (rule->filter.match_flags & IGC_FILTER_FLAG_USER_DATA)

drivers/net/ethernet/intel/igc/igc_main.c

3835

igc_flex_filter_add_field(&flex, &filter->user_data,

drivers/net/ethernet/intel/igc/igc_main.c

3837

sizeof(filter->user_data),

drivers/net/ethernet/intel/igc/igc_main.c

3838

filter->user_mask);

drivers/net/ethernet/intel/igc/igc_main.c

3845

filter->flex_index = index;

drivers/net/ethernet/intel/igc/igc_main.c

3906

if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) {

drivers/net/ethernet/intel/igc/igc_main.c

3907

err = igc_add_etype_filter(adapter, rule->filter.etype,

drivers/net/ethernet/intel/igc/igc_main.c

3913

if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) {

drivers/net/ethernet/intel/igc/igc_main.c

3915

rule->filter.src_addr, rule->action);

drivers/net/ethernet/intel/igc/igc_main.c

3920

if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) {

drivers/net/ethernet/intel/igc/igc_main.c

3922

rule->filter.dst_addr, rule->action);

drivers/net/ethernet/intel/igc/igc_main.c

3927

if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) {

drivers/net/ethernet/intel/igc/igc_main.c

3928

int prio = FIELD_GET(VLAN_PRIO_MASK, rule->filter.vlan_tci);

drivers/net/ethernet/intel/igc/igc_main.c

3935

if (rule->filter.match_flags & IGC_FILTER_FLAG_DEFAULT_QUEUE)

drivers/net/ethernet/intel/igc/igc_main.c

3945

igc_del_flex_filter(adapter, rule->filter.flex_index);

drivers/net/ethernet/intel/igc/igc_main.c

3949

if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE)

drivers/net/ethernet/intel/igc/igc_main.c

3950

igc_del_etype_filter(adapter, rule->filter.etype);

drivers/net/ethernet/intel/igc/igc_main.c

3952

if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) {

drivers/net/ethernet/intel/igc/igc_main.c

3953

int prio = FIELD_GET(VLAN_PRIO_MASK, rule->filter.vlan_tci);

drivers/net/ethernet/intel/igc/igc_main.c

3958

if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR)

drivers/net/ethernet/intel/igc/igc_main.c

3960

rule->filter.src_addr);

drivers/net/ethernet/intel/igc/igc_main.c

3962

if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR)

drivers/net/ethernet/intel/igc/igc_main.c

3964

rule->filter.dst_addr);

drivers/net/ethernet/intel/igc/igc_main.c

3966

if (rule->filter.match_flags & IGC_FILTER_FLAG_DEFAULT_QUEUE)

drivers/net/ethernet/intel/ixgbe/ixgbe.h

895

union ixgbe_atr_input filter;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2689

switch (rule->filter.formatted.flow_type) {

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2709

fsp->h_u.tcp_ip4_spec.psrc = rule->filter.formatted.src_port;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2711

fsp->h_u.tcp_ip4_spec.pdst = rule->filter.formatted.dst_port;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2713

fsp->h_u.tcp_ip4_spec.ip4src = rule->filter.formatted.src_ip[0];

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2715

fsp->h_u.tcp_ip4_spec.ip4dst = rule->filter.formatted.dst_ip[0];

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2717

fsp->h_ext.vlan_tci = rule->filter.formatted.vlan_id;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2719

fsp->h_ext.vlan_etype = rule->filter.formatted.flex_bytes;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2721

fsp->h_ext.data[1] = htonl(rule->filter.formatted.vm_pool);

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2864

if (!input || (rule->filter.formatted.bkt_hash !=

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2865

input->filter.formatted.bkt_hash)) {

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2867

&rule->filter,

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

2995

&input->filter.formatted.flow_type)) {

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3003

if (input->filter.formatted.flow_type == IXGBE_ATR_FLOW_TYPE_IPV4)

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3007

input->filter.formatted.src_ip[0] = fsp->h_u.tcp_ip4_spec.ip4src;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3009

input->filter.formatted.dst_ip[0] = fsp->h_u.tcp_ip4_spec.ip4dst;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3011

input->filter.formatted.src_port = fsp->h_u.tcp_ip4_spec.psrc;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3013

input->filter.formatted.dst_port = fsp->h_u.tcp_ip4_spec.pdst;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3017

input->filter.formatted.vm_pool =

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3021

input->filter.formatted.vlan_id = fsp->h_ext.vlan_tci;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3023

input->filter.formatted.flex_bytes =

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3050

ixgbe_atr_compute_perfect_hash_82599(&input->filter, &mask);

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3054

&input->filter, input->sw_idx, queue);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10155

input->filter.formatted.flow_type |=

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10182

if (input->filter.formatted.flow_type == IXGBE_ATR_FLOW_TYPE_IPV4)

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10360

ixgbe_atr_compute_perfect_hash_82599(&input->filter, mask);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10361

err = ixgbe_fdir_write_perfect_filter_82599(hw, &input->filter,

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5693

struct ixgbe_fdir_filter *filter;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5701

hlist_for_each_entry_safe(filter, node2,

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5703

if (filter->action == IXGBE_FDIR_DROP_QUEUE) {

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5706

u32 ring = ethtool_get_flow_spec_ring(filter->action);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5707

u8 vf = ethtool_get_flow_spec_ring_vf(filter->action);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5730

&filter->filter, filter->sw_idx, queue);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

6673

struct ixgbe_fdir_filter *filter;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

6677

hlist_for_each_entry_safe(filter, node2,

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

6679

hlist_del(&filter->fdir_node);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

6680

kfree(filter);

drivers/net/ethernet/intel/ixgbe/ixgbe_model.h

32

input->filter.formatted.src_ip[0] = (__force __be32)val;

drivers/net/ethernet/intel/ixgbe/ixgbe_model.h

41

input->filter.formatted.dst_ip[0] = (__force __be32)val;

drivers/net/ethernet/intel/ixgbe/ixgbe_model.h

58

input->filter.formatted.src_port = (__force __be16)(val & 0xffff);

drivers/net/ethernet/intel/ixgbe/ixgbe_model.h

60

input->filter.formatted.dst_port = (__force __be16)(val >> 16);

drivers/net/ethernet/marvell/octeontx2/af/cgx.c

1708

int err, filter;

drivers/net/ethernet/marvell/octeontx2/af/cgx.c

1782

for (filter = 0; filter < max_dmac_filters; filter++)

drivers/net/ethernet/marvell/octeontx2/af/cgx.c

1783

cgx_lmac_addr_del(cgx->cgx_id, lmac->lmac_id, filter);

drivers/net/ethernet/marvell/skge.c

2923

static void genesis_add_filter(u8 filter[8], const u8 *addr)

drivers/net/ethernet/marvell/skge.c

2929

filter[bit/8] |= 1 << (bit%8);

drivers/net/ethernet/marvell/skge.c

2939

u8 filter[8];

drivers/net/ethernet/marvell/skge.c

2949

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

drivers/net/ethernet/marvell/skge.c

2951

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

drivers/net/ethernet/marvell/skge.c

2955

genesis_add_filter(filter, pause_mc_addr);

drivers/net/ethernet/marvell/skge.c

2958

genesis_add_filter(filter, ha->addr);

drivers/net/ethernet/marvell/skge.c

2962

xm_outhash(hw, port, XM_HSM, filter);

drivers/net/ethernet/marvell/skge.c

2965

static void yukon_add_filter(u8 filter[8], const u8 *addr)

drivers/net/ethernet/marvell/skge.c

2969

filter[bit / 8] |= 1 << (bit % 8);

drivers/net/ethernet/marvell/skge.c

2981

u8 filter[8];

drivers/net/ethernet/marvell/skge.c

2983

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

drivers/net/ethernet/marvell/skge.c

2991

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

drivers/net/ethernet/marvell/skge.c

2998

yukon_add_filter(filter, pause_mc_addr);

drivers/net/ethernet/marvell/skge.c

3001

yukon_add_filter(filter, ha->addr);

drivers/net/ethernet/marvell/skge.c

3006

(u16)filter[0] | ((u16)filter[1] << 8));

drivers/net/ethernet/marvell/skge.c

3008

(u16)filter[2] | ((u16)filter[3] << 8));

drivers/net/ethernet/marvell/skge.c

3010

(u16)filter[4] | ((u16)filter[5] << 8));

drivers/net/ethernet/marvell/skge.c

3012

(u16)filter[6] | ((u16)filter[7] << 8));

drivers/net/ethernet/marvell/sky2.c

3832

static inline void sky2_add_filter(u8 filter[8], const u8 *addr)

drivers/net/ethernet/marvell/sky2.c

3837

filter[bit >> 3] |= 1 << (bit & 7);

drivers/net/ethernet/marvell/sky2.c

3847

u8 filter[8];

drivers/net/ethernet/marvell/sky2.c

3852

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

drivers/net/ethernet/marvell/sky2.c

3860

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

drivers/net/ethernet/marvell/sky2.c

3867

sky2_add_filter(filter, pause_mc_addr);

drivers/net/ethernet/marvell/sky2.c

3870

sky2_add_filter(filter, ha->addr);

drivers/net/ethernet/marvell/sky2.c

3874

(u16) filter[0] | ((u16) filter[1] << 8));

drivers/net/ethernet/marvell/sky2.c

3876

(u16) filter[2] | ((u16) filter[3] << 8));

drivers/net/ethernet/marvell/sky2.c

3878

(u16) filter[4] | ((u16) filter[5] << 8));

drivers/net/ethernet/marvell/sky2.c

3880

(u16) filter[6] | ((u16) filter[7] << 8));

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

203

struct mlx4_en_filter *filter = container_of(work,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

206

struct mlx4_en_priv *priv = filter->priv;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

208

.id = mlx4_ip_proto_to_trans_rule_id(filter->ip_proto),

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

211

.dst_port = filter->dst_port,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

213

.src_port = filter->src_port,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

222

.dst_ip = filter->dst_ip,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

224

.src_ip = filter->src_ip,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

246

filter->ip_proto);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

253

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

257

filter->activated = 0;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

259

if (filter->reg_id) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

260

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

265

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

272

filter->activated = 1;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

296

struct mlx4_en_filter *filter;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

298

filter = kzalloc_obj(struct mlx4_en_filter, GFP_ATOMIC);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

299

if (!filter)

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

302

filter->priv = priv;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

303

filter->rxq_index = rxq_index;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

304

INIT_WORK(&filter->work, mlx4_en_filter_work);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

306

filter->src_ip = src_ip;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

307

filter->dst_ip = dst_ip;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

308

filter->ip_proto = ip_proto;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

309

filter->src_port = src_port;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

310

filter->dst_port = dst_port;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

312

filter->flow_id = flow_id;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

314

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

316

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

317

hlist_add_head(&filter->filter_chain,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

321

return filter;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

324

static void mlx4_en_filter_free(struct mlx4_en_filter *filter)

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

326

struct mlx4_en_priv *priv = filter->priv;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

329

list_del(&filter->next);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

331

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

335

kfree(filter);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

342

struct mlx4_en_filter *filter;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

345

hlist_for_each_entry(filter,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

349

if (filter->src_ip == src_ip &&

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

350

filter->dst_ip == dst_ip &&

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

351

filter->ip_proto == ip_proto &&

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

352

filter->src_port == src_port &&

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

353

filter->dst_port == dst_port) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

354

ret = filter;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

367

struct mlx4_en_filter *filter;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

399

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

401

if (filter) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

402

if (filter->rxq_index == rxq_index)

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

405

filter->rxq_index = rxq_index;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

407

filter = mlx4_en_filter_alloc(priv, rxq_index,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

410

if (!filter) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

416

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

419

ret = filter->id;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

428

struct mlx4_en_filter *filter, *tmp;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

432

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

433

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

434

hlist_del(&filter->filter_chain);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

438

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

439

cancel_work_sync(&filter->work);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

440

mlx4_en_filter_free(filter);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

446

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

451

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

455

if (filter->activated &&

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

456

!work_pending(&filter->work) &&

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

458

filter->rxq_index, filter->flow_id,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

459

filter->id)) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

460

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

461

hlist_del(&filter->filter_chain);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

463

last_filter = filter;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

473

list_for_each_entry_safe(filter, tmp, &del_list, next)

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

474

mlx4_en_filter_free(filter);

drivers/net/ethernet/mellanox/mlx4/en_port.c

47

struct mlx4_set_vlan_fltr_mbox *filter;

drivers/net/ethernet/mellanox/mlx4/en_port.c

58

filter = mailbox->buf;

drivers/net/ethernet/mellanox/mlx4/en_port.c

64

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

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c

4776

static bool is_tc_ipsec_order_check_needed(struct net_device *filter, struct mlx5e_priv *priv)

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c

4781

if (filter != priv->netdev)

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c

4790

static int mlx5e_tc_block_ipsec_offload(struct net_device *filter, struct mlx5e_priv *priv)

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c

4794

if (!is_tc_ipsec_order_check_needed(filter, priv))

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c

4805

static void mlx5e_tc_unblock_ipsec_offload(struct net_device *filter, struct mlx5e_priv *priv)

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c

4807

if (!is_tc_ipsec_order_check_needed(filter, priv))

drivers/net/ethernet/mellanox/mlx5/core/eswitch.h

733

#define mlx5_esw_for_each_entry_marked(xa, index, entry, last, filter) \

drivers/net/ethernet/mellanox/mlx5/core/eswitch.h

734

for (index = 0, entry = xa_find(xa, &index, last, filter); \

drivers/net/ethernet/mellanox/mlx5/core/eswitch.h

735

entry; entry = xa_find_after(xa, &index, last, filter))

drivers/net/ethernet/mellanox/mlx5/core/eswitch.h

737

#define mlx5_esw_for_each_vport_marked(esw, index, vport, last, filter) \

drivers/net/ethernet/mellanox/mlx5/core/eswitch.h

738

mlx5_esw_for_each_entry_marked(&((esw)->vports), index, vport, last, filter)

drivers/net/ethernet/mscc/ocelot.c

522

struct ocelot_vcap_filter *filter;

drivers/net/ethernet/mscc/ocelot.c

530

filter = ocelot_vcap_block_find_filter_by_id(block_vcap_is1, cookie,

drivers/net/ethernet/mscc/ocelot.c

537

if (filter)

drivers/net/ethernet/mscc/ocelot.c

538

return ocelot_vcap_filter_del(ocelot, filter);

drivers/net/ethernet/mscc/ocelot.c

555

if (filter) {

drivers/net/ethernet/mscc/ocelot.c

559

if (filter->action.vid != vid) {

drivers/net/ethernet/mscc/ocelot.c

560

filter->action.vid = vid;

drivers/net/ethernet/mscc/ocelot.c

563

if (filter->action.pcp != pcp) {

drivers/net/ethernet/mscc/ocelot.c

564

filter->action.pcp = pcp;

drivers/net/ethernet/mscc/ocelot.c

567

if (filter->action.dei != dei) {

drivers/net/ethernet/mscc/ocelot.c

568

filter->action.dei = dei;

drivers/net/ethernet/mscc/ocelot.c

575

return ocelot_vcap_filter_replace(ocelot, filter);

drivers/net/ethernet/mscc/ocelot.c

579

filter = kzalloc_obj(*filter);

drivers/net/ethernet/mscc/ocelot.c

580

if (!filter)

drivers/net/ethernet/mscc/ocelot.c

583

filter->key_type = OCELOT_VCAP_KEY_ANY;

drivers/net/ethernet/mscc/ocelot.c

584

filter->ingress_port_mask = BIT(port);

drivers/net/ethernet/mscc/ocelot.c

585

filter->vlan.tpid = OCELOT_VCAP_BIT_1;

drivers/net/ethernet/mscc/ocelot.c

586

filter->prio = 1;

drivers/net/ethernet/mscc/ocelot.c

587

filter->id.cookie = cookie;

drivers/net/ethernet/mscc/ocelot.c

588

filter->id.tc_offload = false;

drivers/net/ethernet/mscc/ocelot.c

589

filter->block_id = VCAP_IS1;

drivers/net/ethernet/mscc/ocelot.c

590

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot.c

591

filter->lookup = 0;

drivers/net/ethernet/mscc/ocelot.c

592

filter->action.vid_replace_ena = true;

drivers/net/ethernet/mscc/ocelot.c

593

filter->action.pcp_dei_ena = true;

drivers/net/ethernet/mscc/ocelot.c

594

filter->action.vid = vid;

drivers/net/ethernet/mscc/ocelot.c

595

filter->action.pcp = pcp;

drivers/net/ethernet/mscc/ocelot.c

596

filter->action.dei = dei;

drivers/net/ethernet/mscc/ocelot.c

598

err = ocelot_vcap_filter_add(ocelot, filter, NULL);

drivers/net/ethernet/mscc/ocelot.c

600

kfree(filter);

drivers/net/ethernet/mscc/ocelot.c

753

struct ocelot_vcap_filter *filter;

drivers/net/ethernet/mscc/ocelot.c

757

list_for_each_entry(filter, &block->rules, list) {

drivers/net/ethernet/mscc/ocelot.c

758

if (filter->ingress_port_mask & BIT(port) &&

drivers/net/ethernet/mscc/ocelot.c

759

filter->action.vid_replace_ena) {

drivers/net/ethernet/mscc/ocelot_flower.c

1004

struct ocelot_vcap_filter *filter;

drivers/net/ethernet/mscc/ocelot_flower.c

1027

filter = ocelot_vcap_block_find_filter_by_id(block, f->cookie, true);

drivers/net/ethernet/mscc/ocelot_flower.c

1028

if (!filter || filter->type == OCELOT_VCAP_FILTER_DUMMY)

drivers/net/ethernet/mscc/ocelot_flower.c

1031

ret = ocelot_vcap_filter_stats_update(ocelot, filter);

drivers/net/ethernet/mscc/ocelot_flower.c

1035

stats.pkts = filter->stats.pkts;

drivers/net/ethernet/mscc/ocelot_flower.c

147

struct ocelot_vcap_filter *filter;

drivers/net/ethernet/mscc/ocelot_flower.c

158

list_for_each_entry(filter, &block->rules, list)

drivers/net/ethernet/mscc/ocelot_flower.c

159

if (filter->type == OCELOT_VCAP_FILTER_PAG &&

drivers/net/ethernet/mscc/ocelot_flower.c

160

filter->goto_target == chain)

drivers/net/ethernet/mscc/ocelot_flower.c

161

return filter;

drivers/net/ethernet/mscc/ocelot_flower.c

164

list_for_each_entry(filter, &ocelot->dummy_rules, list)

drivers/net/ethernet/mscc/ocelot_flower.c

165

if (filter->goto_target == chain)

drivers/net/ethernet/mscc/ocelot_flower.c

166

return filter;

drivers/net/ethernet/mscc/ocelot_flower.c

173

struct ocelot_vcap_filter *filter,

drivers/net/ethernet/mscc/ocelot_flower.c

179

if (filter->goto_target != -1) {

drivers/net/ethernet/mscc/ocelot_flower.c

191

filter->action.vid_replace_ena = true;

drivers/net/ethernet/mscc/ocelot_flower.c

192

filter->action.pcp_dei_ena = true;

drivers/net/ethernet/mscc/ocelot_flower.c

193

filter->action.vid = a->vlan.vid;

drivers/net/ethernet/mscc/ocelot_flower.c

194

filter->action.pcp = a->vlan.prio;

drivers/net/ethernet/mscc/ocelot_flower.c

195

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

201

ocelot_flower_parse_egress_vlan_modify(struct ocelot_vcap_filter *filter,

drivers/net/ethernet/mscc/ocelot_flower.c

220

filter->action.tag_a_tpid_sel = tpid;

drivers/net/ethernet/mscc/ocelot_flower.c

221

filter->action.push_outer_tag = OCELOT_ES0_TAG;

drivers/net/ethernet/mscc/ocelot_flower.c

222

filter->action.tag_a_vid_sel = OCELOT_ES0_VID_PLUS_CLASSIFIED_VID;

drivers/net/ethernet/mscc/ocelot_flower.c

223

filter->action.vid_a_val = a->vlan.vid;

drivers/net/ethernet/mscc/ocelot_flower.c

224

filter->action.pcp_a_val = a->vlan.prio;

drivers/net/ethernet/mscc/ocelot_flower.c

225

filter->action.tag_a_pcp_sel = OCELOT_ES0_PCP;

drivers/net/ethernet/mscc/ocelot_flower.c

226

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

259

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_flower.c

276

filter->block_id = ocelot_chain_to_block(chain, ingress);

drivers/net/ethernet/mscc/ocelot_flower.c

277

if (filter->block_id < 0) {

drivers/net/ethernet/mscc/ocelot_flower.c

281

if (filter->block_id == VCAP_IS1 || filter->block_id == VCAP_IS2)

drivers/net/ethernet/mscc/ocelot_flower.c

282

filter->lookup = ocelot_chain_to_lookup(chain);

drivers/net/ethernet/mscc/ocelot_flower.c

283

if (filter->block_id == VCAP_IS2)

drivers/net/ethernet/mscc/ocelot_flower.c

284

filter->pag = ocelot_chain_to_pag(chain);

drivers/net/ethernet/mscc/ocelot_flower.c

286

filter->goto_target = -1;

drivers/net/ethernet/mscc/ocelot_flower.c

287

filter->type = OCELOT_VCAP_FILTER_DUMMY;

drivers/net/ethernet/mscc/ocelot_flower.c

292

if (filter->block_id != VCAP_IS2) {

drivers/net/ethernet/mscc/ocelot_flower.c

297

if (filter->goto_target != -1) {

drivers/net/ethernet/mscc/ocelot_flower.c

302

filter->action.mask_mode = OCELOT_MASK_MODE_PERMIT_DENY;

drivers/net/ethernet/mscc/ocelot_flower.c

303

filter->action.port_mask = 0;

drivers/net/ethernet/mscc/ocelot_flower.c

304

filter->action.police_ena = true;

drivers/net/ethernet/mscc/ocelot_flower.c

305

filter->action.pol_ix = OCELOT_POLICER_DISCARD;

drivers/net/ethernet/mscc/ocelot_flower.c

306

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

309

if (filter->block_id != VCAP_ES0 &&

drivers/net/ethernet/mscc/ocelot_flower.c

310

filter->block_id != VCAP_IS1 &&

drivers/net/ethernet/mscc/ocelot_flower.c

311

filter->block_id != VCAP_IS2) {

drivers/net/ethernet/mscc/ocelot_flower.c

316

if (filter->block_id != VCAP_ES0 &&

drivers/net/ethernet/mscc/ocelot_flower.c

317

filter->goto_target != -1) {

drivers/net/ethernet/mscc/ocelot_flower.c

322

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

325

if (filter->block_id != VCAP_IS2 ||

drivers/net/ethernet/mscc/ocelot_flower.c

326

filter->lookup != 0) {

drivers/net/ethernet/mscc/ocelot_flower.c

331

if (filter->goto_target != -1) {

drivers/net/ethernet/mscc/ocelot_flower.c

336

filter->action.mask_mode = OCELOT_MASK_MODE_PERMIT_DENY;

drivers/net/ethernet/mscc/ocelot_flower.c

337

filter->action.port_mask = 0;

drivers/net/ethernet/mscc/ocelot_flower.c

338

filter->action.cpu_copy_ena = true;

drivers/net/ethernet/mscc/ocelot_flower.c

339

filter->action.cpu_qu_num = 0;

drivers/net/ethernet/mscc/ocelot_flower.c

340

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

341

filter->is_trap = true;

drivers/net/ethernet/mscc/ocelot_flower.c

344

if (filter->block_id == PSFP_BLOCK_ID) {

drivers/net/ethernet/mscc/ocelot_flower.c

345

filter->type = OCELOT_PSFP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

348

if (filter->block_id != VCAP_IS2 ||

drivers/net/ethernet/mscc/ocelot_flower.c

349

filter->lookup != 0) {

drivers/net/ethernet/mscc/ocelot_flower.c

354

if (filter->goto_target != -1) {

drivers/net/ethernet/mscc/ocelot_flower.c

364

filter->action.police_ena = true;

drivers/net/ethernet/mscc/ocelot_flower.c

377

filter->action.pol_ix = pol_ix;

drivers/net/ethernet/mscc/ocelot_flower.c

380

filter->action.pol.rate = div_u64(rate, 1000) * 8;

drivers/net/ethernet/mscc/ocelot_flower.c

381

filter->action.pol.burst = a->police.burst;

drivers/net/ethernet/mscc/ocelot_flower.c

382

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

386

if (filter->block_id != VCAP_IS2) {

drivers/net/ethernet/mscc/ocelot_flower.c

391

if (filter->goto_target != -1) {

drivers/net/ethernet/mscc/ocelot_flower.c

403

filter->action.mask_mode = OCELOT_MASK_MODE_REDIRECT;

drivers/net/ethernet/mscc/ocelot_flower.c

404

filter->action.port_mask = BIT(egress_port);

drivers/net/ethernet/mscc/ocelot_flower.c

405

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

409

if (filter->block_id != VCAP_IS2) {

drivers/net/ethernet/mscc/ocelot_flower.c

414

if (filter->goto_target != -1) {

drivers/net/ethernet/mscc/ocelot_flower.c

426

filter->egress_port.value = egress_port;

drivers/net/ethernet/mscc/ocelot_flower.c

427

filter->action.mirror_ena = true;

drivers/net/ethernet/mscc/ocelot_flower.c

428

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

431

if (filter->block_id != VCAP_IS1) {

drivers/net/ethernet/mscc/ocelot_flower.c

436

if (filter->goto_target != -1) {

drivers/net/ethernet/mscc/ocelot_flower.c

441

filter->action.vlan_pop_cnt_ena = true;

drivers/net/ethernet/mscc/ocelot_flower.c

442

filter->action.vlan_pop_cnt++;

drivers/net/ethernet/mscc/ocelot_flower.c

443

if (filter->action.vlan_pop_cnt > 2) {

drivers/net/ethernet/mscc/ocelot_flower.c

448

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

451

if (filter->block_id == VCAP_IS1) {

drivers/net/ethernet/mscc/ocelot_flower.c

453

filter, a,

drivers/net/ethernet/mscc/ocelot_flower.c

455

} else if (filter->block_id == VCAP_ES0) {

drivers/net/ethernet/mscc/ocelot_flower.c

456

err = ocelot_flower_parse_egress_vlan_modify(filter, a,

drivers/net/ethernet/mscc/ocelot_flower.c

467

if (filter->block_id != VCAP_IS1) {

drivers/net/ethernet/mscc/ocelot_flower.c

472

if (filter->goto_target != -1) {

drivers/net/ethernet/mscc/ocelot_flower.c

477

filter->action.qos_ena = true;

drivers/net/ethernet/mscc/ocelot_flower.c

478

filter->action.qos_val = a->priority;

drivers/net/ethernet/mscc/ocelot_flower.c

479

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

482

filter->goto_target = a->chain_index;

drivers/net/ethernet/mscc/ocelot_flower.c

484

if (filter->block_id == VCAP_IS1 && filter->lookup == 2) {

drivers/net/ethernet/mscc/ocelot_flower.c

485

int pag = ocelot_chain_to_pag(filter->goto_target);

drivers/net/ethernet/mscc/ocelot_flower.c

487

filter->action.pag_override_mask = 0xff;

drivers/net/ethernet/mscc/ocelot_flower.c

488

filter->action.pag_val = pag;

drivers/net/ethernet/mscc/ocelot_flower.c

489

filter->type = OCELOT_VCAP_FILTER_PAG;

drivers/net/ethernet/mscc/ocelot_flower.c

493

if (filter->block_id != VCAP_ES0) {

drivers/net/ethernet/mscc/ocelot_flower.c

510

filter->action.tag_a_tpid_sel = tpid;

drivers/net/ethernet/mscc/ocelot_flower.c

511

filter->action.push_outer_tag = OCELOT_ES0_TAG;

drivers/net/ethernet/mscc/ocelot_flower.c

512

filter->action.tag_a_vid_sel = OCELOT_ES0_VID;

drivers/net/ethernet/mscc/ocelot_flower.c

513

filter->action.vid_a_val = a->vlan.vid;

drivers/net/ethernet/mscc/ocelot_flower.c

514

filter->action.pcp_a_val = a->vlan.prio;

drivers/net/ethernet/mscc/ocelot_flower.c

515

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

518

if (filter->block_id != PSFP_BLOCK_ID) {

drivers/net/ethernet/mscc/ocelot_flower.c

523

filter->type = OCELOT_PSFP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_flower.c

531

if (filter->goto_target == -1) {

drivers/net/ethernet/mscc/ocelot_flower.c

532

if ((filter->block_id == VCAP_IS2 && filter->lookup == 1) ||

drivers/net/ethernet/mscc/ocelot_flower.c

533

chain == 0 || filter->block_id == PSFP_BLOCK_ID) {

drivers/net/ethernet/mscc/ocelot_flower.c

541

if (!ocelot_is_goto_target_valid(filter->goto_target, chain, ingress) &&

drivers/net/ethernet/mscc/ocelot_flower.c

552

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_flower.c

595

filter->ingress_port.value = ingress_port;

drivers/net/ethernet/mscc/ocelot_flower.c

596

filter->ingress_port.mask = GENMASK(key_length - 1, 0);

drivers/net/ethernet/mscc/ocelot_flower.c

604

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_flower.c

637

ret = ocelot_flower_parse_indev(ocelot, port, f, filter);

drivers/net/ethernet/mscc/ocelot_flower.c

649

filter->key_type = OCELOT_VCAP_KEY_ANY;

drivers/net/ethernet/mscc/ocelot_flower.c

650

filter->vlan.vid.value = match.key->vlan_id;

drivers/net/ethernet/mscc/ocelot_flower.c

651

filter->vlan.vid.mask = match.mask->vlan_id;

drivers/net/ethernet/mscc/ocelot_flower.c

652

filter->vlan.pcp.value[0] = match.key->vlan_priority;

drivers/net/ethernet/mscc/ocelot_flower.c

653

filter->vlan.pcp.mask[0] = match.mask->vlan_priority;

drivers/net/ethernet/mscc/ocelot_flower.c

660

if (filter->block_id == VCAP_ES0) {

drivers/net/ethernet/mscc/ocelot_flower.c

681

if (filter->block_id == VCAP_IS1 &&

drivers/net/ethernet/mscc/ocelot_flower.c

688

filter->key_type = OCELOT_VCAP_KEY_ETYPE;

drivers/net/ethernet/mscc/ocelot_flower.c

689

ether_addr_copy(filter->key.etype.dmac.value,

drivers/net/ethernet/mscc/ocelot_flower.c

691

ether_addr_copy(filter->key.etype.smac.value,

drivers/net/ethernet/mscc/ocelot_flower.c

693

ether_addr_copy(filter->key.etype.dmac.mask,

drivers/net/ethernet/mscc/ocelot_flower.c

695

ether_addr_copy(filter->key.etype.smac.mask,

drivers/net/ethernet/mscc/ocelot_flower.c

705

if (filter->block_id == VCAP_ES0) {

drivers/net/ethernet/mscc/ocelot_flower.c

711

filter->key_type = OCELOT_VCAP_KEY_IPV4;

drivers/net/ethernet/mscc/ocelot_flower.c

712

filter->key.ipv4.proto.value[0] =

drivers/net/ethernet/mscc/ocelot_flower.c

714

filter->key.ipv4.proto.mask[0] =

drivers/net/ethernet/mscc/ocelot_flower.c

719

if (filter->block_id == VCAP_ES0) {

drivers/net/ethernet/mscc/ocelot_flower.c

725

filter->key_type = OCELOT_VCAP_KEY_IPV6;

drivers/net/ethernet/mscc/ocelot_flower.c

726

filter->key.ipv6.proto.value[0] =

drivers/net/ethernet/mscc/ocelot_flower.c

728

filter->key.ipv6.proto.mask[0] =

drivers/net/ethernet/mscc/ocelot_flower.c

739

if (filter->block_id == VCAP_ES0) {

drivers/net/ethernet/mscc/ocelot_flower.c

747

if (filter->block_id == VCAP_IS1 && *(u32 *)&match.mask->dst) {

drivers/net/ethernet/mscc/ocelot_flower.c

753

tmp = &filter->key.ipv4.sip.value.addr[0];

drivers/net/ethernet/mscc/ocelot_flower.c

756

tmp = &filter->key.ipv4.sip.mask.addr[0];

drivers/net/ethernet/mscc/ocelot_flower.c

759

tmp = &filter->key.ipv4.dip.value.addr[0];

drivers/net/ethernet/mscc/ocelot_flower.c

762

tmp = &filter->key.ipv4.dip.mask.addr[0];

drivers/net/ethernet/mscc/ocelot_flower.c

775

if (filter->block_id == VCAP_ES0) {

drivers/net/ethernet/mscc/ocelot_flower.c

782

filter->key.ipv4.sport.value = ntohs(match.key->src);

drivers/net/ethernet/mscc/ocelot_flower.c

783

filter->key.ipv4.sport.mask = ntohs(match.mask->src);

drivers/net/ethernet/mscc/ocelot_flower.c

784

filter->key.ipv4.dport.value = ntohs(match.key->dst);

drivers/net/ethernet/mscc/ocelot_flower.c

785

filter->key.ipv4.dport.mask = ntohs(match.mask->dst);

drivers/net/ethernet/mscc/ocelot_flower.c

791

if (filter->block_id == VCAP_ES0) {

drivers/net/ethernet/mscc/ocelot_flower.c

800

filter->key_type = OCELOT_VCAP_KEY_ETYPE;

drivers/net/ethernet/mscc/ocelot_flower.c

801

*(__be16 *)filter->key.etype.etype.value = htons(proto);

drivers/net/ethernet/mscc/ocelot_flower.c

802

*(__be16 *)filter->key.etype.etype.mask = htons(0xffff);

drivers/net/ethernet/mscc/ocelot_flower.c

811

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_flower.c

815

filter->prio = f->common.prio;

drivers/net/ethernet/mscc/ocelot_flower.c

816

filter->id.cookie = f->cookie;

drivers/net/ethernet/mscc/ocelot_flower.c

817

filter->id.tc_offload = true;

drivers/net/ethernet/mscc/ocelot_flower.c

819

ret = ocelot_flower_parse_action(ocelot, port, ingress, f, filter);

drivers/net/ethernet/mscc/ocelot_flower.c

824

if (filter->type == OCELOT_PSFP_FILTER_OFFLOAD)

drivers/net/ethernet/mscc/ocelot_flower.c

827

return ocelot_flower_parse_key(ocelot, port, ingress, f, filter);

drivers/net/ethernet/mscc/ocelot_flower.c

834

struct ocelot_vcap_filter *filter;

drivers/net/ethernet/mscc/ocelot_flower.c

836

filter = kzalloc_obj(*filter);

drivers/net/ethernet/mscc/ocelot_flower.c

837

if (!filter)

drivers/net/ethernet/mscc/ocelot_flower.c

841

filter->ingress_port_mask = BIT(port);

drivers/net/ethernet/mscc/ocelot_flower.c

846

filter->egress_port.value = port;

drivers/net/ethernet/mscc/ocelot_flower.c

847

filter->egress_port.mask = GENMASK(key_length - 1, 0);

drivers/net/ethernet/mscc/ocelot_flower.c

850

return filter;

drivers/net/ethernet/mscc/ocelot_flower.c

854

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_flower.c

856

list_add(&filter->list, &ocelot->dummy_rules);

drivers/net/ethernet/mscc/ocelot_flower.c

862

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_flower.c

864

list_del(&filter->list);

drivers/net/ethernet/mscc/ocelot_flower.c

865

kfree(filter);

drivers/net/ethernet/mscc/ocelot_flower.c

876

ocelot_flower_patch_es0_vlan_modify(struct ocelot_vcap_filter *filter,

drivers/net/ethernet/mscc/ocelot_flower.c

879

if (filter->block_id != VCAP_ES0 ||

drivers/net/ethernet/mscc/ocelot_flower.c

880

filter->action.tag_a_vid_sel != OCELOT_ES0_VID_PLUS_CLASSIFIED_VID)

drivers/net/ethernet/mscc/ocelot_flower.c

883

if (filter->vlan.vid.mask != VLAN_VID_MASK) {

drivers/net/ethernet/mscc/ocelot_flower.c

889

filter->action.vid_a_val -= filter->vlan.vid.value;

drivers/net/ethernet/mscc/ocelot_flower.c

890

filter->action.vid_a_val &= VLAN_VID_MASK;

drivers/net/ethernet/mscc/ocelot_flower.c

899

struct ocelot_vcap_filter *filter;

drivers/net/ethernet/mscc/ocelot_flower.c

914

filter = ocelot_vcap_block_find_filter_by_id(&ocelot->block[block_id],

drivers/net/ethernet/mscc/ocelot_flower.c

916

if (filter) {

drivers/net/ethernet/mscc/ocelot_flower.c

923

filter->ingress_port_mask |= BIT(port);

drivers/net/ethernet/mscc/ocelot_flower.c

925

return ocelot_vcap_filter_replace(ocelot, filter);

drivers/net/ethernet/mscc/ocelot_flower.c

929

filter = ocelot_vcap_filter_create(ocelot, port, ingress, f);

drivers/net/ethernet/mscc/ocelot_flower.c

930

if (!filter)

drivers/net/ethernet/mscc/ocelot_flower.c

933

ret = ocelot_flower_parse(ocelot, port, ingress, f, filter);

drivers/net/ethernet/mscc/ocelot_flower.c

935

kfree(filter);

drivers/net/ethernet/mscc/ocelot_flower.c

939

ret = ocelot_flower_patch_es0_vlan_modify(filter, extack);

drivers/net/ethernet/mscc/ocelot_flower.c

941

kfree(filter);

drivers/net/ethernet/mscc/ocelot_flower.c

948

if (filter->type == OCELOT_VCAP_FILTER_DUMMY)

drivers/net/ethernet/mscc/ocelot_flower.c

949

return ocelot_vcap_dummy_filter_add(ocelot, filter);

drivers/net/ethernet/mscc/ocelot_flower.c

951

if (filter->type == OCELOT_PSFP_FILTER_OFFLOAD) {

drivers/net/ethernet/mscc/ocelot_flower.c

952

kfree(filter);

drivers/net/ethernet/mscc/ocelot_flower.c

960

return ocelot_vcap_filter_add(ocelot, filter, f->common.extack);

drivers/net/ethernet/mscc/ocelot_flower.c

967

struct ocelot_vcap_filter *filter;

drivers/net/ethernet/mscc/ocelot_flower.c

984

filter = ocelot_vcap_block_find_filter_by_id(block, f->cookie, true);

drivers/net/ethernet/mscc/ocelot_flower.c

985

if (!filter)

drivers/net/ethernet/mscc/ocelot_flower.c

988

if (filter->type == OCELOT_VCAP_FILTER_DUMMY)

drivers/net/ethernet/mscc/ocelot_flower.c

989

return ocelot_vcap_dummy_filter_del(ocelot, filter);

drivers/net/ethernet/mscc/ocelot_flower.c

992

filter->ingress_port_mask &= ~BIT(port);

drivers/net/ethernet/mscc/ocelot_flower.c

993

if (filter->ingress_port_mask)

drivers/net/ethernet/mscc/ocelot_flower.c

994

return ocelot_vcap_filter_replace(ocelot, filter);

drivers/net/ethernet/mscc/ocelot_flower.c

997

return ocelot_vcap_filter_del(ocelot, filter);

drivers/net/ethernet/mscc/ocelot_mrp.c

39

struct ocelot_vcap_filter *filter;

drivers/net/ethernet/mscc/ocelot_mrp.c

42

filter = ocelot_vcap_block_find_filter_by_id(block_vcap_is2, id,

drivers/net/ethernet/mscc/ocelot_mrp.c

44

if (!filter)

drivers/net/ethernet/mscc/ocelot_mrp.c

47

return ocelot_vcap_filter_del(ocelot, filter);

drivers/net/ethernet/mscc/ocelot_mrp.c

54

struct ocelot_vcap_filter *filter;

drivers/net/ethernet/mscc/ocelot_mrp.c

57

filter = kzalloc_obj(*filter);

drivers/net/ethernet/mscc/ocelot_mrp.c

58

if (!filter)

drivers/net/ethernet/mscc/ocelot_mrp.c

61

filter->key_type = OCELOT_VCAP_KEY_ETYPE;

drivers/net/ethernet/mscc/ocelot_mrp.c

62

filter->prio = 1;

drivers/net/ethernet/mscc/ocelot_mrp.c

63

filter->id.cookie = OCELOT_VCAP_IS2_MRP_REDIRECT(ocelot, src_port);

drivers/net/ethernet/mscc/ocelot_mrp.c

64

filter->id.tc_offload = false;

drivers/net/ethernet/mscc/ocelot_mrp.c

65

filter->block_id = VCAP_IS2;

drivers/net/ethernet/mscc/ocelot_mrp.c

66

filter->type = OCELOT_VCAP_FILTER_OFFLOAD;

drivers/net/ethernet/mscc/ocelot_mrp.c

67

filter->ingress_port_mask = BIT(src_port);

drivers/net/ethernet/mscc/ocelot_mrp.c

68

ether_addr_copy(filter->key.etype.dmac.value, mrp_test_dmac);

drivers/net/ethernet/mscc/ocelot_mrp.c

69

ether_addr_copy(filter->key.etype.dmac.mask, mrp_test_mask);

drivers/net/ethernet/mscc/ocelot_mrp.c

70

filter->action.mask_mode = OCELOT_MASK_MODE_REDIRECT;

drivers/net/ethernet/mscc/ocelot_mrp.c

71

filter->action.port_mask = BIT(dst_port);

drivers/net/ethernet/mscc/ocelot_mrp.c

73

err = ocelot_vcap_filter_add(ocelot, filter, NULL);

drivers/net/ethernet/mscc/ocelot_mrp.c

75

kfree(filter);

drivers/net/ethernet/mscc/ocelot_mrp.c

80

static void ocelot_populate_mrp_trap_key(struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_mrp.c

87

ether_addr_copy(filter->key.etype.dmac.value, mrp_test_dmac);

drivers/net/ethernet/mscc/ocelot_mrp.c

88

ether_addr_copy(filter->key.etype.dmac.mask, mrp_mask);

drivers/net/ethernet/mscc/ocelot_vcap.c

1000

ret = ocelot_vcap_filter_add_aux_resources(ocelot, filter, extack);

drivers/net/ethernet/mscc/ocelot_vcap.c

1007

if (filter->prio < tmp->prio) {

drivers/net/ethernet/mscc/ocelot_vcap.c

1012

list_add_tail(&filter->list, pos);

drivers/net/ethernet/mscc/ocelot_vcap.c

1024

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

1030

if (ocelot_vcap_filter_equal(filter, tmp))

drivers/net/ethernet/mscc/ocelot_vcap.c

1058

struct ocelot_vcap_filter *filter;

drivers/net/ethernet/mscc/ocelot_vcap.c

1060

list_for_each_entry(filter, &block->rules, list)

drivers/net/ethernet/mscc/ocelot_vcap.c

1061

if (filter->id.tc_offload == tc_offload &&

drivers/net/ethernet/mscc/ocelot_vcap.c

1062

filter->id.cookie == cookie)

drivers/net/ethernet/mscc/ocelot_vcap.c

1063

return filter;

drivers/net/ethernet/mscc/ocelot_vcap.c

1101

ocelot_vcap_is_problematic_mac_etype(struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

1105

if (filter->key_type != OCELOT_VCAP_KEY_ETYPE)

drivers/net/ethernet/mscc/ocelot_vcap.c

1108

proto = ntohs(*(__be16 *)filter->key.etype.etype.value);

drivers/net/ethernet/mscc/ocelot_vcap.c

1109

mask = ntohs(*(__be16 *)filter->key.etype.etype.mask);

drivers/net/ethernet/mscc/ocelot_vcap.c

1125

ocelot_vcap_is_problematic_non_mac_etype(struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

1127

if (filter->key_type == OCELOT_VCAP_KEY_SNAP)

drivers/net/ethernet/mscc/ocelot_vcap.c

1129

if (filter->key_type == OCELOT_VCAP_KEY_ARP)

drivers/net/ethernet/mscc/ocelot_vcap.c

1131

if (filter->key_type == OCELOT_VCAP_KEY_IPV4)

drivers/net/ethernet/mscc/ocelot_vcap.c

1133

if (filter->key_type == OCELOT_VCAP_KEY_IPV6)

drivers/net/ethernet/mscc/ocelot_vcap.c

1140

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

1142

struct ocelot_vcap_block *block = &ocelot->block[filter->block_id];

drivers/net/ethernet/mscc/ocelot_vcap.c

1148

if (filter->block_id != VCAP_IS2)

drivers/net/ethernet/mscc/ocelot_vcap.c

1151

if (ocelot_vcap_is_problematic_mac_etype(filter)) {

drivers/net/ethernet/mscc/ocelot_vcap.c

1155

if (tmp->ingress_port_mask & filter->ingress_port_mask &&

drivers/net/ethernet/mscc/ocelot_vcap.c

1156

tmp->lookup == filter->lookup &&

drivers/net/ethernet/mscc/ocelot_vcap.c

1161

for_each_set_bit(port, &filter->ingress_port_mask,

drivers/net/ethernet/mscc/ocelot_vcap.c

1164

filter->lookup, true);

drivers/net/ethernet/mscc/ocelot_vcap.c

1165

} else if (ocelot_vcap_is_problematic_non_mac_etype(filter)) {

drivers/net/ethernet/mscc/ocelot_vcap.c

1169

if (tmp->ingress_port_mask & filter->ingress_port_mask &&

drivers/net/ethernet/mscc/ocelot_vcap.c

1170

tmp->lookup == filter->lookup &&

drivers/net/ethernet/mscc/ocelot_vcap.c

1175

for_each_set_bit(port, &filter->ingress_port_mask,

drivers/net/ethernet/mscc/ocelot_vcap.c

1178

filter->lookup, false);

drivers/net/ethernet/mscc/ocelot_vcap.c

1185

struct ocelot_vcap_filter *filter,

drivers/net/ethernet/mscc/ocelot_vcap.c

1188

struct ocelot_vcap_block *block = &ocelot->block[filter->block_id];

drivers/net/ethernet/mscc/ocelot_vcap.c

1191

if (!ocelot_exclusive_mac_etype_filter_rules(ocelot, filter)) {

drivers/net/ethernet/mscc/ocelot_vcap.c

1198

ret = ocelot_vcap_filter_add_to_block(ocelot, block, filter, extack);

drivers/net/ethernet/mscc/ocelot_vcap.c

1203

index = ocelot_vcap_block_get_filter_index(block, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

1218

vcap_entry_set(ocelot, index, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

1225

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

1230

if (ocelot_vcap_filter_equal(filter, tmp)) {

drivers/net/ethernet/mscc/ocelot_vcap.c

1241

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

1243

struct ocelot_vcap_block *block = &ocelot->block[filter->block_id];

drivers/net/ethernet/mscc/ocelot_vcap.c

1251

del_filter.block_id = filter->block_id;

drivers/net/ethernet/mscc/ocelot_vcap.c

1254

index = ocelot_vcap_block_get_filter_index(block, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

1259

ocelot_vcap_block_remove_filter(ocelot, block, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

1279

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

1281

struct ocelot_vcap_block *block = &ocelot->block[filter->block_id];

drivers/net/ethernet/mscc/ocelot_vcap.c

1284

index = ocelot_vcap_block_get_filter_index(block, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

1288

vcap_entry_set(ocelot, index, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

1295

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

1297

struct ocelot_vcap_block *block = &ocelot->block[filter->block_id];

drivers/net/ethernet/mscc/ocelot_vcap.c

1301

index = ocelot_vcap_block_get_filter_index(block, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

1305

vcap_entry_get(ocelot, index, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

1308

tmp = *filter;

drivers/net/ethernet/mscc/ocelot_vcap.c

331

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

334

struct ocelot_vcap_action *a = &filter->action;

drivers/net/ethernet/mscc/ocelot_vcap.c

346

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

349

struct ocelot_vcap_key_vlan *tag = &filter->vlan;

drivers/net/ethernet/mscc/ocelot_vcap.c

366

if (filter->prio != 0)

drivers/net/ethernet/mscc/ocelot_vcap.c

371

vcap_key_set(vcap, &data, VCAP_IS2_HK_PAG, filter->pag, 0xff);

drivers/net/ethernet/mscc/ocelot_vcap.c

373

(filter->lookup == 0) ? OCELOT_VCAP_BIT_1 :

drivers/net/ethernet/mscc/ocelot_vcap.c

376

~filter->ingress_port_mask);

drivers/net/ethernet/mscc/ocelot_vcap.c

379

vcap_key_bit_set(vcap, &data, VCAP_IS2_HK_L2_MC, filter->dmac_mc);

drivers/net/ethernet/mscc/ocelot_vcap.c

380

vcap_key_bit_set(vcap, &data, VCAP_IS2_HK_L2_BC, filter->dmac_bc);

drivers/net/ethernet/mscc/ocelot_vcap.c

388

switch (filter->key_type) {

drivers/net/ethernet/mscc/ocelot_vcap.c

390

struct ocelot_vcap_key_etype *etype = &filter->key.etype;

drivers/net/ethernet/mscc/ocelot_vcap.c

412

struct ocelot_vcap_key_llc *llc = &filter->key.llc;

drivers/net/ethernet/mscc/ocelot_vcap.c

428

struct ocelot_vcap_key_snap *snap = &filter->key.snap;

drivers/net/ethernet/mscc/ocelot_vcap.c

436

filter->key.snap.snap.value,

drivers/net/ethernet/mscc/ocelot_vcap.c

437

filter->key.snap.snap.mask);

drivers/net/ethernet/mscc/ocelot_vcap.c

441

struct ocelot_vcap_key_arp *arp = &filter->key.arp;

drivers/net/ethernet/mscc/ocelot_vcap.c

494

if (filter->key_type == OCELOT_VCAP_KEY_IPV4) {

drivers/net/ethernet/mscc/ocelot_vcap.c

495

ipv4 = &filter->key.ipv4;

drivers/net/ethernet/mscc/ocelot_vcap.c

516

ipv6 = &filter->key.ipv6;

drivers/net/ethernet/mscc/ocelot_vcap.c

636

is2_action_set(ocelot, &data, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

638

vcap->counter_width, filter->stats.pkts);

drivers/net/ethernet/mscc/ocelot_vcap.c

647

const struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

650

const struct ocelot_vcap_action *a = &filter->action;

drivers/net/ethernet/mscc/ocelot_vcap.c

670

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

673

struct ocelot_vcap_key_vlan *tag = &filter->vlan;

drivers/net/ethernet/mscc/ocelot_vcap.c

689

if (filter->prio != 0)

drivers/net/ethernet/mscc/ocelot_vcap.c

692

vcap_key_set(vcap, &data, VCAP_IS1_HK_LOOKUP, filter->lookup, 0x3);

drivers/net/ethernet/mscc/ocelot_vcap.c

694

~filter->ingress_port_mask);

drivers/net/ethernet/mscc/ocelot_vcap.c

695

vcap_key_bit_set(vcap, &data, VCAP_IS1_HK_L2_MC, filter->dmac_mc);

drivers/net/ethernet/mscc/ocelot_vcap.c

696

vcap_key_bit_set(vcap, &data, VCAP_IS1_HK_L2_BC, filter->dmac_bc);

drivers/net/ethernet/mscc/ocelot_vcap.c

705

switch (filter->key_type) {

drivers/net/ethernet/mscc/ocelot_vcap.c

707

struct ocelot_vcap_key_etype *etype = &filter->key.etype;

drivers/net/ethernet/mscc/ocelot_vcap.c

716

struct ocelot_vcap_key_ipv4 *ipv4 = &filter->key.ipv4;

drivers/net/ethernet/mscc/ocelot_vcap.c

771

is1_action_set(ocelot, &data, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

773

vcap->counter_width, filter->stats.pkts);

drivers/net/ethernet/mscc/ocelot_vcap.c

782

const struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

785

const struct ocelot_vcap_action *a = &filter->action;

drivers/net/ethernet/mscc/ocelot_vcap.c

810

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

813

struct ocelot_vcap_key_vlan *tag = &filter->vlan;

drivers/net/ethernet/mscc/ocelot_vcap.c

828

if (filter->prio != 0)

drivers/net/ethernet/mscc/ocelot_vcap.c

831

vcap_key_set(vcap, &data, VCAP_ES0_IGR_PORT, filter->ingress_port.value,

drivers/net/ethernet/mscc/ocelot_vcap.c

832

filter->ingress_port.mask);

drivers/net/ethernet/mscc/ocelot_vcap.c

833

vcap_key_set(vcap, &data, VCAP_ES0_EGR_PORT, filter->egress_port.value,

drivers/net/ethernet/mscc/ocelot_vcap.c

834

filter->egress_port.mask);

drivers/net/ethernet/mscc/ocelot_vcap.c

835

vcap_key_bit_set(vcap, &data, VCAP_ES0_L2_MC, filter->dmac_mc);

drivers/net/ethernet/mscc/ocelot_vcap.c

836

vcap_key_bit_set(vcap, &data, VCAP_ES0_L2_BC, filter->dmac_bc);

drivers/net/ethernet/mscc/ocelot_vcap.c

842

es0_action_set(ocelot, &data, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

844

vcap->counter_width, filter->stats.pkts);

drivers/net/ethernet/mscc/ocelot_vcap.c

853

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

855

const struct vcap_props *vcap = &ocelot->vcap[filter->block_id];

drivers/net/ethernet/mscc/ocelot_vcap.c

860

if (filter->block_id == VCAP_ES0)

drivers/net/ethernet/mscc/ocelot_vcap.c

873

filter->stats.pkts = cnt;

drivers/net/ethernet/mscc/ocelot_vcap.c

877

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

879

if (filter->block_id == VCAP_IS1)

drivers/net/ethernet/mscc/ocelot_vcap.c

880

return is1_entry_set(ocelot, ix, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

881

if (filter->block_id == VCAP_IS2)

drivers/net/ethernet/mscc/ocelot_vcap.c

882

return is2_entry_set(ocelot, ix, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

883

if (filter->block_id == VCAP_ES0)

drivers/net/ethernet/mscc/ocelot_vcap.c

884

return es0_entry_set(ocelot, ix, filter);

drivers/net/ethernet/mscc/ocelot_vcap.c

957

struct ocelot_vcap_filter *filter,

drivers/net/ethernet/mscc/ocelot_vcap.c

963

if (filter->block_id == VCAP_IS2 && filter->action.mirror_ena) {

drivers/net/ethernet/mscc/ocelot_vcap.c

964

m = ocelot_mirror_get(ocelot, filter->egress_port.value,

drivers/net/ethernet/mscc/ocelot_vcap.c

970

if (filter->block_id == VCAP_IS2 && filter->action.police_ena) {

drivers/net/ethernet/mscc/ocelot_vcap.c

971

ret = ocelot_vcap_policer_add(ocelot, filter->action.pol_ix,

drivers/net/ethernet/mscc/ocelot_vcap.c

972

&filter->action.pol);

drivers/net/ethernet/mscc/ocelot_vcap.c

982

struct ocelot_vcap_filter *filter)

drivers/net/ethernet/mscc/ocelot_vcap.c

984

if (filter->block_id == VCAP_IS2 && filter->action.police_ena)

drivers/net/ethernet/mscc/ocelot_vcap.c

985

ocelot_vcap_policer_del(ocelot, filter->action.pol_ix);

drivers/net/ethernet/mscc/ocelot_vcap.c

987

if (filter->block_id == VCAP_IS2 && filter->action.mirror_ena)

drivers/net/ethernet/mscc/ocelot_vcap.c

993

struct ocelot_vcap_filter *filter,

drivers/net/ethernet/qlogic/qed/qed_dev.c

1074

union qed_llh_filter filter = {};

drivers/net/ethernet/qlogic/qed/qed_dev.c

1090

filter.protocol.type = type;

drivers/net/ethernet/qlogic/qed/qed_dev.c

1091

filter.protocol.source_port_or_eth_type = source_port_or_eth_type;

drivers/net/ethernet/qlogic/qed/qed_dev.c

1092

filter.protocol.dest_port = dest_port;

drivers/net/ethernet/qlogic/qed/qed_dev.c

1096

&filter, &filter_idx, &ref_cnt);

drivers/net/ethernet/qlogic/qed/qed_dev.c

1140

union qed_llh_filter filter = {};

drivers/net/ethernet/qlogic/qed/qed_dev.c

1154

ether_addr_copy(filter.mac.addr, mac_addr);

drivers/net/ethernet/qlogic/qed/qed_dev.c

1155

rc = qed_llh_shadow_remove_filter(cdev, ppfid, &filter, &filter_idx,

drivers/net/ethernet/qlogic/qed/qed_dev.c

1194

union qed_llh_filter filter = {};

drivers/net/ethernet/qlogic/qed/qed_dev.c

1210

filter.protocol.type = type;

drivers/net/ethernet/qlogic/qed/qed_dev.c

1211

filter.protocol.source_port_or_eth_type = source_port_or_eth_type;

drivers/net/ethernet/qlogic/qed/qed_dev.c

1212

filter.protocol.dest_port = dest_port;

drivers/net/ethernet/qlogic/qed/qed_dev.c

1213

rc = qed_llh_shadow_remove_filter(cdev, ppfid, &filter, &filter_idx,

drivers/net/ethernet/qlogic/qed/qed_dev.c

347

union qed_llh_filter filter;

drivers/net/ethernet/qlogic/qed/qed_dev.c

459

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

drivers/net/ethernet/qlogic/qed/qed_dev.c

513

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

drivers/net/ethernet/qlogic/qed/qed_dev.c

514

sizeof(p_filters[filter_idx].filter));

drivers/net/ethernet/qlogic/qed/qed_dev.c

940

union qed_llh_filter filter = {};

drivers/net/ethernet/qlogic/qed/qed_dev.c

951

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

drivers/net/ethernet/qlogic/qed/qed_dev.c

954

&filter, &filter_idx, &ref_cnt);

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1722

struct qed_filter_ucast filter;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1726

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

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1727

filter.is_rx_filter = 1;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1728

filter.is_tx_filter = 1;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1729

filter.vport_to_add_to = p_vf->vport_id;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1730

filter.opcode = QED_FILTER_ADD;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1737

filter.type = QED_FILTER_VLAN;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1738

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

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1741

filter.vlan, p_vf->relative_vf_id);

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1743

&filter, QED_SPQ_MODE_CB, NULL);

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1747

filter.vlan, p_vf->relative_vf_id);

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1772

struct qed_filter_ucast filter;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1782

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

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1783

filter.type = QED_FILTER_MAC;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1784

filter.opcode = QED_FILTER_REPLACE;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1785

filter.is_rx_filter = 1;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1786

filter.is_tx_filter = 1;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1787

filter.vport_to_add_to = p_vf->vport_id;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1788

ether_addr_copy(filter.mac, p_vf->bulletin.p_virt->mac);

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1791

&filter, QED_SPQ_MODE_CB, NULL);

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1810

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

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1811

filter.type = QED_FILTER_VLAN;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1812

filter.is_rx_filter = 1;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1813

filter.is_tx_filter = 1;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1814

filter.vport_to_add_to = p_vf->vport_id;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1815

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

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1816

filter.opcode = filter.vlan ? QED_FILTER_REPLACE :

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1821

&filter, QED_SPQ_MODE_CB, NULL);

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1833

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

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1835

vport_update.default_vlan = filter.vlan;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1838

removal = filter.vlan ? 1

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1841

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

drivers/net/ethernet/qlogic/qed/qed_sriov.c

1874

if (filter.vlan)

drivers/net/ethernet/qlogic/qede/qede.h

507

void qede_arfs_filter_op(void *dev, void *filter, u8 fw_rc);

drivers/net/ethernet/qlogic/qede/qede_filter.c

186

void qede_arfs_filter_op(void *dev, void *filter, u8 fw_rc)

drivers/net/ethernet/qlogic/qede/qede_filter.c

188

struct qede_arfs_fltr_node *fltr = filter;

drivers/net/ethernet/sfc/falcon/farch.c

2142

static u32 ef4_farch_filter_build(ef4_oword_t *filter,

drivers/net/ethernet/sfc/falcon/farch.c

2152

*filter,

drivers/net/ethernet/sfc/falcon/farch.c

2169

*filter,

drivers/net/ethernet/sfc/falcon/farch.c

2185

EF4_POPULATE_OWORD_5(*filter,

drivers/net/ethernet/sfc/falcon/farch.c

2303

ef4_oword_t filter;

drivers/net/ethernet/sfc/falcon/farch.c

2345

u32 key = ef4_farch_filter_build(&filter, &spec);

drivers/net/ethernet/sfc/falcon/farch.c

2427

ef4_writeo(efx, &filter,

drivers/net/ethernet/sfc/falcon/farch.c

2453

static ef4_oword_t filter;

drivers/net/ethernet/sfc/falcon/farch.c

2462

ef4_writeo(efx, &filter, table->offset + table->step * filter_idx);

drivers/net/ethernet/sfc/falcon/farch.c

2659

ef4_oword_t filter;

drivers/net/ethernet/sfc/falcon/farch.c

2674

ef4_farch_filter_build(&filter, &table->spec[filter_idx]);

drivers/net/ethernet/sfc/falcon/farch.c

2675

ef4_writeo(efx, &filter,

drivers/net/ethernet/sfc/falcon/farch.c

2759

ef4_oword_t filter;

drivers/net/ethernet/sfc/falcon/farch.c

2786

ef4_farch_filter_build(&filter, &table->spec[filter_idx]);

drivers/net/ethernet/sfc/falcon/farch.c

2787

ef4_writeo(efx, &filter,

drivers/net/ethernet/sfc/siena/farch.c

2233

static u32 efx_farch_filter_build(efx_oword_t *filter,

drivers/net/ethernet/sfc/siena/farch.c

2243

*filter,

drivers/net/ethernet/sfc/siena/farch.c

2260

*filter,

drivers/net/ethernet/sfc/siena/farch.c

2276

EFX_POPULATE_OWORD_5(*filter,

drivers/net/ethernet/sfc/siena/farch.c

2394

efx_oword_t filter;

drivers/net/ethernet/sfc/siena/farch.c

2438

u32 key = efx_farch_filter_build(&filter, &spec);

drivers/net/ethernet/sfc/siena/farch.c

2518

efx_writeo(efx, &filter,

drivers/net/ethernet/sfc/siena/farch.c

2544

static efx_oword_t filter;

drivers/net/ethernet/sfc/siena/farch.c

2553

efx_writeo(efx, &filter, table->offset + table->step * filter_idx);

drivers/net/ethernet/sfc/siena/farch.c

2748

efx_oword_t filter;

drivers/net/ethernet/sfc/siena/farch.c

2763

efx_farch_filter_build(&filter, &table->spec[filter_idx]);

drivers/net/ethernet/sfc/siena/farch.c

2764

efx_writeo(efx, &filter,

drivers/net/ethernet/sfc/siena/farch.c

2863

efx_oword_t filter;

drivers/net/ethernet/sfc/siena/farch.c

2890

efx_farch_filter_build(&filter, &table->spec[filter_idx]);

drivers/net/ethernet/sfc/siena/farch.c

2891

efx_writeo(efx, &filter,

drivers/net/ethernet/sfc/siena/siena_sriov.c

305

struct efx_filter_spec filter;

drivers/net/ethernet/sfc/siena/siena_sriov.c

327

efx_filter_init_tx(&filter, abs_index(vf, 0));

drivers/net/ethernet/sfc/siena/siena_sriov.c

328

rc = efx_filter_set_eth_local(&filter,

drivers/net/ethernet/sfc/siena/siena_sriov.c

333

rc = efx_filter_insert_filter(efx, &filter, true);

drivers/net/ethernet/sfc/siena/siena_sriov.c

349

struct efx_filter_spec filter;

drivers/net/ethernet/sfc/siena/siena_sriov.c

365

efx_filter_init_rx(&filter, EFX_FILTER_PRI_REQUIRED,

drivers/net/ethernet/sfc/siena/siena_sriov.c

368

rc = efx_filter_set_eth_local(&filter,

drivers/net/ethernet/sfc/siena/siena_sriov.c

373

rc = efx_filter_insert_filter(efx, &filter, true);

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

129

switch (rule->filter.formatted.flow_type) {

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

149

fsp->h_u.tcp_ip4_spec.psrc = rule->filter.formatted.src_port;

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

151

fsp->h_u.tcp_ip4_spec.pdst = rule->filter.formatted.dst_port;

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

153

fsp->h_u.tcp_ip4_spec.ip4src = rule->filter.formatted.src_ip[0];

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

155

fsp->h_u.tcp_ip4_spec.ip4dst = rule->filter.formatted.dst_ip[0];

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

157

fsp->h_ext.vlan_etype = rule->filter.formatted.flex_bytes;

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

159

fsp->h_ext.data[1] = htonl(rule->filter.formatted.vm_pool);

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

277

if (rule->filter.formatted.bkt_hash ==

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

278

input->filter.formatted.bkt_hash &&

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

312

(!input || rule->filter.formatted.bkt_hash !=

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

313

input->filter.formatted.bkt_hash)) {

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

315

&rule->filter,

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

404

&input->filter.formatted.flow_type)) {

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

412

if (input->filter.formatted.flow_type == TXGBE_ATR_FLOW_TYPE_IPV4)

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

416

input->filter.formatted.src_ip[0] = fsp->h_u.tcp_ip4_spec.ip4src;

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

418

input->filter.formatted.dst_ip[0] = fsp->h_u.tcp_ip4_spec.ip4dst;

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

420

input->filter.formatted.src_port = fsp->h_u.tcp_ip4_spec.psrc;

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

422

input->filter.formatted.dst_port = fsp->h_u.tcp_ip4_spec.pdst;

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

426

input->filter.formatted.vm_pool =

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

430

input->filter.formatted.flex_bytes =

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

435

switch (input->filter.formatted.flow_type) {

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

452

input->filter.formatted.vlan_id = htons(ptype);

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

478

txgbe_atr_compute_perfect_hash(&input->filter, &mask);

drivers/net/ethernet/wangxun/txgbe/txgbe_ethtool.c

489

err = txgbe_fdir_write_perfect_filter(wx, &input->filter,

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

574

struct txgbe_fdir_filter *filter;

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

588

hlist_for_each_entry_safe(filter, node,

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

590

if (filter->action == TXGBE_RDB_FDIR_DROP_QUEUE) {

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

593

u32 ring = ethtool_get_flow_spec_ring(filter->action);

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

606

&filter->filter,

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

607

filter->sw_idx,

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

611

filter->sw_idx);

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

634

struct txgbe_fdir_filter *filter;

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

640

hlist_for_each_entry_safe(filter, node,

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

642

hlist_del(&filter->fdir_node);

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

643

kfree(filter);

drivers/net/ethernet/wangxun/txgbe/txgbe_type.h

289

union txgbe_atr_input filter;

drivers/net/hyperv/hyperv_net.h

205

u32 filter;

drivers/net/hyperv/rndis_filter.c

1031

if (dev->filter == new_filter)

drivers/net/hyperv/rndis_filter.c

1050

dev->filter = new_filter;

drivers/net/hyperv/rndis_filter.c

1062

u32 filter = NDIS_PACKET_TYPE_DIRECTED;

drivers/net/hyperv/rndis_filter.c

1066

filter = NDIS_PACKET_TYPE_PROMISCUOUS;

drivers/net/hyperv/rndis_filter.c

1069

filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;

drivers/net/hyperv/rndis_filter.c

1071

filter |= NDIS_PACKET_TYPE_BROADCAST;

drivers/net/hyperv/rndis_filter.c

1074

rndis_filter_set_packet_filter(rdev, filter);

drivers/net/ipa/ipa_table.c

145

ipa_table_mem(struct ipa *ipa, bool filter, bool hashed, bool ipv6)

drivers/net/ipa/ipa_table.c

149

mem_id = filter ? hashed ? ipv6 ? IPA_MEM_V6_FILTER_HASHED

drivers/net/ipa/ipa_table.c

205

static void ipa_table_reset_add(struct gsi_trans *trans, bool filter,

drivers/net/ipa/ipa_table.c

215

mem = ipa_table_mem(ipa, filter, hashed, ipv6);

drivers/net/ipa/ipa_table.c

219

if (filter)

drivers/net/ipa/ipa_table.c

386

static void ipa_table_init_add(struct gsi_trans *trans, bool filter, bool ipv6)

drivers/net/ipa/ipa_table.c

402

opcode = filter ? ipv6 ? IPA_CMD_IP_V6_FILTER_INIT

drivers/net/ipa/ipa_table.c

408

mem = ipa_table_mem(ipa, filter, false, ipv6);

drivers/net/ipa/ipa_table.c

409

hash_mem = ipa_table_mem(ipa, filter, true, ipv6);

drivers/net/ipa/ipa_table.c

413

if (filter) {

drivers/net/ipa/ipa_table.c

431

addr = ipa_table_addr(ipa, filter, count);

drivers/net/ipa/ipa_table.c

432

hash_addr = ipa_table_addr(ipa, filter, hash_count);

drivers/net/ipa/ipa_table.c

436

if (!filter)

drivers/net/ipa/ipa_table.c

606

bool ipa_table_mem_valid(struct ipa *ipa, bool filter)

drivers/net/ipa/ipa_table.c

618

mem_ipv4 = ipa_table_mem(ipa, filter, false, false);

drivers/net/ipa/ipa_table.c

622

mem_ipv6 = ipa_table_mem(ipa, filter, false, true);

drivers/net/ipa/ipa_table.c

633

if (filter)

drivers/net/ipa/ipa_table.c

639

if (!ipa_cmd_table_init_valid(ipa, mem_ipv4, !filter))

drivers/net/ipa/ipa_table.c

643

if (filter) {

drivers/net/ipa/ipa_table.c

662

mem_hashed = ipa_table_mem(ipa, filter, true, false);

drivers/net/ipa/ipa_table.c

672

mem_hashed = ipa_table_mem(ipa, filter, true, true);

drivers/net/ipa/ipa_table.h

74

bool ipa_table_mem_valid(struct ipa *ipa, bool filter);

drivers/net/macvlan.c

805

DECLARE_BITMAP(filter, MACVLAN_MC_FILTER_SZ);

drivers/net/macvlan.c

808

bitmap_zero(filter, MACVLAN_MC_FILTER_SZ);

drivers/net/macvlan.c

813

__set_bit(mc_hash(vlan, ha->addr), filter);

drivers/net/macvlan.c

816

__set_bit(mc_hash(vlan, dev->broadcast), filter);

drivers/net/macvlan.c

818

bitmap_copy(mc_filter, filter, MACVLAN_MC_FILTER_SZ);

drivers/net/ppp/ppp_generic.c

1004

struct bpf_prog *filter = compat_ppp_get_filter(argp);

drivers/net/ppp/ppp_generic.c

1007

if (IS_ERR(filter)) {

drivers/net/ppp/ppp_generic.c

1008

err = PTR_ERR(filter);

drivers/net/ppp/ppp_generic.c

1018

*which = filter;

drivers/net/ppp/ppp_generic.c

595

fprog.filter = memdup_array_user(uprog->filter,

drivers/net/ppp/ppp_generic.c

597

if (IS_ERR(fprog.filter))

drivers/net/ppp/ppp_generic.c

598

return ERR_CAST(fprog.filter);

drivers/net/ppp/ppp_generic.c

601

kfree(fprog.filter);

drivers/net/ppp/ppp_generic.c

618

compat_caddr_t filter;

drivers/net/ppp/ppp_generic.c

632

uprog.filter = compat_ptr(uprog32.filter);

drivers/net/ppp/ppp_generic.c

938

struct bpf_prog *filter = ppp_get_filter(argp);

drivers/net/ppp/ppp_generic.c

941

if (IS_ERR(filter)) {

drivers/net/ppp/ppp_generic.c

942

err = PTR_ERR(filter);

drivers/net/ppp/ppp_generic.c

952

*which = filter;

drivers/net/team/team_mode_loadbalance.c

251

ctx->data.bin_val.ptr = lb_priv->ex->orig_fprog->filter;

drivers/net/team/team_mode_loadbalance.c

258

struct sock_filter *filter = (struct sock_filter *) data;

drivers/net/team/team_mode_loadbalance.c

265

fprog->filter = kmemdup(filter, data_len, GFP_KERNEL);

drivers/net/team/team_mode_loadbalance.c

266

if (!fprog->filter) {

drivers/net/team/team_mode_loadbalance.c

277

kfree(fprog->filter);

drivers/net/tun.c

816

static int update_filter(struct tap_filter *filter, void __user *arg)

drivers/net/tun.c

827

filter->count = 0;

drivers/net/tun.c

839

filter->count = 0;

drivers/net/tun.c

844

memcpy(filter->addr[n], addr[n].u, ETH_ALEN);

drivers/net/tun.c

850

memset(filter->mask, 0, sizeof(filter->mask));

drivers/net/tun.c

856

addr_hash_set(filter->mask, addr[n].u);

drivers/net/tun.c

862

memset(filter->mask, ~0, sizeof(filter->mask));

drivers/net/tun.c

866

filter->count = nexact;

drivers/net/tun.c

876

static int run_filter(struct tap_filter *filter, const struct sk_buff *skb)

drivers/net/tun.c

884

for (i = 0; i < filter->count; i++)

drivers/net/tun.c

885

if (ether_addr_equal(eh->h_dest, filter->addr[i]))

drivers/net/tun.c

890

return addr_hash_test(filter->mask, eh->h_dest);

drivers/net/tun.c

899

static int check_filter(struct tap_filter *filter, const struct sk_buff *skb)

drivers/net/tun.c

901

if (!filter->count)

drivers/net/tun.c

904

return run_filter(filter, skb);

drivers/net/usb/smsc75xx.c

1522

static int smsc75xx_write_wuff(struct usbnet *dev, int filter, u32 wuf_cfg,

drivers/net/usb/smsc75xx.c

1525

int cfg_base = WUF_CFGX + filter * 4;

drivers/net/usb/smsc75xx.c

1526

int mask_base = WUF_MASKX + filter * 16;

drivers/net/usb/smsc75xx.c

1886

int i, filter = 0;

drivers/net/usb/smsc75xx.c

1903

ret = smsc75xx_write_wuff(dev, filter++, val, 0x0007);

drivers/net/usb/smsc75xx.c

1916

ret = smsc75xx_write_wuff(dev, filter++, val, 0x0003);

drivers/net/usb/smsc95xx.c

1345

static u32 smsc_crc(const u8 *buffer, size_t len, int filter)

drivers/net/usb/smsc95xx.c

1348

return crc << ((filter % 2) * 16);

drivers/net/usb/smsc95xx.c

1625

int i, filter = 0;

drivers/net/usb/smsc95xx.c

1640

filter_mask[filter * 4] = 0x003F;

drivers/net/usb/smsc95xx.c

1641

filter_mask[filter * 4 + 1] = 0x00;

drivers/net/usb/smsc95xx.c

1642

filter_mask[filter * 4 + 2] = 0x00;

drivers/net/usb/smsc95xx.c

1643

filter_mask[filter * 4 + 3] = 0x00;

drivers/net/usb/smsc95xx.c

1644

command[filter/4] |= 0x05UL << ((filter % 4) * 8);

drivers/net/usb/smsc95xx.c

1645

offset[filter/4] |= 0x00 << ((filter % 4) * 8);

drivers/net/usb/smsc95xx.c

1646

crc[filter/2] |= smsc_crc(bcast, 6, filter);

drivers/net/usb/smsc95xx.c

1647

filter++;

drivers/net/usb/smsc95xx.c

1653

filter_mask[filter * 4] = 0x0007;

drivers/net/usb/smsc95xx.c

1654

filter_mask[filter * 4 + 1] = 0x00;

drivers/net/usb/smsc95xx.c

1655

filter_mask[filter * 4 + 2] = 0x00;

drivers/net/usb/smsc95xx.c

1656

filter_mask[filter * 4 + 3] = 0x00;

drivers/net/usb/smsc95xx.c

1657

command[filter/4] |= 0x09UL << ((filter % 4) * 8);

drivers/net/usb/smsc95xx.c

1658

offset[filter/4] |= 0x00 << ((filter % 4) * 8);

drivers/net/usb/smsc95xx.c

1659

crc[filter/2] |= smsc_crc(mcast, 3, filter);

drivers/net/usb/smsc95xx.c

1660

filter++;

drivers/net/usb/smsc95xx.c

1666

filter_mask[filter * 4] = 0x0003;

drivers/net/usb/smsc95xx.c

1667

filter_mask[filter * 4 + 1] = 0x00;

drivers/net/usb/smsc95xx.c

1668

filter_mask[filter * 4 + 2] = 0x00;

drivers/net/usb/smsc95xx.c

1669

filter_mask[filter * 4 + 3] = 0x00;

drivers/net/usb/smsc95xx.c

1670

command[filter/4] |= 0x05UL << ((filter % 4) * 8);

drivers/net/usb/smsc95xx.c

1671

offset[filter/4] |= 0x0C << ((filter % 4) * 8);

drivers/net/usb/smsc95xx.c

1672

crc[filter/2] |= smsc_crc(arp, 2, filter);

drivers/net/usb/smsc95xx.c

1673

filter++;

drivers/net/usb/smsc95xx.c

1678

filter_mask[filter * 4] = 0x003F;

drivers/net/usb/smsc95xx.c

1679

filter_mask[filter * 4 + 1] = 0x00;

drivers/net/usb/smsc95xx.c

1680

filter_mask[filter * 4 + 2] = 0x00;

drivers/net/usb/smsc95xx.c

1681

filter_mask[filter * 4 + 3] = 0x00;

drivers/net/usb/smsc95xx.c

1682

command[filter/4] |= 0x01UL << ((filter % 4) * 8);

drivers/net/usb/smsc95xx.c

1683

offset[filter/4] |= 0x00 << ((filter % 4) * 8);

drivers/net/usb/smsc95xx.c

1684

crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter);

drivers/net/usb/smsc95xx.c

1685

filter++;

drivers/net/wireless/ath/ar5523/ar5523.c

1339

u32 filter = 0;

drivers/net/wireless/ath/ar5523/ar5523.c

1351

filter |= UATH_FILTER_RX_UCAST | UATH_FILTER_RX_MCAST |

drivers/net/wireless/ath/ar5523/ar5523.c

1356

ar5523_set_rxfilter(ar, filter, UATH_FILTER_OP_SET);

drivers/net/wireless/ath/ath10k/debug.c

1858

u32 filter;

drivers/net/wireless/ath/ath10k/debug.c

1861

if (kstrtouint_from_user(ubuf, count, 0, &filter))

drivers/net/wireless/ath/ath10k/debug.c

1867

ar->pktlog_filter = filter;

drivers/net/wireless/ath/ath10k/debug.c

1872

if (filter == ar->pktlog_filter) {

drivers/net/wireless/ath/ath10k/debug.c

1877

if (filter) {

drivers/net/wireless/ath/ath10k/debug.c

1878

ret = ath10k_wmi_pdev_pktlog_enable(ar, filter);

drivers/net/wireless/ath/ath10k/debug.c

1892

ar->pktlog_filter = filter;

drivers/net/wireless/ath/ath10k/debug.c

2047

u32 filter;

drivers/net/wireless/ath/ath10k/debug.c

2050

if (kstrtouint_from_user(ubuf, count, 0, &filter))

drivers/net/wireless/ath/ath10k/debug.c

2056

ar->debug.enable_extd_tx_stats = filter;

drivers/net/wireless/ath/ath10k/debug.c

2061

if (filter == ar->debug.enable_extd_tx_stats) {

drivers/net/wireless/ath/ath10k/debug.c

2066

ar->debug.enable_extd_tx_stats = filter;

drivers/net/wireless/ath/ath10k/wmi-ops.h

1173

ath10k_wmi_pdev_pktlog_enable(struct ath10k *ar, u32 filter)

drivers/net/wireless/ath/ath10k/wmi-ops.h

1180

skb = ar->wmi.ops->gen_pktlog_enable(ar, filter);

drivers/net/wireless/ath/ath10k/wmi-ops.h

146

struct sk_buff *(*gen_pktlog_enable)(struct ath10k *ar, u32 filter);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3240

ath10k_wmi_tlv_op_gen_pktlog_enable(struct ath10k *ar, u32 filter)

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3258

cmd->filter = __cpu_to_le32(filter);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3264

filter);

drivers/net/wireless/ath/ath10k/wmi-tlv.h

2021

__le32 filter;

drivers/net/wireless/ath/ath11k/debugfs.c

1070

ar->debug.pktlog_filter = filter;

drivers/net/wireless/ath/ath11k/debugfs.c

445

u32 filter;

drivers/net/wireless/ath/ath11k/debugfs.c

448

if (kstrtouint_from_user(ubuf, count, 0, &filter))

drivers/net/wireless/ath/ath11k/debugfs.c

458

if (filter == ar->debug.extd_tx_stats) {

drivers/net/wireless/ath/ath11k/debugfs.c

463

ar->debug.extd_tx_stats = filter;

drivers/net/wireless/ath/ath11k/debugfs.c

954

u32 rx_filter = 0, ring_id, filter, mode;

drivers/net/wireless/ath/ath11k/debugfs.c

972

ret = sscanf(buf, "0x%x %u", &filter, &mode);

drivers/net/wireless/ath/ath11k/debugfs.c

978

if (filter) {

drivers/net/wireless/ath/ath11k/debugfs.c

979

ret = ath11k_wmi_pdev_pktlog_enable(ar, filter);

drivers/net/wireless/ath/ath5k/ath5k.h

1543

void ath5k_hw_set_rx_filter(struct ath5k_hw *ah, u32 filter);

drivers/net/wireless/ath/ath5k/pcu.c

485

u32 data, filter = 0;

drivers/net/wireless/ath/ath5k/pcu.c

487

filter = ath5k_hw_reg_read(ah, AR5K_RX_FILTER);

drivers/net/wireless/ath/ath5k/pcu.c

494

filter |= AR5K_RX_FILTER_RADARERR;

drivers/net/wireless/ath/ath5k/pcu.c

496

filter |= AR5K_RX_FILTER_PHYERR;

drivers/net/wireless/ath/ath5k/pcu.c

499

return filter;

drivers/net/wireless/ath/ath5k/pcu.c

512

ath5k_hw_set_rx_filter(struct ath5k_hw *ah, u32 filter)

drivers/net/wireless/ath/ath5k/pcu.c

518

if (filter & AR5K_RX_FILTER_RADARERR)

drivers/net/wireless/ath/ath5k/pcu.c

520

if (filter & AR5K_RX_FILTER_PHYERR)

drivers/net/wireless/ath/ath5k/pcu.c

528

(filter & AR5K_RX_FILTER_RADARERR)) {

drivers/net/wireless/ath/ath5k/pcu.c

529

filter &= ~AR5K_RX_FILTER_RADARERR;

drivers/net/wireless/ath/ath5k/pcu.c

530

filter |= AR5K_RX_FILTER_PROM;

drivers/net/wireless/ath/ath5k/pcu.c

540

ath5k_hw_reg_write(ah, filter & 0xff, AR5K_RX_FILTER);

drivers/net/wireless/ath/ath6kl/cfg80211.c

1910

struct cfg80211_wowlan *wow, u32 *filter)

drivers/net/wireless/ath/ath6kl/cfg80211.c

1947

*filter |= WOW_FILTER_OPTION_NWK_DISASSOC;

drivers/net/wireless/ath/ath6kl/cfg80211.c

1950

*filter |= WOW_FILTER_OPTION_MAGIC_PACKET;

drivers/net/wireless/ath/ath6kl/cfg80211.c

1953

*filter |= WOW_FILTER_OPTION_GTK_ERROR;

drivers/net/wireless/ath/ath6kl/cfg80211.c

1956

*filter |= WOW_FILTER_OPTION_EAP_REQ;

drivers/net/wireless/ath/ath6kl/cfg80211.c

1959

*filter |= WOW_FILTER_OPTION_8021X_4WAYHS;

drivers/net/wireless/ath/ath6kl/cfg80211.c

2131

struct cfg80211_wowlan *wow, u32 *filter)

drivers/net/wireless/ath/ath6kl/cfg80211.c

2161

ret = ath6kl_wow_usr(ar, vif, wow, filter);

drivers/net/wireless/ath/ath6kl/cfg80211.c

2229

u32 filter = 0;

drivers/net/wireless/ath/ath6kl/cfg80211.c

2249

ret = ath6kl_wow_suspend_vif(vif, wow, &filter);

drivers/net/wireless/ath/ath6kl/cfg80211.c

2264

filter,

drivers/net/wireless/ath/ath6kl/wmi.c

2121

int ath6kl_wmi_bssfilter_cmd(struct wmi *wmi, u8 if_idx, u8 filter, u32 ie_mask)

drivers/net/wireless/ath/ath6kl/wmi.c

2127

if (filter >= LAST_BSS_FILTER)

drivers/net/wireless/ath/ath6kl/wmi.c

2135

cmd->bss_filter = filter;

drivers/net/wireless/ath/ath6kl/wmi.c

2913

u32 filter, u16 host_req_delay)

drivers/net/wireless/ath/ath6kl/wmi.c

2931

cmd->filter = cpu_to_le32(filter);

drivers/net/wireless/ath/ath6kl/wmi.c

2941

u8 filter_offset, const u8 *filter,

drivers/net/wireless/ath/ath6kl/wmi.c

2965

memcpy(cmd->filter, filter, filter_size);

drivers/net/wireless/ath/ath6kl/wmi.c

2967

filter_mask = (u8 *) (cmd->filter + filter_size);

drivers/net/wireless/ath/ath6kl/wmi.c

3239

u8 *filter, bool add_filter)

drivers/net/wireless/ath/ath6kl/wmi.c

3245

if ((filter[0] != 0x33 || filter[1] != 0x33) &&

drivers/net/wireless/ath/ath6kl/wmi.c

3246

(filter[0] != 0x01 || filter[1] != 0x00 ||

drivers/net/wireless/ath/ath6kl/wmi.c

3247

filter[2] != 0x5e || filter[3] > 0x7f)) {

drivers/net/wireless/ath/ath6kl/wmi.c

3257

memcpy(cmd->mcast_mac, filter, ATH6KL_MCAST_FILTER_MAC_ADDR_SIZE);

drivers/net/wireless/ath/ath6kl/wmi.h

2122

__le32 filter;

drivers/net/wireless/ath/ath6kl/wmi.h

2130

u8 filter[];

drivers/net/wireless/ath/ath6kl/wmi.h

2584

int ath6kl_wmi_bssfilter_cmd(struct wmi *wmi, u8 if_idx, u8 filter,

drivers/net/wireless/ath/ath6kl/wmi.h

2645

u32 filter, u16 host_req_delay);

drivers/net/wireless/ath/ath6kl/wmi.h

2648

u8 filter_offset, const u8 *filter,

drivers/net/wireless/ath/ath6kl/wmi.h

2661

u8 *filter, bool add_filter);

drivers/net/wireless/ath/ath9k/mac.c

1034

u32 filter;

drivers/net/wireless/ath/ath9k/mac.c

1037

filter = SM(set, AR_D_TXBLK_WRITE_COMMAND);

drivers/net/wireless/ath/ath9k/mac.c

1038

filter |= SM(dcu_idx, AR_D_TXBLK_WRITE_DCU);

drivers/net/wireless/ath/ath9k/mac.c

1039

filter |= SM((destidx / ATH9K_HW_SLICE_PER_DCU),

drivers/net/wireless/ath/ath9k/mac.c

1041

filter |= BIT(destidx % ATH9K_HW_BIT_IN_SLICE);

drivers/net/wireless/ath/ath9k/mac.c

1044

dcu_idx, destidx, set, filter);

drivers/net/wireless/ath/ath9k/mac.c

1045

REG_WRITE(ah, AR_D_TXBLK_BASE, filter);

drivers/net/wireless/broadcom/b43/phy_n.c

4900

const s16 *filter)

drivers/net/wireless/broadcom/b43/phy_n.c

4907

b43_phy_write(dev, offset, filter[i]);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4003

struct brcmf_fil_wowl_pattern_le *filter;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4011

patternoffset = sizeof(*filter) - sizeof(filter->cmd) + masksize;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4013

bufsize = sizeof(*filter) + patternsize + masksize;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4017

filter = (struct brcmf_fil_wowl_pattern_le *)buf;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4019

memcpy(filter->cmd, cmd, 4);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4020

filter->masksize = cpu_to_le32(masksize);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4021

filter->offset = cpu_to_le32(packet_offset);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4022

filter->patternoffset = cpu_to_le32(patternoffset);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4023

filter->patternsize = cpu_to_le32(patternsize);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4024

filter->type = cpu_to_le32(BRCMF_WOWL_PATTERN_TYPE_BITMAP);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4027

memcpy(buf + sizeof(*filter), mask, masksize);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

4029

memcpy(buf + sizeof(*filter) + masksize, pattern, patternsize);

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10262

u16 filter = priv->prom_priv->filter;

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10265

if (filter & IPW_PROM_NO_TX)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10273

if (filter & IPW_PROM_NO_MGMT)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10275

if (filter & IPW_PROM_MGMT_HEADER_ONLY)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10278

if (filter & IPW_PROM_NO_CTL)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10280

if (filter & IPW_PROM_CTL_HEADER_ONLY)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10283

if (filter & IPW_PROM_NO_DATA)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10285

if (filter & IPW_PROM_DATA_HEADER_ONLY)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

1429

priv->prom_priv->filter = simple_strtol(buf, NULL, 0);

drivers/net/wireless/intel/ipw2x00/ipw2200.c

1432

BIT_ARG16(priv->prom_priv->filter));

drivers/net/wireless/intel/ipw2x00/ipw2200.c

1443

priv->prom_priv ? priv->prom_priv->filter : 0);

drivers/net/wireless/intel/ipw2x00/ipw2200.c

7879

u16 filter = priv->prom_priv->filter;

drivers/net/wireless/intel/ipw2x00/ipw2200.c

7882

if (filter & IPW_PROM_NO_RX)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

7912

if (filter & IPW_PROM_NO_MGMT)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

7914

if (filter & IPW_PROM_MGMT_HEADER_ONLY)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

7917

if (filter & IPW_PROM_NO_CTL)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

7919

if (filter & IPW_PROM_CTL_HEADER_ONLY)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

7922

if (filter & IPW_PROM_NO_DATA)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

7924

if (filter & IPW_PROM_DATA_HEADER_ONLY)

drivers/net/wireless/intel/ipw2x00/ipw2200.h

1129

enum ipw_prom_filter filter;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3338

mef_entry->filter[filt_num].repeat = 1;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3339

memcpy(mef_entry->filter[filt_num].byte_seq,

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3341

mef_entry->filter[filt_num].

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3344

mef_entry->filter[filt_num].offset = 46;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3345

mef_entry->filter[filt_num].filt_type = TYPE_EQ;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3347

mef_entry->filter[filt_num].filt_action =

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3353

mef_entry->filter[filt_num].repeat = 1;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3354

mef_entry->filter[filt_num].byte_seq[0] = 0x08;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3355

mef_entry->filter[filt_num].byte_seq[1] = 0x06;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3356

mef_entry->filter[filt_num].byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] = 2;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3357

mef_entry->filter[filt_num].offset = 20;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3358

mef_entry->filter[filt_num].filt_type = TYPE_EQ;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3359

mef_entry->filter[filt_num].filt_action = TYPE_AND;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3402

mef_entry->filter[filt_num].repeat = 1;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3403

mef_entry->filter[filt_num].offset =

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3405

memcpy(mef_entry->filter[filt_num].byte_seq, byte_seq,

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3407

mef_entry->filter[filt_num].filt_type = TYPE_EQ;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3413

mef_entry->filter[filt_num].filt_action = TYPE_AND;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3421

mef_entry->filter[filt_num].repeat = 16;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3422

memcpy(mef_entry->filter[filt_num].byte_seq, priv->curr_addr,

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3424

mef_entry->filter[filt_num].byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] =

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3426

mef_entry->filter[filt_num].offset = 28;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3427

mef_entry->filter[filt_num].filt_type = TYPE_EQ;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3429

mef_entry->filter[filt_num].filt_action = TYPE_OR;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3432

mef_entry->filter[filt_num].repeat = 16;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3433

memcpy(mef_entry->filter[filt_num].byte_seq, priv->curr_addr,

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3435

mef_entry->filter[filt_num].byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] =

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3437

mef_entry->filter[filt_num].offset = 56;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3438

mef_entry->filter[filt_num].filt_type = TYPE_EQ;

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3439

mef_entry->filter[filt_num].filt_action = TYPE_OR;

drivers/net/wireless/marvell/mwifiex/ioctl.h

412

struct mwifiex_mef_filter filter[MWIFIEX_MEF_MAX_FILTERS];

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1362

struct mwifiex_mef_filter *filter = mef_entry->filter;

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1367

filter = &mef_entry->filter[i];

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1368

if (!filter->filt_type)

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1370

put_unaligned_le32((u32)filter->repeat, stack_ptr);

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1375

byte_len = filter->byte_seq[MWIFIEX_MEF_MAX_BYTESEQ];

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1376

memcpy(stack_ptr, filter->byte_seq, byte_len);

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1382

put_unaligned_le32((u32)filter->offset, stack_ptr);

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1387

*stack_ptr = filter->filt_type;

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1390

if (filter->filt_action) {

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1391

*stack_ptr = filter->filt_action;

drivers/net/wireless/mediatek/mt76/mt7996/main.c

440

u32 filter = phy->rxfilter;

drivers/net/wireless/mediatek/mt76/mt7996/main.c

442

if (filter & MT_WF_RFCR_DROP_OTHER_UC) {

drivers/net/wireless/mediatek/mt76/mt7996/main.c

443

filter |= MT_WF_RFCR_DROP_CTS |

drivers/net/wireless/mediatek/mt76/mt7996/main.c

449

mt76_wr(dev, MT_WF_RFCR(phy->mt76->band_idx), filter);

drivers/net/wireless/mediatek/mt76/mt7996/main.c

450

if (filter & MT_WF_RFCR_DROP_CTL_RSV)

drivers/net/wireless/mediatek/mt7601u/phy.c

273

u32 filter = 0;

drivers/net/wireless/mediatek/mt7601u/phy.c

277

filter |= 0x10000;

drivers/net/wireless/mediatek/mt7601u/phy.c

279

filter |= 0x00100;

drivers/net/wireless/mediatek/mt7601u/phy.c

282

ret = mt7601u_mcu_calibrate(dev, MCU_CAL_BW, filter | 1);

drivers/net/wireless/mediatek/mt7601u/phy.c

286

return mt7601u_mcu_calibrate(dev, MCU_CAL_BW, filter);

drivers/net/wireless/realtek/rtw89/rtw8852c.c

2101

__DECL_DFIR_ADDR(filter,

drivers/net/wireless/st/cw1200/sta.c

1814

struct wsm_mib_arp_ipv4_filter filter = {0};

drivers/net/wireless/st/cw1200/sta.c

1826

filter.ipv4addrs[i] = vif->cfg.arp_addr_list[i];

drivers/net/wireless/st/cw1200/sta.c

1828

i, filter.ipv4addrs[i]);

drivers/net/wireless/st/cw1200/sta.c

1830

filter.enable = __cpu_to_le32(1);

drivers/net/wireless/st/cw1200/sta.c

1834

__le32_to_cpu(filter.enable));

drivers/net/wireless/st/cw1200/sta.c

1836

wsm_set_arp_ipv4_filter(priv, &filter);

drivers/net/wireless/st/cw1200/wsm.h

1680

u8 filter;

drivers/net/wireless/st/cw1200/wsm.h

1688

.filter = !enabled,

drivers/net/wireless/ti/wl1251/acx.c

299

int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter)

drivers/net/wireless/ti/wl1251/acx.c

311

rx_config->filter_options = filter;

drivers/net/wireless/ti/wl1251/acx.h

1449

int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter);

drivers/net/wireless/ti/wl1251/init.c

89

int wl1251_hw_init_rx_config(struct wl1251 *wl, u32 config, u32 filter)

drivers/net/wireless/ti/wl1251/init.c

97

ret = wl1251_acx_rx_config(wl, config, filter);

drivers/net/wireless/ti/wl1251/init.h

62

int wl1251_hw_init_rx_config(struct wl1251 *wl, u32 config, u32 filter);

drivers/net/wireless/ti/wl18xx/scan.c

194

cmd->filter = 1;

drivers/net/wireless/ti/wl18xx/scan.c

58

cmd->filter = 0;

drivers/net/wireless/ti/wl18xx/scan.h

45

u8 filter; /* forward only results with matching ssids */

drivers/net/wireless/ti/wlcore/acx.c

1790

struct wl12xx_rx_filter *filter)

drivers/net/wireless/ti/wlcore/acx.c

1797

WARN_ON(enable && !filter);

drivers/net/wireless/ti/wlcore/acx.c

1802

index, enable, filter);

drivers/net/wireless/ti/wlcore/acx.c

1805

fields_size = wl1271_rx_filter_get_fields_size(filter);

drivers/net/wireless/ti/wlcore/acx.c

1808

filter->action, filter->num_fields, fields_size);

drivers/net/wireless/ti/wlcore/acx.c

1821

acx->num_fields = filter->num_fields;

drivers/net/wireless/ti/wlcore/acx.c

1822

acx->action = filter->action;

drivers/net/wireless/ti/wlcore/acx.c

1823

wl1271_rx_filter_flatten_fields(filter, acx->fields);

drivers/net/wireless/ti/wlcore/acx.h

1121

struct wl12xx_rx_filter *filter);

drivers/net/wireless/ti/wlcore/main.c

1483

void wl1271_rx_filter_free(struct wl12xx_rx_filter *filter)

drivers/net/wireless/ti/wlcore/main.c

1487

if (filter == NULL)

drivers/net/wireless/ti/wlcore/main.c

1490

for (i = 0; i < filter->num_fields; i++)

drivers/net/wireless/ti/wlcore/main.c

1491

kfree(filter->fields[i].pattern);

drivers/net/wireless/ti/wlcore/main.c

1493

kfree(filter);

drivers/net/wireless/ti/wlcore/main.c

1496

int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,

drivers/net/wireless/ti/wlcore/main.c

1502

if (filter->num_fields == WL1271_RX_FILTER_MAX_FIELDS) {

drivers/net/wireless/ti/wlcore/main.c

1507

field = &filter->fields[filter->num_fields];

drivers/net/wireless/ti/wlcore/main.c

1515

filter->num_fields++;

drivers/net/wireless/ti/wlcore/main.c

1524

int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter *filter)

drivers/net/wireless/ti/wlcore/main.c

1528

for (i = 0; i < filter->num_fields; i++)

drivers/net/wireless/ti/wlcore/main.c

1529

fields_size += filter->fields[i].len +

drivers/net/wireless/ti/wlcore/main.c

1536

void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter *filter,

drivers/net/wireless/ti/wlcore/main.c

1542

for (i = 0; i < filter->num_fields; i++) {

drivers/net/wireless/ti/wlcore/main.c

1545

field->offset = filter->fields[i].offset;

drivers/net/wireless/ti/wlcore/main.c

1546

field->flags = filter->fields[i].flags;

drivers/net/wireless/ti/wlcore/main.c

1547

field->len = filter->fields[i].len;

drivers/net/wireless/ti/wlcore/main.c

1549

memcpy(&field->pattern, filter->fields[i].pattern, field->len);

drivers/net/wireless/ti/wlcore/main.c

1564

struct wl12xx_rx_filter *filter;

drivers/net/wireless/ti/wlcore/main.c

1568

filter = wl1271_rx_filter_alloc();

drivers/net/wireless/ti/wlcore/main.c

1569

if (!filter) {

drivers/net/wireless/ti/wlcore/main.c

1601

ret = wl1271_rx_filter_alloc_field(filter,

drivers/net/wireless/ti/wlcore/main.c

1611

filter->action = FILTER_SIGNAL;

drivers/net/wireless/ti/wlcore/main.c

1613

*f = filter;

drivers/net/wireless/ti/wlcore/main.c

1617

wl1271_rx_filter_free(filter);

drivers/net/wireless/ti/wlcore/main.c

1664

struct wl12xx_rx_filter *filter = NULL;

drivers/net/wireless/ti/wlcore/main.c

1668

ret = wl1271_convert_wowlan_pattern_to_rx_filter(p, &filter);

drivers/net/wireless/ti/wlcore/main.c

1675

ret = wl1271_rx_filter_enable(wl, i, 1, filter);

drivers/net/wireless/ti/wlcore/main.c

1677

wl1271_rx_filter_free(filter);

drivers/net/wireless/ti/wlcore/rx.c

301

struct wl12xx_rx_filter *filter)

drivers/net/wireless/ti/wlcore/rx.c

311

ret = wl1271_acx_set_rx_filter(wl, index, enable, filter);

drivers/net/wireless/ti/wlcore/rx.h

138

struct wl12xx_rx_filter *filter);

drivers/net/wireless/ti/wlcore/wlcore_i.h

541

int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,

drivers/net/wireless/ti/wlcore/wlcore_i.h

544

void wl1271_rx_filter_free(struct wl12xx_rx_filter *filter);

drivers/net/wireless/ti/wlcore/wlcore_i.h

546

int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter *filter);

drivers/net/wireless/ti/wlcore/wlcore_i.h

547

void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter *filter,

drivers/net/wireless/zydas/zd1211rw/zd_mac.c

232

u32 filter = STA_RX_FILTER;

drivers/net/wireless/zydas/zd1211rw/zd_mac.c

236

filter |= RX_FILTER_CTRL;

drivers/net/wireless/zydas/zd1211rw/zd_mac.c

239

return zd_iowrite32(&mac->chip, CR_RX_FILTER, filter);

drivers/nvme/target/pci-epf.c

280

struct nvmet_pci_epf_dma_filter *filter = arg;

drivers/nvme/target/pci-epf.c

286

return chan->device->dev == filter->dev &&

drivers/nvme/target/pci-epf.c

287

(filter->dma_mask & caps.directions);

drivers/nvme/target/pci-epf.c

294

struct nvmet_pci_epf_dma_filter filter;

drivers/nvme/target/pci-epf.c

304

filter.dev = epf->epc->dev.parent;

drivers/nvme/target/pci-epf.c

305

filter.dma_mask = BIT(DMA_DEV_TO_MEM);

drivers/nvme/target/pci-epf.c

307

chan = dma_request_channel(mask, nvmet_pci_epf_dma_filter, &filter);

drivers/nvme/target/pci-epf.c

313

filter.dma_mask = BIT(DMA_MEM_TO_DEV);

drivers/nvme/target/pci-epf.c

314

chan = dma_request_channel(mask, nvmet_pci_epf_dma_filter, &filter);

drivers/pci/endpoint/functions/pci-epf-mhi.c

650

struct epf_dma_filter *filter = node;

drivers/pci/endpoint/functions/pci-epf-mhi.c

656

return chan->device->dev == filter->dev && filter->dma_mask &

drivers/pci/endpoint/functions/pci-epf-mhi.c

664

struct epf_dma_filter filter;

drivers/pci/endpoint/functions/pci-epf-mhi.c

671

filter.dev = dma_dev;

drivers/pci/endpoint/functions/pci-epf-mhi.c

672

filter.dma_mask = BIT(DMA_MEM_TO_DEV);

drivers/pci/endpoint/functions/pci-epf-mhi.c

674

&filter);

drivers/pci/endpoint/functions/pci-epf-mhi.c

680

filter.dma_mask = BIT(DMA_DEV_TO_MEM);

drivers/pci/endpoint/functions/pci-epf-mhi.c

682

&filter);

drivers/pci/endpoint/functions/pci-epf-test.c

230

struct epf_dma_filter *filter = node;

drivers/pci/endpoint/functions/pci-epf-test.c

236

return chan->device->dev == filter->dev

drivers/pci/endpoint/functions/pci-epf-test.c

237

&& (filter->dma_mask & caps.directions);

drivers/pci/endpoint/functions/pci-epf-test.c

250

struct epf_dma_filter filter;

drivers/pci/endpoint/functions/pci-epf-test.c

255

filter.dev = epf->epc->dev.parent;

drivers/pci/endpoint/functions/pci-epf-test.c

256

filter.dma_mask = BIT(DMA_DEV_TO_MEM);

drivers/pci/endpoint/functions/pci-epf-test.c

260

dma_chan = dma_request_channel(mask, epf_dma_filter_fn, &filter);

drivers/pci/endpoint/functions/pci-epf-test.c

268

filter.dma_mask = BIT(DMA_MEM_TO_DEV);

drivers/pci/endpoint/functions/pci-epf-test.c

269

dma_chan = dma_request_channel(mask, epf_dma_filter_fn, &filter);

drivers/perf/arm_cspmu/arm_cspmu.c

808

u32 filter = event->attr.config1 & ARM_CSPMU_FILTER_MASK;

drivers/perf/arm_cspmu/arm_cspmu.c

812

writel(filter, cspmu->base0 + PMEVFILTR + offset);

drivers/perf/arm_cspmu/arm_cspmu.c

819

u32 filter = event->attr.config1 & ARM_CSPMU_FILTER_MASK;

drivers/perf/arm_cspmu/arm_cspmu.c

821

writel(filter, cspmu->base0 + PMCCFILTR);

drivers/perf/arm_cspmu/arm_cspmu.h

49

ARM_CSPMU_FORMAT_ATTR(filter, "config1:0-31")

drivers/perf/arm_cspmu/nvidia_cspmu.c

215

u32 filter, offset;

drivers/perf/arm_cspmu/nvidia_cspmu.c

221

filter = ctx->get_filter(event);

drivers/perf/arm_cspmu/nvidia_cspmu.c

222

writel(filter, cspmu->base0 + PMEVFILTR + offset);

drivers/perf/arm_cspmu/nvidia_cspmu.c

226

filter = ctx->get_filter2(event);

drivers/perf/arm_cspmu/nvidia_cspmu.c

227

writel(filter, cspmu->base0 + PMEVFILT2R + offset);

drivers/perf/arm_cspmu/nvidia_cspmu.c

234

u32 filter = nv_cspmu_event_filter(event);

drivers/perf/arm_cspmu/nvidia_cspmu.c

236

writel(filter, cspmu->base0 + PMCCFILTR);

drivers/perf/arm_pmu.c

886

.filter = armpmu_filter,

drivers/perf/fsl_imx8_ddr_perf.c

224

PERF_FILTER_EXT_ATTR_ENTRY(filter, PERF_CAP_AXI_ID_FILTER),

drivers/pinctrl/samsung/pinctrl-exynos.c

399

static void exynos_eint_set_filter(struct samsung_pin_bank *bank, int filter)

drivers/pinctrl/samsung/pinctrl-exynos.c

403

unsigned int con = EXYNOS_FLTCON_EN | filter;

drivers/platform/chrome/cros_ec_sensorhub_ring.c

455

&sensorhub->filter, b, c);

drivers/platform/chrome/cros_ec_sensorhub_ring.c

457

&sensorhub->filter, a);

drivers/pwm/pwm-stm32.c

27

u32 filter;

drivers/pwm/pwm-stm32.c

710

bdtr = (bi->filter & TIM_BDTR_BKF_MASK) << shift | bke;

drivers/pwm/pwm-stm32.c

765

priv->breakinputs[i].filter > 15)

drivers/rapidio/devices/rio_mport_cdev.c

1394

if (((db_filter->filter.rioid == RIO_INVALID_DESTID ||

drivers/rapidio/devices/rio_mport_cdev.c

1395

db_filter->filter.rioid == src)) &&

drivers/rapidio/devices/rio_mport_cdev.c

1396

info >= db_filter->filter.low &&

drivers/rapidio/devices/rio_mport_cdev.c

1397

info <= db_filter->filter.high) {

drivers/rapidio/devices/rio_mport_cdev.c

1416

struct rio_doorbell_filter filter;

drivers/rapidio/devices/rio_mport_cdev.c

1420

if (copy_from_user(&filter, arg, sizeof(filter)))

drivers/rapidio/devices/rio_mport_cdev.c

1423

if (filter.low > filter.high)

drivers/rapidio/devices/rio_mport_cdev.c

1426

ret = rio_request_inb_dbell(md->mport, md, filter.low, filter.high,

drivers/rapidio/devices/rio_mport_cdev.c

1436

rio_release_inb_dbell(md->mport, filter.low, filter.high);

drivers/rapidio/devices/rio_mport_cdev.c

1440

db_filter->filter = filter;

drivers/rapidio/devices/rio_mport_cdev.c

1461

struct rio_doorbell_filter filter;

drivers/rapidio/devices/rio_mport_cdev.c

1465

if (copy_from_user(&filter, arg, sizeof(filter)))

drivers/rapidio/devices/rio_mport_cdev.c

1468

if (filter.low > filter.high)

drivers/rapidio/devices/rio_mport_cdev.c

1473

if (db_filter->filter.rioid == filter.rioid &&

drivers/rapidio/devices/rio_mport_cdev.c

1474

db_filter->filter.low == filter.low &&

drivers/rapidio/devices/rio_mport_cdev.c

1475

db_filter->filter.high == filter.high) {

drivers/rapidio/devices/rio_mport_cdev.c

1484

rio_release_inb_dbell(priv->md->mport, filter.low, filter.high);

drivers/rapidio/devices/rio_mport_cdev.c

1490

struct rio_pw_filter *filter)

drivers/rapidio/devices/rio_mport_cdev.c

1492

if ((msg->em.comptag & filter->mask) < filter->low ||

drivers/rapidio/devices/rio_mport_cdev.c

1493

(msg->em.comptag & filter->mask) > filter->high)

drivers/rapidio/devices/rio_mport_cdev.c

1513

if (rio_mport_match_pw(msg, &pw_filter->filter)) {

drivers/rapidio/devices/rio_mport_cdev.c

1535

struct rio_pw_filter filter;

drivers/rapidio/devices/rio_mport_cdev.c

1539

if (copy_from_user(&filter, arg, sizeof(filter)))

drivers/rapidio/devices/rio_mport_cdev.c

1546

pw_filter->filter = filter;

drivers/rapidio/devices/rio_mport_cdev.c

1592

struct rio_pw_filter filter;

drivers/rapidio/devices/rio_mport_cdev.c

1597

if (copy_from_user(&filter, arg, sizeof(filter)))

drivers/rapidio/devices/rio_mport_cdev.c

1602

if (rio_mport_match_pw_filter(&pw_filter->filter, &filter)) {

drivers/rapidio/devices/rio_mport_cdev.c

209

struct rio_pw_filter filter;

drivers/rapidio/devices/rio_mport_cdev.c

223

struct rio_doorbell_filter filter;

drivers/s390/cio/ccwreq.c

263

if (req->filter)

drivers/s390/cio/ccwreq.c

264

status = req->filter(cdev, req->data, irb, status);

drivers/s390/cio/device_pgid.c

541

req->filter = nop_filter;

drivers/s390/cio/io_sch.h

83

enum io_status (*filter)(struct ccw_device *, void *, struct irb *,

drivers/s390/scsi/zfcp_scsi.c

238

struct zfcp_scsi_req_filter *filter =

drivers/s390/scsi/zfcp_scsi.c

248

if (old_req->qtcb->header.port_handle != filter->port_handle)

drivers/s390/scsi/zfcp_scsi.c

251

if (filter->tmf_scope == FCP_TMF_LUN_RESET &&

drivers/s390/scsi/zfcp_scsi.c

252

old_req->qtcb->header.lun_handle != filter->lun_handle)

drivers/s390/scsi/zfcp_scsi.c

262

struct zfcp_scsi_req_filter filter = {

drivers/s390/scsi/zfcp_scsi.c

269

filter.tmf_scope = FCP_TMF_LUN_RESET;

drivers/s390/scsi/zfcp_scsi.c

270

filter.lun_handle = zsdev->lun_handle;

drivers/s390/scsi/zfcp_scsi.c

279

&filter);

drivers/scsi/aic7xxx/aic79xx_osm.c

920

bus_dma_filter_t *filter, void *filterarg,

drivers/scsi/aic7xxx/aic7xxx_osm.c

820

bus_dma_filter_t *filter, void *filterarg,

drivers/scsi/lpfc/lpfc_hbadisc.c

6379

__lpfc_find_node(struct lpfc_vport *vport, node_filter filter, void *param)

drivers/scsi/lpfc/lpfc_hbadisc.c

6384

if (filter(ndlp, param)) {

drivers/scsi/lpfc/lpfc_hbadisc.c

6389

filter, ndlp, ndlp->nlp_DID,

drivers/scsi/lpfc/lpfc_hbadisc.c

6397

"3186 FIND node filter %ps NOT FOUND.\n", filter);

drivers/staging/media/av7110/av7110.c

1023

ret = StopHWFilter(feed->filter);

drivers/staging/media/av7110/av7110.c

1033

if (demux->filter[i].state == DMX_STATE_GO &&

drivers/staging/media/av7110/av7110.c

1034

demux->filter[i].filter.parent == &feed->feed.sec) {

drivers/staging/media/av7110/av7110.c

1035

demux->filter[i].state = DMX_STATE_READY;

drivers/staging/media/av7110/av7110.c

1037

rc = StopHWFilter(&demux->filter[i]);

drivers/staging/media/av7110/av7110.c

1070

if (dvbdmx->filter[j].type != DMX_TYPE_SEC)

drivers/staging/media/av7110/av7110.c

1072

if (dvbdmx->filter[j].filter.parent != &feed->feed.sec)

drivers/staging/media/av7110/av7110.c

1074

if (dvbdmx->filter[j].state == DMX_STATE_GO)

drivers/staging/media/av7110/av7110.c

1075

dvbdmx->filter[j].state = DMX_STATE_READY;

drivers/staging/media/av7110/av7110.c

285

struct dmx_section_filter *filter = &dvbdmxfilter->filter;

drivers/staging/media/av7110/av7110.c

290

xor = filter->filter_value[i] ^ buffer1[i];

drivers/staging/media/av7110/av7110.c

298

&dvbdmxfilter->filter, NULL);

drivers/staging/media/av7110/av7110.c

775

buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) |

drivers/staging/media/av7110/av7110.c

779

(dvbdmxfilter->filter.filter_value[i] << 8) |

drivers/staging/media/av7110/av7110.c

865

ret = StartHWFilter(dvbdmxfeed->filter);

drivers/staging/media/av7110/av7110.c

919

ret = StopHWFilter(dvbdmxfeed->filter);

drivers/staging/media/av7110/av7110.c

971

ret = StartHWFilter(feed->filter);

drivers/staging/media/av7110/av7110.c

984

if (demux->filter[i].state != DMX_STATE_READY)

drivers/staging/media/av7110/av7110.c

986

if (demux->filter[i].type != DMX_TYPE_SEC)

drivers/staging/media/av7110/av7110.c

988

if (demux->filter[i].filter.parent != &feed->feed.sec)

drivers/staging/media/av7110/av7110.c

990

demux->filter[i].state = DMX_STATE_GO;

drivers/staging/media/av7110/av7110.c

992

ret = StartHWFilter(&demux->filter[i]);

drivers/tty/hvc/hvc_iucv.c

1128

static const char *hvc_iucv_parse_filter(const char *filter, char *dest)

drivers/tty/hvc/hvc_iucv.c

1133

nextdelim = strchr(filter, ',');

drivers/tty/hvc/hvc_iucv.c

1135

len = nextdelim - filter;

drivers/tty/hvc/hvc_iucv.c

1138

len = strlen(filter);

drivers/tty/hvc/hvc_iucv.c

1139

residual = filter + len;

drivers/tty/hvc/hvc_iucv.c

1146

if (filter[len - 1] == '\n')

drivers/tty/hvc/hvc_iucv.c

1150

if (len == 1 && *filter == FILTER_WILDCARD_CHAR)

drivers/tty/hvc/hvc_iucv.c

1159

dest[len] = toupper(filter[len]);

drivers/tty/serial/pch_uart.c

688

chan = dma_request_channel(mask, filter, param);

drivers/tty/serial/pch_uart.c

703

chan = dma_request_channel(mask, filter, param);

drivers/tty/sysrq.c

1035

.filter = sysrq_filter,

drivers/usb/gadget/function/rndis.c

313

*outbuf = cpu_to_le32(*params->filter);

drivers/usb/gadget/function/rndis.c

516

*params->filter = (u16)get_unaligned_le32(buf);

drivers/usb/gadget/function/rndis.c

518

__func__, *params->filter);

drivers/usb/gadget/function/rndis.c

525

if (*params->filter) {

drivers/usb/gadget/function/rndis.c

967

params->filter = cdc_filter;

drivers/usb/gadget/function/rndis.h

169

u16 *filter;

drivers/virt/vboxguest/vboxguest_core.c

1594

struct vbg_ioctl_change_filter *filter)

drivers/virt/vboxguest/vboxguest_core.c

1598

if (vbg_ioctl_chk(&filter->hdr, sizeof(filter->u.in), 0))

drivers/virt/vboxguest/vboxguest_core.c

1601

or_mask = filter->u.in.or_mask;

drivers/virt/vboxguest/vboxguest_core.c

1602

not_mask = filter->u.in.not_mask;

fs/bpf_fs_kfuncs.c

409

.filter = bpf_fs_kfuncs_filter,

fs/select.c

854

__poll_t mask, filter;

fs/select.c

864

filter = demangle_poll(pollfd->events) | EPOLLERR | EPOLLHUP;

fs/select.c

865

pwait->_key = filter | busy_flag;

fs/select.c

869

return mask & filter; /* Mask out unneeded events. */

fs/smb/client/cifsglob.h

1793

__u32 filter; /* CompletionFilter (for multishot) */

fs/verity/measure.c

180

.filter = bpf_get_fsverity_digest_filter,

include/kunit/attributes.h

24

const char *kunit_attr_filter_name(struct kunit_attr_filter filter);

include/kunit/attributes.h

48

struct kunit_attr_filter filter, char *action, int *err);

include/linux/btf.h

124

btf_kfunc_filter_t filter;

include/linux/connector.h

103

netlink_filter_fn filter,

include/linux/dmaengine.h

874

struct dma_filter filter;

include/linux/filter.h

1075

#define bpf_classic_proglen(fprog) (fprog->len * sizeof(fprog->filter[0]))

include/linux/filter.h

1132

typedef int (*bpf_aux_classic_check_t)(struct sock_filter *filter,

include/linux/filter.h

654

compat_uptr_t filter; /* struct sock_filter * */

include/linux/filter.h

659

struct sock_filter *filter;

include/linux/fprobe.h

100

static inline int register_fprobe(struct fprobe *fp, const char *filter, const char *notfilter)

include/linux/fprobe.h

120

static inline int fprobe_count_ips_from_filter(const char *filter, const char *notfilter)

include/linux/fprobe.h

93

int register_fprobe(struct fprobe *fp, const char *filter, const char *notfilter);

include/linux/fprobe.h

98

int fprobe_count_ips_from_filter(const char *filter, const char *notfilter);

include/linux/i8042.h

101

static inline int i8042_remove_filter(i8042_filter_t filter)

include/linux/i8042.h

78

int i8042_install_filter(i8042_filter_t filter, void *context);

include/linux/i8042.h

79

int i8042_remove_filter(i8042_filter_t filter);

include/linux/i8042.h

96

static inline int i8042_install_filter(i8042_filter_t filter, void *context)

include/linux/input.h

322

bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);

include/linux/ipv6.h

311

struct icmp6_filter filter;

include/linux/kobject.h

134

int (* const filter)(const struct kobject *kobj);

include/linux/mroute_base.h

300

spinlock_t *lock, struct fib_dump_filter *filter);

include/linux/mroute_base.h

308

spinlock_t *lock, struct fib_dump_filter *filter);

include/linux/mroute_base.h

359

spinlock_t *lock, struct fib_dump_filter *filter)

include/linux/msi.h

240

enum msi_desc_filter filter);

include/linux/msi.h

254

enum msi_desc_filter filter)

include/linux/msi.h

256

return msi_domain_first_desc(dev, MSI_DEFAULT_DOMAIN, filter);

include/linux/msi.h

260

enum msi_desc_filter filter);

include/linux/msi.h

275

#define msi_domain_for_each_desc(desc, dev, domid, filter) \

include/linux/msi.h

276

for ((desc) = msi_domain_first_desc((dev), (domid), (filter)); (desc); \

include/linux/msi.h

277

(desc) = msi_next_desc((dev), (domid), (filter)))

include/linux/msi.h

291

#define msi_for_each_desc(desc, dev, filter) \

include/linux/msi.h

292

msi_domain_for_each_desc((desc), (dev), MSI_DEFAULT_DOMAIN, (filter))

include/linux/netlink.h

237

netlink_filter_fn filter,

include/linux/perf_event.h

586

bool (*filter) (struct pmu *pmu, int cpu); /* optional */

include/linux/perf_event.h

911

struct event_filter *filter;

include/linux/platform_data/cros_ec_sensorhub.h

170

struct cros_ec_sensors_ts_filter_state filter;

include/linux/seccomp_types.h

25

struct seccomp_filter *filter;

include/linux/trace_events.h

729

extern int filter_match_preds(struct event_filter *filter, void *rec);

include/linux/uprobes.h

58

bool (*filter)(struct uprobe_consumer *self, struct mm_struct *mm);

include/linux/watch_queue.h

40

struct watch_filter __rcu *filter;

include/linux/xarray.h

531

#define xa_for_each_marked(xa, index, entry, filter) \

include/linux/xarray.h

532

for (index = 0, entry = xa_find(xa, &index, ULONG_MAX, filter); \

include/linux/xarray.h

533

entry; entry = xa_find_after(xa, &index, ULONG_MAX, filter))

include/media/demux.h

182

struct dmx_section_filter **filter);

include/media/demux.h

184

struct dmx_section_filter *filter);

include/media/dmxdev.h

127

} filter;

include/media/dmxdev.h

177

struct dmxdev_filter *filter;

include/media/dvb_demux.h

148

struct dvb_demux_filter *filter;

include/media/dvb_demux.h

218

struct dvb_demux_filter *filter;

include/media/dvb_demux.h

79

struct dmx_section_filter filter;

include/media/rc-core.h

216

struct rc_scancode_filter *filter);

include/media/rc-core.h

218

struct rc_scancode_filter *filter);

include/media/v4l2-ctrls.h

815

v4l2_ctrl_filter filter,

include/media/v4l2-vp9.h

132

u32 (*filter)[4][3];

include/net/bluetooth/l2cap.h

639

int (*filter) (struct l2cap_chan * chan,

include/net/cfg80211.h

4077

const u8 *filter;

include/net/genetlink.h

489

netlink_filter_fn filter,

include/net/genetlink.h

496

flags, filter, filter_data);

include/net/ip6_route.h

203

struct fib_dump_filter filter;

include/net/ip_fib.h

286

struct netlink_callback *cb, struct fib_dump_filter *filter);

include/net/ip_fib.h

654

struct fib_dump_filter *filter,

include/net/netlink.h

1158

netlink_filter_fn filter,

include/net/netlink.h

1166

filter, filter_data);

include/net/pkt_cls.h

101

if (arg->count >= arg->skip && arg->fn(tp, filter, arg) < 0) {

include/net/pkt_cls.h

99

void *filter)

include/net/raw.h

82

struct icmp_filter filter;

include/net/rawv6.h

22

int rawv6_mh_filter_register(int (*filter)(struct sock *sock,

include/net/rawv6.h

24

int rawv6_mh_filter_unregister(int (*filter)(struct sock *sock,

include/net/rps.h

33

u16 filter;

include/net/tc_act/tc_bpf.h

14

struct bpf_prog __rcu *filter;

include/net/xfrm.h

130

struct xfrm_address_filter *filter;

include/net/xfrm.h

1681

struct xfrm_address_filter *filter);

include/rdma/ib_cache.h

27

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

include/soc/mscc/ocelot_vcap.h

728

struct ocelot_vcap_filter *filter);

include/sound/designware_i2s.h

45

bool (*filter)(struct dma_chan *chan, void *slave);

include/sound/designware_i2s.h

55

bool (*filter)(struct dma_chan *chan, void *slave);

include/sound/spear_spdif.h

12

bool (*filter)(struct dma_chan *chan, void *slave);

include/sound/ump_msg.h

674

u32 filter:8;

include/sound/ump_msg.h

679

u32 filter:8;

include/uapi/linux/atmbr2684.h

107

struct br2684_filter filter;

include/uapi/linux/dvb/dmx.h

135

__u8 filter[DMX_FILTER_SIZE];

include/uapi/linux/dvb/dmx.h

160

struct dmx_filter filter;

include/uapi/linux/filter.h

33

struct sock_filter __user *filter;

include/uapi/linux/io_uring/bpf_filter.h

64

struct io_uring_bpf_filter filter;

include/uapi/linux/netfilter/xt_bpf.h

19

struct bpf_prog *filter __attribute__((aligned(8)));

include/uapi/linux/netfilter/xt_bpf.h

39

struct bpf_prog *filter __attribute__((aligned(8)));

include/uapi/linux/tipc.h

120

__u32 filter; /* bitmask of filter options */

include/uapi/sound/asequencer.h

367

unsigned int filter; /* filter flags */

include/uapi/sound/asound.h

967

unsigned int filter; /* event filter (bitmask of SNDRV_TIMER_EVENT_*) */

io_uring/bpf_filter.c

105

filter = filters->filters;

io_uring/bpf_filter.c

106

if (!filter)

io_uring/bpf_filter.c

114

f = rcu_dereference(filter[i]);

io_uring/bpf_filter.c

174

static int io_uring_check_cbpf_filter(struct sock_filter *filter,

io_uring/bpf_filter.c

180

struct sock_filter *ftest = &filter[pc];

io_uring/bpf_filter.c

326

if (reg->filter.opcode >= IORING_OP_LAST)

io_uring/bpf_filter.c

328

if (reg->filter.flags & ~IO_URING_BPF_FILTER_FLAGS)

io_uring/bpf_filter.c

330

if (!mem_is_zero(reg->filter.resv, sizeof(reg->filter.resv)))

io_uring/bpf_filter.c

332

if (!mem_is_zero(reg->filter.resv2, sizeof(reg->filter.resv2)))

io_uring/bpf_filter.c

334

if (!reg->filter.filter_len || reg->filter.filter_len > BPF_MAXINSNS)

io_uring/bpf_filter.c

338

def = &io_issue_defs[array_index_nospec(reg->filter.opcode, IORING_OP_LAST)];

io_uring/bpf_filter.c

342

if (reg->filter.pdu_size == def->filter_pdu_size)

io_uring/bpf_filter.c

345

else if (reg->filter.flags & IO_URING_BPF_FILTER_SZ_STRICT)

io_uring/bpf_filter.c

348

else if (reg->filter.pdu_size > def->filter_pdu_size)

io_uring/bpf_filter.c

352

reg->filter.pdu_size = def->filter_pdu_size;

io_uring/bpf_filter.c

353

if (copy_to_user(&arg->filter, &reg->filter, sizeof(reg->filter)))

io_uring/bpf_filter.c

363

struct io_bpf_filter *filter, *old_filter;

io_uring/bpf_filter.c

373

fprog.len = reg.filter.filter_len;

io_uring/bpf_filter.c

374

fprog.filter = u64_to_user_ptr(reg.filter.filter_ptr);

io_uring/bpf_filter.c

404

filter = kzalloc_obj(*filter, GFP_KERNEL_ACCOUNT);

io_uring/bpf_filter.c

405

if (!filter) {

io_uring/bpf_filter.c

409

refcount_set(&filter->refs, 1);

io_uring/bpf_filter.c

410

filter->prog = prog;

io_uring/bpf_filter.c

428

old_filter = rcu_dereference(filters->filters[reg.filter.opcode]);

io_uring/bpf_filter.c

430

filter->next = old_filter;

io_uring/bpf_filter.c

431

rcu_assign_pointer(filters->filters[reg.filter.opcode], filter);

io_uring/bpf_filter.c

437

if (reg.filter.flags & IO_URING_BPF_FILTER_DENY_REST) {

io_uring/bpf_filter.c

439

if (i == reg.filter.opcode)

io_uring/bpf_filter.c

60

struct io_bpf_filter *filter;

io_uring/bpf_filter.c

73

filter = rcu_dereference(filters[req->opcode]);

io_uring/bpf_filter.c

74

if (!filter)

io_uring/bpf_filter.c

76

else if (filter == &dummy_filter)

io_uring/bpf_filter.c

86

if (filter == &dummy_filter)

io_uring/bpf_filter.c

88

ret = bpf_prog_run_pin_on_cpu(filter->prog, &bpf_ctx);

io_uring/bpf_filter.c

91

filter = filter->next;

io_uring/bpf_filter.c

92

} while (filter);

io_uring/bpf_filter.c

99

struct io_bpf_filter __rcu **filter;

kernel/bpf/btf.c

8674

bool add_filter = !!kset->filter;

kernel/bpf/btf.c

8695

if (hook_filter->filters[i] == kset->filter) {

kernel/bpf/btf.c

8771

hook_filter->filters[hook_filter->nr_filters++] = kset->filter;

kernel/events/core.c

11299

if (likely(!event->filter) || filter_match_preds(event->filter, record))

kernel/events/core.c

11745

struct perf_addr_filter *filter;

kernel/events/core.c

11747

filter = kzalloc_node(sizeof(*filter), GFP_KERNEL, node);

kernel/events/core.c

11748

if (!filter)

kernel/events/core.c

11751

INIT_LIST_HEAD(&filter->entry);

kernel/events/core.c

11752

list_add_tail(&filter->entry, filters);

kernel/events/core.c

11754

return filter;

kernel/events/core.c

11759

struct perf_addr_filter *filter, *iter;

kernel/events/core.c

11761

list_for_each_entry_safe(filter, iter, filters, entry) {

kernel/events/core.c

11762

path_put(&filter->path);

kernel/events/core.c

11763

list_del(&filter->entry);

kernel/events/core.c

11764

kfree(filter);

kernel/events/core.c

11811

static void perf_addr_filter_apply(struct perf_addr_filter *filter,

kernel/events/core.c

11822

if (perf_addr_filter_vma_adjust(filter, vma, fr))

kernel/events/core.c

11835

struct perf_addr_filter *filter;

kernel/events/core.c

11856

list_for_each_entry(filter, &ifh->list, entry) {

kernel/events/core.c

11857

if (filter->path.dentry) {

kernel/events/core.c

11865

perf_addr_filter_apply(filter, mm, &event->addr_filter_ranges[count]);

kernel/events/core.c

11867

event->addr_filter_ranges[count].start = filter->offset;

kernel/events/core.c

11868

event->addr_filter_ranges[count].size = filter->size;

kernel/events/core.c

11941

struct perf_addr_filter *filter = NULL;

kernel/events/core.c

11965

filter = perf_addr_filter_new(event, filters);

kernel/events/core.c

11966

if (!filter)

kernel/events/core.c

11978

filter->action = actions[token];

kernel/events/core.c

11993

ret = kstrtoul(args[0].from, 0, &filter->offset);

kernel/events/core.c

11999

ret = kstrtoul(args[1].from, 0, &filter->size);

kernel/events/core.c

12034

if (filter->action == PERF_ADDR_FILTER_ACTION_FILTER &&

kernel/events/core.c

12035

!filter->size)

kernel/events/core.c

12056

&filter->path);

kernel/events/core.c

12061

if (!filter->path.dentry ||

kernel/events/core.c

12062

!S_ISREG(d_inode(filter->path.dentry)

kernel/events/core.c

12073

filter = NULL;

kernel/events/core.c

4016

if (pmu->filter && pmu->filter(pmu, cpu))

kernel/events/core.c

8968

struct perf_addr_filter *filter;

kernel/events/core.c

8976

list_for_each_entry(filter, &ifh->list, entry) {

kernel/events/core.c

8977

if (filter->path.dentry) {

kernel/events/core.c

9795

static bool perf_addr_filter_match(struct perf_addr_filter *filter,

kernel/events/core.c

9800

if (!filter->path.dentry)

kernel/events/core.c

9803

if (d_inode(filter->path.dentry) != file_user_inode(file))

kernel/events/core.c

9806

if (filter->offset > offset + size)

kernel/events/core.c

9809

if (filter->offset + filter->size < offset)

kernel/events/core.c

9815

static bool perf_addr_filter_vma_adjust(struct perf_addr_filter *filter,

kernel/events/core.c

9823

if (!perf_addr_filter_match(filter, file, off, vma_size))

kernel/events/core.c

9826

if (filter->offset < off) {

kernel/events/core.c

9828

fr->size = min(vma_size, filter->size - (off - filter->offset));

kernel/events/core.c

9830

fr->start = vma->vm_start + filter->offset - off;

kernel/events/core.c

9831

fr->size = min(vma->vm_end - fr->start, filter->size);

kernel/events/core.c

9841

struct perf_addr_filter *filter;

kernel/events/core.c

9852

list_for_each_entry(filter, &ifh->list, entry) {

kernel/events/core.c

9853

if (perf_addr_filter_vma_adjust(filter, vma,

kernel/events/uprobes.c

1132

return !uc->filter || uc->filter(uc, mm);

kernel/fork.c

532

WARN_ON_ONCE(tsk->seccomp.filter);

kernel/fork.c

944

tsk->seccomp.filter = NULL;

kernel/irq/msi.c

167

static bool msi_desc_match(struct msi_desc *desc, enum msi_desc_filter filter)

kernel/irq/msi.c

169

switch (filter) {

kernel/irq/msi.c

373

enum msi_desc_filter filter)

kernel/irq/msi.c

379

if (msi_desc_match(desc, filter))

kernel/irq/msi.c

399

enum msi_desc_filter filter)

kernel/irq/msi.c

409

return msi_find_desc(md, domid, filter);

kernel/irq/msi.c

428

enum msi_desc_filter filter)

kernel/irq/msi.c

441

return msi_find_desc(md, domid, filter);

kernel/params.c

933

.filter = uevent_filter,

kernel/seccomp.c

1113

static u64 seccomp_next_notify_id(struct seccomp_filter *filter)

kernel/seccomp.c

1119

lockdep_assert_held(&filter->notify_lock);

kernel/seccomp.c

1120

return filter->notif->next_id++;

kernel/seccomp.c

1451

static void seccomp_notify_free(struct seccomp_filter *filter)

kernel/seccomp.c

1453

kfree(filter->notif);

kernel/seccomp.c

1454

filter->notif = NULL;

kernel/seccomp.c

1457

static void seccomp_notify_detach(struct seccomp_filter *filter)

kernel/seccomp.c

1461

if (!filter)

kernel/seccomp.c

1464

mutex_lock(&filter->notify_lock);

kernel/seccomp.c

1470

list_for_each_entry(knotif, &filter->notif->notifications, list) {

kernel/seccomp.c

1486

seccomp_notify_free(filter);

kernel/seccomp.c

1487

mutex_unlock(&filter->notify_lock);

kernel/seccomp.c

1492

struct seccomp_filter *filter = file->private_data;

kernel/seccomp.c

1494

seccomp_notify_detach(filter);

kernel/seccomp.c

1495

__put_seccomp_filter(filter);

kernel/seccomp.c

1501

find_notification(struct seccomp_filter *filter, u64 id)

kernel/seccomp.c

1505

lockdep_assert_held(&filter->notify_lock);

kernel/seccomp.c

1507

list_for_each_entry(cur, &filter->notif->notifications, list) {

kernel/seccomp.c

1524

static int recv_wait_event(struct seccomp_filter *filter)

kernel/seccomp.c

1529

if (refcount_read(&filter->users) == 0)

kernel/seccomp.c

1532

if (atomic_dec_if_positive(&filter->notif->requests) >= 0)

kernel/seccomp.c

1536

ret = prepare_to_wait_event(&filter->wqh, &wait, TASK_INTERRUPTIBLE);

kernel/seccomp.c

1538

if (atomic_dec_if_positive(&filter->notif->requests) >= 0)

kernel/seccomp.c

1540

if (refcount_read(&filter->users) == 0)

kernel/seccomp.c

1548

finish_wait(&filter->wqh, &wait);

kernel/seccomp.c

1552

static long seccomp_notify_recv(struct seccomp_filter *filter,

kernel/seccomp.c

1568

ret = recv_wait_event(filter);

kernel/seccomp.c

1572

mutex_lock(&filter->notify_lock);

kernel/seccomp.c

1573

list_for_each_entry(cur, &filter->notif->notifications, list) {

kernel/seccomp.c

1595

wake_up_poll(&filter->wqh, EPOLLOUT | EPOLLWRNORM);

kernel/seccomp.c

1598

mutex_unlock(&filter->notify_lock);

kernel/seccomp.c

1609

mutex_lock(&filter->notify_lock);

kernel/seccomp.c

1610

knotif = find_notification(filter, unotif.id);

kernel/seccomp.c

1613

if (should_sleep_killable(filter, knotif))

kernel/seccomp.c

1616

atomic_inc(&filter->notif->requests);

kernel/seccomp.c

1617

wake_up_poll(&filter->wqh, EPOLLIN | EPOLLRDNORM);

kernel/seccomp.c

1619

mutex_unlock(&filter->notify_lock);

kernel/seccomp.c

1625

static long seccomp_notify_send(struct seccomp_filter *filter,

kernel/seccomp.c

1642

ret = mutex_lock_interruptible(&filter->notify_lock);

kernel/seccomp.c

1646

knotif = find_notification(filter, resp.id);

kernel/seccomp.c

1663

if (filter->notif->flags & SECCOMP_USER_NOTIF_FD_SYNC_WAKE_UP)

kernel/seccomp.c

1668

mutex_unlock(&filter->notify_lock);

kernel/seccomp.c

1672

static long seccomp_notify_id_valid(struct seccomp_filter *filter,

kernel/seccomp.c

1682

ret = mutex_lock_interruptible(&filter->notify_lock);

kernel/seccomp.c

1686

knotif = find_notification(filter, id);

kernel/seccomp.c

1692

mutex_unlock(&filter->notify_lock);

kernel/seccomp.c

1696

static long seccomp_notify_set_flags(struct seccomp_filter *filter,

kernel/seccomp.c

1704

ret = mutex_lock_interruptible(&filter->notify_lock);

kernel/seccomp.c

1707

filter->notif->flags = flags;

kernel/seccomp.c

1708

mutex_unlock(&filter->notify_lock);

kernel/seccomp.c

1712

static long seccomp_notify_addfd(struct seccomp_filter *filter,

kernel/seccomp.c

1750

ret = mutex_lock_interruptible(&filter->notify_lock);

kernel/seccomp.c

1754

knotif = find_notification(filter, addfd.id);

kernel/seccomp.c

1789

mutex_unlock(&filter->notify_lock);

kernel/seccomp.c

1805

mutex_lock(&filter->notify_lock);

kernel/seccomp.c

1819

mutex_unlock(&filter->notify_lock);

kernel/seccomp.c

1829

struct seccomp_filter *filter = file->private_data;

kernel/seccomp.c

1835

return seccomp_notify_recv(filter, buf);

kernel/seccomp.c

1837

return seccomp_notify_send(filter, buf);

kernel/seccomp.c

1840

return seccomp_notify_id_valid(filter, buf);

kernel/seccomp.c

1842

return seccomp_notify_set_flags(filter, arg);

kernel/seccomp.c

1849

return seccomp_notify_addfd(filter, buf, _IOC_SIZE(cmd));

kernel/seccomp.c

1858

struct seccomp_filter *filter = file->private_data;

kernel/seccomp.c

1862

poll_wait(file, &filter->wqh, poll_tab);

kernel/seccomp.c

1864

if (mutex_lock_interruptible(&filter->notify_lock) < 0)

kernel/seccomp.c

1867

list_for_each_entry(cur, &filter->notif->notifications, list) {

kernel/seccomp.c

1876

mutex_unlock(&filter->notify_lock);

kernel/seccomp.c

1878

if (refcount_read(&filter->users) == 0)

kernel/seccomp.c

1891

static struct file *init_listener(struct seccomp_filter *filter)

kernel/seccomp.c

1896

filter->notif = kzalloc_obj(*(filter->notif));

kernel/seccomp.c

1897

if (!filter->notif)

kernel/seccomp.c

1900

filter->notif->next_id = get_random_u64();

kernel/seccomp.c

1901

INIT_LIST_HEAD(&filter->notif->notifications);

kernel/seccomp.c

1904

filter, O_RDWR);

kernel/seccomp.c

1909

__get_seccomp_filter(filter);

kernel/seccomp.c

1913

seccomp_notify_free(filter);

kernel/seccomp.c

1935

for (cur = current->seccomp.filter; cur; cur = cur->prev) {

kernel/seccomp.c

1957

const char __user *filter)

kernel/seccomp.c

1990

prepared = seccomp_prepare_user_filter(filter);

kernel/seccomp.c

2056

const char __user *filter)

kernel/seccomp.c

2139

long prctl_set_seccomp(unsigned long seccomp_mode, void __user *filter)

kernel/seccomp.c

2156

uargs = filter;

kernel/seccomp.c

2170

struct seccomp_filter *orig, *filter;

kernel/seccomp.c

2184

orig = task->seccomp.filter;

kernel/seccomp.c

2189

for (filter = orig; filter; filter = filter->prev)

kernel/seccomp.c

2193

filter = ERR_PTR(-ENOENT);

kernel/seccomp.c

2198

for (filter = orig; filter && count > 1; filter = filter->prev)

kernel/seccomp.c

2201

if (WARN_ON(count != 1 || !filter)) {

kernel/seccomp.c

2202

filter = ERR_PTR(-ENOENT);

kernel/seccomp.c

2206

__get_seccomp_filter(filter);

kernel/seccomp.c

2210

return filter;

kernel/seccomp.c

2216

struct seccomp_filter *filter;

kernel/seccomp.c

2225

filter = get_nth_filter(task, filter_off);

kernel/seccomp.c

2226

if (IS_ERR(filter))

kernel/seccomp.c

2227

return PTR_ERR(filter);

kernel/seccomp.c

2229

fprog = filter->prog->orig_prog;

kernel/seccomp.c

2243

if (copy_to_user(data, fprog->filter, bpf_classic_proglen(fprog)))

kernel/seccomp.c

2247

__put_seccomp_filter(filter);

kernel/seccomp.c

2255

struct seccomp_filter *filter;

kernel/seccomp.c

2271

filter = get_nth_filter(task, kmd.filter_off);

kernel/seccomp.c

2272

if (IS_ERR(filter))

kernel/seccomp.c

2273

return PTR_ERR(filter);

kernel/seccomp.c

2275

if (filter->log)

kernel/seccomp.c

2282

__put_seccomp_filter(filter);

kernel/seccomp.c

2546

f = READ_ONCE(task->seccomp.filter);

kernel/seccomp.c

278

static int seccomp_check_filter(struct sock_filter *filter, unsigned int flen)

kernel/seccomp.c

282

struct sock_filter *ftest = &filter[pc];

kernel/seccomp.c

410

READ_ONCE(current->seccomp.filter);

kernel/seccomp.c

509

is_ancestor(thread->seccomp.filter,

kernel/seccomp.c

510

caller->seccomp.filter)))

kernel/seccomp.c

524

static inline void seccomp_filter_free(struct seccomp_filter *filter)

kernel/seccomp.c

526

if (filter) {

kernel/seccomp.c

527

bpf_prog_destroy(filter->prog);

kernel/seccomp.c

528

kfree(filter);

kernel/seccomp.c

577

if (READ_ONCE(tsk->seccomp.filter) == NULL)

kernel/seccomp.c

581

orig = tsk->seccomp.filter;

kernel/seccomp.c

583

tsk->seccomp.filter = NULL;

kernel/seccomp.c

634

__seccomp_filter_release(thread->seccomp.filter);

kernel/seccomp.c

637

smp_store_release(&thread->seccomp.filter,

kernel/seccomp.c

638

caller->seccomp.filter);

kernel/seccomp.c

725

struct seccomp_filter *filter = ERR_PTR(-EFAULT);

kernel/seccomp.c

733

fprog.filter = compat_ptr(fprog32.filter);

kernel/seccomp.c

738

filter = seccomp_prepare_filter(&fprog);

kernel/seccomp.c

740

return filter;

kernel/seccomp.c

785

struct sock_filter *insn = &fprog->filter[pc];

kernel/seccomp.c

922

struct seccomp_filter *filter)

kernel/seccomp.c

930

total_insns = filter->prog->len;

kernel/seccomp.c

931

for (walker = current->seccomp.filter; walker; walker = walker->prev)

kernel/seccomp.c

951

filter->log = true;

kernel/seccomp.c

955

filter->wait_killable_recv = true;

kernel/seccomp.c

961

filter->prev = current->seccomp.filter;

kernel/seccomp.c

962

seccomp_cache_prepare(filter);

kernel/seccomp.c

963

current->seccomp.filter = filter;

kernel/seccomp.c

973

static void __get_seccomp_filter(struct seccomp_filter *filter)

kernel/seccomp.c

975

refcount_inc(&filter->refs);

kernel/seccomp.c

981

struct seccomp_filter *orig = tsk->seccomp.filter;

kernel/trace/bpf_trace.c

3280

uprobes[i].consumer.filter = uprobe_multi_link_filter;

kernel/trace/bpf_trace.c

3376

.filter = bpf_session_filter,

kernel/trace/fprobe.c

667

const char *filter;

kernel/trace/fprobe.c

679

if (!glob_match(match->filter, name) ||

kernel/trace/fprobe.c

708

static int get_ips_from_filter(const char *filter, const char *notfilter,

kernel/trace/fprobe.c

712

struct filter_match_data match = { .filter = filter, .notfilter = notfilter,

kernel/trace/fprobe.c

775

int fprobe_count_ips_from_filter(const char *filter, const char *notfilter)

kernel/trace/fprobe.c

777

return get_ips_from_filter(filter, notfilter, NULL, NULL, FPROBE_IPS_MAX);

kernel/trace/fprobe.c

791

int register_fprobe(struct fprobe *fp, const char *filter, const char *notfilter)

kernel/trace/fprobe.c

797

if (!fp || !filter)

kernel/trace/fprobe.c

800

num = get_ips_from_filter(filter, notfilter, NULL, NULL, FPROBE_IPS_MAX);

kernel/trace/fprobe.c

812

ret = get_ips_from_filter(filter, notfilter, addrs, mods, num);

kernel/trace/trace.c

2432

!filter_match_preds(file->filter, fbuffer->entry)))

kernel/trace/trace.h

1531

struct event_filter *filter;

kernel/trace/trace.h

1681

!filter_match_preds(file->filter, entry))

kernel/trace/trace.h

1784

extern void free_event_filter(struct event_filter *filter);

kernel/trace/trace.h

1862

struct event_filter __rcu *filter;

kernel/trace/trace.h

1931

char **filter, bool param_required);

kernel/trace/trace_eprobe.c

528

struct event_filter *filter = NULL;

kernel/trace/trace_eprobe.c

553

ep->filter_str, false, &filter);

kernel/trace/trace_eprobe.c

557

RCU_INIT_POINTER(trigger->filter, filter);

kernel/trace/trace_eprobe.c

565

free_event_filter(filter);

kernel/trace/trace_eprobe.c

602

struct event_filter *filter;

kernel/trace/trace_eprobe.c

629

filter = rcu_access_pointer(trigger->filter);

kernel/trace/trace_eprobe.c

631

if (filter)

kernel/trace/trace_eprobe.c

632

free_event_filter(filter);

kernel/trace/trace_events.c

1228

struct event_filter *filter = system->filter;

kernel/trace/trace_events.c

1236

if (filter) {

kernel/trace/trace_events.c

1237

kfree(filter->filter_string);

kernel/trace/trace_events.c

1238

kfree(filter);

kernel/trace/trace_events.c

1313

free_event_filter(file->filter);

kernel/trace/trace_events.c

1711

struct event_filter *filter;

kernel/trace/trace_events.c

1715

filter = rcu_dereference(file->filter);

kernel/trace/trace_events.c

1716

if (!filter || !filter->filter_string)

kernel/trace/trace_events.c

1722

trace_event_name(call), len, "", filter->filter_string);

kernel/trace/trace_events.c

2897

system->filter = kzalloc_obj(struct event_filter);

kernel/trace/trace_events.c

2898

if (!system->filter)

kernel/trace/trace_events_filter.c

1171

int filter_match_preds(struct event_filter *filter, void *rec)

kernel/trace/trace_events_filter.c

1177

if (!filter)

kernel/trace/trace_events_filter.c

1181

prog = rcu_dereference_raw(filter->prog);

kernel/trace/trace_events_filter.c

1195

static void remove_filter_string(struct event_filter *filter)

kernel/trace/trace_events_filter.c

1197

if (!filter)

kernel/trace/trace_events_filter.c

1200

kfree(filter->filter_string);

kernel/trace/trace_events_filter.c

1201

filter->filter_string = NULL;

kernel/trace/trace_events_filter.c

1206

struct event_filter *filter)

kernel/trace/trace_events_filter.c

1213

if (WARN_ON(!filter->filter_string))

kernel/trace/trace_events_filter.c

1221

len = strlen(filter->filter_string);

kernel/trace/trace_events_filter.c

1229

trace_seq_puts(s, filter->filter_string);

kernel/trace/trace_events_filter.c

1234

filter->filter_string, err_text,

kernel/trace/trace_events_filter.c

1239

filter->filter_string, err_text,

kernel/trace/trace_events_filter.c

1245

kfree(filter->filter_string);

kernel/trace/trace_events_filter.c

1246

filter->filter_string = buf;

kernel/trace/trace_events_filter.c

1253

return rcu_dereference_protected(file->filter,

kernel/trace/trace_events_filter.c

1261

struct event_filter *filter = event_filter(file);

kernel/trace/trace_events_filter.c

1263

if (filter && filter->filter_string)

kernel/trace/trace_events_filter.c

1264

trace_seq_printf(s, "%s\n", filter->filter_string);

kernel/trace/trace_events_filter.c

1272

struct event_filter *filter;

kernel/trace/trace_events_filter.c

1275

filter = system->filter;

kernel/trace/trace_events_filter.c

1276

if (filter && filter->filter_string)

kernel/trace/trace_events_filter.c

1277

trace_seq_printf(s, "%s\n", filter->filter_string);

kernel/trace/trace_events_filter.c

1283

static void free_prog(struct event_filter *filter)

kernel/trace/trace_events_filter.c

1288

prog = rcu_access_pointer(filter->prog);

kernel/trace/trace_events_filter.c

1307

static void __free_filter(struct event_filter *filter)

kernel/trace/trace_events_filter.c

1309

if (!filter)

kernel/trace/trace_events_filter.c

1312

free_prog(filter);

kernel/trace/trace_events_filter.c

1313

kfree(filter->filter_string);

kernel/trace/trace_events_filter.c

1314

kfree(filter);

kernel/trace/trace_events_filter.c

1317

void free_event_filter(struct event_filter *filter)

kernel/trace/trace_events_filter.c

1319

__free_filter(filter);

kernel/trace/trace_events_filter.c

1342

struct event_filter *filter;

kernel/trace/trace_events_filter.c

1358

__free_filter(filter_item->filter);

kernel/trace/trace_events_filter.c

1392

static void try_delay_free_filter(struct event_filter *filter)

kernel/trace/trace_events_filter.c

1409

item->filter = filter;

kernel/trace/trace_events_filter.c

1417

__free_filter(filter);

kernel/trace/trace_events_filter.c

1423

file->filter = NULL;

kernel/trace/trace_events_filter.c

1427

struct event_filter *filter)

kernel/trace/trace_events_filter.c

1429

rcu_assign_pointer(file->filter, filter);

kernel/trace/trace_events_filter.c

1434

RCU_INIT_POINTER(file->filter, NULL);

kernel/trace/trace_events_filter.c

1439

struct event_filter *filter)

kernel/trace/trace_events_filter.c

1457

item->filter = event_filter(file);

kernel/trace/trace_events_filter.c

1466

item->filter = filter;

kernel/trace/trace_events_filter.c

1478

if (file->system != dir || !file->filter)

kernel/trace/trace_events_filter.c

1482

__free_filter(filter);

kernel/trace/trace_events_filter.c

2206

struct event_filter *filter,

kernel/trace/trace_events_filter.c

2238

rcu_assign_pointer(filter->prog, prog);

kernel/trace/trace_events_filter.c

2259

struct event_filter *filter = NULL;

kernel/trace/trace_events_filter.c

2275

filter = kzalloc_obj(*filter);

kernel/trace/trace_events_filter.c

2276

if (!filter)

kernel/trace/trace_events_filter.c

2279

filter->filter_string = kstrdup(filter_string, GFP_KERNEL);

kernel/trace/trace_events_filter.c

2280

if (!filter->filter_string)

kernel/trace/trace_events_filter.c

2283

err = process_preds(file->event_call, filter_string, filter, pe);

kernel/trace/trace_events_filter.c

2287

append_filter_err(tr, pe, filter);

kernel/trace/trace_events_filter.c

2301

filter_item->filter = event_filter(file);

kernel/trace/trace_events_filter.c

2302

event_set_filter(file, filter);

kernel/trace/trace_events_filter.c

2303

filter = NULL;

kernel/trace/trace_events_filter.c

2324

__free_filter(filter);

kernel/trace/trace_events_filter.c

2339

struct event_filter *filter;

kernel/trace/trace_events_filter.c

2346

filter = kzalloc_obj(*filter);

kernel/trace/trace_events_filter.c

2347

if (filter && set_str) {

kernel/trace/trace_events_filter.c

2348

filter->filter_string = kstrdup(filter_string, GFP_KERNEL);

kernel/trace/trace_events_filter.c

2349

if (!filter->filter_string)

kernel/trace/trace_events_filter.c

2355

if (!filter || !pe || err) {

kernel/trace/trace_events_filter.c

2357

__free_filter(filter);

kernel/trace/trace_events_filter.c

2362

*filterp = filter;

kernel/trace/trace_events_filter.c

2458

struct event_filter *filter = NULL;

kernel/trace/trace_events_filter.c

2466

filter = event_filter(file);

kernel/trace/trace_events_filter.c

2468

if (!filter)

kernel/trace/trace_events_filter.c

2473

try_delay_free_filter(filter);

kernel/trace/trace_events_filter.c

2478

err = create_filter(file->tr, call, filter_string, true, &filter);

kernel/trace/trace_events_filter.c

2486

if (filter) {

kernel/trace/trace_events_filter.c

2495

event_set_filter(file, filter);

kernel/trace/trace_events_filter.c

2509

struct event_filter *filter = NULL;

kernel/trace/trace_events_filter.c

2520

remove_filter_string(system->filter);

kernel/trace/trace_events_filter.c

2521

filter = system->filter;

kernel/trace/trace_events_filter.c

2522

system->filter = NULL;

kernel/trace/trace_events_filter.c

2524

filter_free_subsystem_filters(dir, tr, filter);

kernel/trace/trace_events_filter.c

2528

err = create_system_filter(dir, filter_string, &filter);

kernel/trace/trace_events_filter.c

2529

if (filter) {

kernel/trace/trace_events_filter.c

2534

__free_filter(system->filter);

kernel/trace/trace_events_filter.c

2535

system->filter = filter;

kernel/trace/trace_events_filter.c

2545

struct event_filter *filter = event->filter;

kernel/trace/trace_events_filter.c

2547

event->filter = NULL;

kernel/trace/trace_events_filter.c

2548

__free_filter(filter);

kernel/trace/trace_events_filter.c

2578

static int ftrace_function_set_regexp(struct ftrace_ops *ops, int filter,

kernel/trace/trace_events_filter.c

2583

if (filter)

kernel/trace/trace_events_filter.c

2591

static int __ftrace_function_set_filter(int filter, char *buf, int len,

kernel/trace/trace_events_filter.c

2598

reset = filter ? &data->first_filter : &data->first_notrace;

kernel/trace/trace_events_filter.c

2610

ret = ftrace_function_set_regexp(data->ops, filter, *reset,

kernel/trace/trace_events_filter.c

2676

struct event_filter *filter)

kernel/trace/trace_events_filter.c

2678

struct prog_entry *prog = rcu_dereference_protected(filter->prog,

kernel/trace/trace_events_filter.c

2700

struct event_filter *filter)

kernel/trace/trace_events_filter.c

2710

struct event_filter *filter = NULL;

kernel/trace/trace_events_filter.c

2720

if (event->filter)

kernel/trace/trace_events_filter.c

2723

err = create_filter(NULL, call, filter_str, false, &filter);

kernel/trace/trace_events_filter.c

2728

err = ftrace_function_set_filter(event, filter);

kernel/trace/trace_events_filter.c

2730

event->filter = filter;

kernel/trace/trace_events_filter.c

2734

__free_filter(filter);

kernel/trace/trace_events_filter.c

2751

.filter = FILTER, \

kernel/trace/trace_events_filter.c

2761

char *filter;

kernel/trace/trace_events_filter.c

2834

static void update_pred_fn(struct event_filter *filter, char *fields)

kernel/trace/trace_events_filter.c

2836

struct prog_entry *prog = rcu_dereference_protected(filter->prog,

kernel/trace/trace_events_filter.c

2865

struct event_filter *filter = NULL;

kernel/trace/trace_events_filter.c

2870

d->filter, false, &filter);

kernel/trace/trace_events_filter.c

2874

d->filter, err);

kernel/trace/trace_events_filter.c

2875

__free_filter(filter);

kernel/trace/trace_events_filter.c

2887

update_pred_fn(filter, d->not_visited);

kernel/trace/trace_events_filter.c

2890

err = filter_match_preds(filter, &d->rec);

kernel/trace/trace_events_filter.c

2895

__free_filter(filter);

kernel/trace/trace_events_filter.c

2900

d->filter);

kernel/trace/trace_events_filter.c

2907

d->filter, d->match);

kernel/trace/trace_events_hist.c

6798

char *param, *filter, *p, *start;

kernel/trace/trace_events_hist.c

6844

filter = NULL;

kernel/trace/trace_events_hist.c

6847

filter = strstrip(p);

kernel/trace/trace_events_hist.c

6880

ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);

kernel/trace/trace_events_trigger.c

1123

char *param, *filter;

kernel/trace/trace_events_trigger.c

1129

ret = event_trigger_separate_filter(param_and_filter, &param, &filter, false);

kernel/trace/trace_events_trigger.c

1148

ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);

kernel/trace/trace_events_trigger.c

1190

struct event_filter *filter = NULL, *tmp;

kernel/trace/trace_events_trigger.c

1207

filter_str, true, &filter);

kernel/trace/trace_events_trigger.c

1210

if (filter) {

kernel/trace/trace_events_trigger.c

1211

kfree(filter->filter_string);

kernel/trace/trace_events_trigger.c

1212

filter->filter_string = NULL;

kernel/trace/trace_events_trigger.c

1220

tmp = rcu_access_pointer(data->filter);

kernel/trace/trace_events_trigger.c

1222

rcu_assign_pointer(data->filter, filter);

kernel/trace/trace_events_trigger.c

1242

free_event_filter(rcu_access_pointer(data->filter));

kernel/trace/trace_events_trigger.c

1243

data->filter = NULL;

kernel/trace/trace_events_trigger.c

1745

char *param, *filter;

kernel/trace/trace_events_trigger.c

1757

ret = event_trigger_separate_filter(param_and_filter, &param, &filter, true);

kernel/trace/trace_events_trigger.c

1812

ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);

kernel/trace/trace_events_trigger.c

183

struct event_filter *filter;

kernel/trace/trace_events_trigger.c

195

filter = rcu_dereference_sched(data->filter);

kernel/trace/trace_events_trigger.c

196

if (filter && !filter_match_preds(filter, rec))

kernel/trace/trace_events_trigger.c

663

if (data->filter || event_command_post_trigger(data->cmd_ops) ||

kernel/trace/trace_events_trigger.c

905

char **filter, bool param_required)

kernel/trace/trace_events_trigger.c

909

*param = *filter = NULL;

kernel/trace/trace_events_trigger.c

924

*filter = param_and_filter;

kernel/trace/trace_events_trigger.c

939

*filter = skip_spaces(param_and_filter);

kernel/trace/trace_events_trigger.c

940

if (!**filter)

kernel/trace/trace_events_trigger.c

941

*filter = NULL;

kernel/trace/trace_events_trigger.c

985

RCU_INIT_POINTER(trigger_data->filter, NULL);

kernel/trace/trace_probe.h

257

struct trace_uprobe_filter filter[];

kernel/trace/trace_uprobe.c

1102

static int trace_uprobe_enable(struct trace_uprobe *tu, filter_func_t filter)

kernel/trace/trace_uprobe.c

1107

tu->consumer.filter = filter;

kernel/trace/trace_uprobe.c

1122

WARN_ON(!uprobe_filter_is_empty(tu->tp.event->filter));

kernel/trace/trace_uprobe.c

1137

struct trace_event_file *file, filter_func_t filter)

kernel/trace/trace_uprobe.c

1165

WARN_ON(!uprobe_filter_is_empty(tu->tp.event->filter));

kernel/trace/trace_uprobe.c

1175

ret = trace_uprobe_enable(tu, filter);

kernel/trace/trace_uprobe.c

1245

__uprobe_perf_filter(struct trace_uprobe_filter *filter, struct mm_struct *mm)

kernel/trace/trace_uprobe.c

1249

list_for_each_entry(event, &filter->perf_events, hw.tp_list) {

kernel/trace/trace_uprobe.c

1258

trace_uprobe_filter_event(struct trace_uprobe_filter *filter,

kernel/trace/trace_uprobe.c

1261

return __uprobe_perf_filter(filter, event->hw.target->mm);

kernel/trace/trace_uprobe.c

1264

static bool trace_uprobe_filter_remove(struct trace_uprobe_filter *filter,

kernel/trace/trace_uprobe.c

1269

write_lock(&filter->rwlock);

kernel/trace/trace_uprobe.c

1272

done = filter->nr_systemwide ||

kernel/trace/trace_uprobe.c

1274

trace_uprobe_filter_event(filter, event);

kernel/trace/trace_uprobe.c

1276

filter->nr_systemwide--;

kernel/trace/trace_uprobe.c

1277

done = filter->nr_systemwide;

kernel/trace/trace_uprobe.c

1279

write_unlock(&filter->rwlock);

kernel/trace/trace_uprobe.c

1285

static bool trace_uprobe_filter_add(struct trace_uprobe_filter *filter,

kernel/trace/trace_uprobe.c

1290

write_lock(&filter->rwlock);

kernel/trace/trace_uprobe.c

1300

done = filter->nr_systemwide ||

kernel/trace/trace_uprobe.c

1302

trace_uprobe_filter_event(filter, event);

kernel/trace/trace_uprobe.c

1303

list_add(&event->hw.tp_list, &filter->perf_events);

kernel/trace/trace_uprobe.c

1305

done = filter->nr_systemwide;

kernel/trace/trace_uprobe.c

1306

filter->nr_systemwide++;

kernel/trace/trace_uprobe.c

1308

write_unlock(&filter->rwlock);

kernel/trace/trace_uprobe.c

1325

if (trace_uprobe_filter_remove(tu->tp.event->filter, event))

kernel/trace/trace_uprobe.c

1349

if (trace_uprobe_filter_add(tu->tp.event->filter, event))

kernel/trace/trace_uprobe.c

1365

struct trace_uprobe_filter *filter;

kernel/trace/trace_uprobe.c

1370

filter = tu->tp.event->filter;

kernel/trace/trace_uprobe.c

1376

if (READ_ONCE(filter->nr_systemwide))

kernel/trace/trace_uprobe.c

1379

read_lock(&filter->rwlock);

kernel/trace/trace_uprobe.c

1380

ret = __uprobe_perf_filter(filter, mm);

kernel/trace/trace_uprobe.c

1381

read_unlock(&filter->rwlock);

kernel/trace/trace_uprobe.c

257

static inline void init_trace_uprobe_filter(struct trace_uprobe_filter *filter)

kernel/trace/trace_uprobe.c

259

rwlock_init(&filter->rwlock);

kernel/trace/trace_uprobe.c

260

filter->nr_systemwide = 0;

kernel/trace/trace_uprobe.c

261

INIT_LIST_HEAD(&filter->perf_events);

kernel/trace/trace_uprobe.c

264

static inline bool uprobe_filter_is_empty(struct trace_uprobe_filter *filter)

kernel/trace/trace_uprobe.c

266

return !filter->nr_systemwide && list_empty(&filter->perf_events);

kernel/trace/trace_uprobe.c

359

init_trace_uprobe_filter(tu->tp.event->filter);

kernel/watch_queue.c

216

wf = rcu_dereference(wqueue->filter);

kernel/watch_queue.c

319

struct watch_notification_filter filter;

kernel/watch_queue.c

335

if (copy_from_user(&filter, _filter, sizeof(filter)) != 0)

kernel/watch_queue.c

337

if (filter.nr_filters == 0 ||

kernel/watch_queue.c

338

filter.nr_filters > 16 ||

kernel/watch_queue.c

339

filter.__reserved != 0)

kernel/watch_queue.c

342

tf = memdup_array_user(_filter->filters, filter.nr_filters, sizeof(*tf));

kernel/watch_queue.c

347

for (i = 0; i < filter.nr_filters; i++) {

kernel/watch_queue.c

367

for (i = 0; i < filter.nr_filters; i++) {

kernel/watch_queue.c

382

wfilter = rcu_replace_pointer(wqueue->filter, wfilter,

kernel/watch_queue.c

406

wfilter = rcu_access_pointer(wqueue->filter);

lib/kobject_uevent.c

519

if (uevent_ops && uevent_ops->filter)

lib/kobject_uevent.c

520

if (!uevent_ops->filter(kobj)) {

lib/kunit/attributes.c

256

.filter = attr_speed_filter,

lib/kunit/attributes.c

264

.filter = attr_string_filter,

lib/kunit/attributes.c

272

.filter = attr_bool_filter,

lib/kunit/attributes.c

280

const char *kunit_attr_filter_name(struct kunit_attr_filter filter)

lib/kunit/attributes.c

282

return filter.attr->name;

lib/kunit/attributes.c

338

struct kunit_attr_filter filter = {};

lib/kunit/attributes.c

359

return filter;

lib/kunit/attributes.c

380

filter.attr = &kunit_attr_list[attr_index];

lib/kunit/attributes.c

385

filter.input = input + op_index;

lib/kunit/attributes.c

388

filter.input = input + op_index;

lib/kunit/attributes.c

394

return filter;

lib/kunit/attributes.c

398

struct kunit_attr_filter filter, char *action, int *err)

lib/kunit/attributes.c

40

int (*filter)(void *attr, const char *input, int *err);

lib/kunit/attributes.c

422

default_result = filter.attr->filter(filter.attr->attr_default, filter.input, err);

lib/kunit/attributes.c

427

suite_val = filter.attr->get_attr((void *)suite, false);

lib/kunit/attributes.c

428

suite_result = filter.attr->filter(suite_val, filter.input, err);

lib/kunit/attributes.c

434

test_val = filter.attr->get_attr((void *) test_case, true);

lib/kunit/attributes.c

435

test_result = filter.attr->filter(filter.attr->get_attr(test_case, true),

lib/kunit/attributes.c

436

filter.input, err);

lib/kunit/executor.c

57

module_param_named(filter, filter_param, charp, 0600);

lib/kunit/executor.c

58

MODULE_PARM_DESC(filter,

lib/kunit/executor_test.c

122

char filters[] = "speed>slow, module!=example", *filter = filters;

lib/kunit/executor_test.c

131

parsed_filters[j] = kunit_next_attr_filter(&filter, &err);

lib/kunit/executor_test.c

157

char filter[] = "speed>slow";

lib/kunit/executor_test.c

172

got = kunit_filter_suites(&suite_set, NULL, filter, NULL, &err);

lib/kunit/executor_test.c

195

char filter[] = "module!=dummy";

lib/kunit/executor_test.c

201

got = kunit_filter_suites(&suite_set, NULL, filter, NULL, &err);

lib/kunit/executor_test.c

216

char filter[] = "speed>slow";

lib/kunit/executor_test.c

222

got = kunit_filter_suites(&suite_set, NULL, filter, "skip", &err);

lib/kunit/executor_test.c

28

struct kunit_glob_filter filter = {NULL, NULL};

lib/kunit/executor_test.c

30

kunit_parse_glob_filter(&filter, "suite");

lib/kunit/executor_test.c

31

KUNIT_EXPECT_STREQ(test, filter.suite_glob, "suite");

lib/kunit/executor_test.c

32

KUNIT_EXPECT_FALSE(test, filter.test_glob);

lib/kunit/executor_test.c

33

kfree(filter.suite_glob);

lib/kunit/executor_test.c

34

kfree(filter.test_glob);

lib/kunit/executor_test.c

36

kunit_parse_glob_filter(&filter, "suite.test");

lib/kunit/executor_test.c

37

KUNIT_EXPECT_STREQ(test, filter.suite_glob, "suite");

lib/kunit/executor_test.c

38

KUNIT_EXPECT_STREQ(test, filter.test_glob, "test");

lib/kunit/executor_test.c

39

kfree(filter.suite_glob);

lib/kunit/executor_test.c

40

kfree(filter.test_glob);

lib/test_bpf.c

14848

fprog.filter = fptr;

lib/xarray.c

2190

unsigned long max, xa_mark_t filter)

lib/xarray.c

2197

if ((__force unsigned int)filter < XA_MAX_MARKS)

lib/xarray.c

2198

entry = xas_find_marked(&xas, max, filter);

lib/xarray.c

2240

unsigned long max, xa_mark_t filter)

lib/xarray.c

2250

if ((__force unsigned int)filter < XA_MAX_MARKS)

lib/xarray.c

2251

entry = xas_find_marked(&xas, max, filter);

lib/xarray.c

2337

unsigned long max, unsigned int n, xa_mark_t filter)

lib/xarray.c

2344

if ((__force unsigned int)filter < XA_MAX_MARKS)

lib/xarray.c

2345

return xas_extract_marked(&xas, dst, max, n, filter);

mm/damon/core.c

1779

struct damon_region *r, struct damos_filter *filter,

mm/damon/core.c

1787

switch (filter->type) {

mm/damon/core.c

1794

matched = target_idx == filter->target_idx;

mm/damon/core.c

1797

start = ALIGN_DOWN(filter->addr_range.start, min_region_sz);

mm/damon/core.c

1798

end = ALIGN_DOWN(filter->addr_range.end, min_region_sz);

mm/damon/core.c

1824

return matched == filter->matching;

mm/damon/core.c

1830

struct damos_filter *filter;

mm/damon/core.c

1833

damos_for_each_core_filter(filter, s) {

mm/damon/core.c

1834

if (damos_filter_match(ctx, t, r, filter, ctx->min_region_sz)) {

mm/damon/core.c

1835

if (filter->allow)

mm/damon/core.c

1837

return !filter->allow;

mm/damon/core.c

274

struct damos_filter *filter;

mm/damon/core.c

276

filter = kmalloc_obj(*filter);

mm/damon/core.c

277

if (!filter)

mm/damon/core.c

279

filter->type = type;

mm/damon/core.c

280

filter->matching = matching;

mm/damon/core.c

281

filter->allow = allow;

mm/damon/core.c

282

INIT_LIST_HEAD(&filter->list);

mm/damon/core.c

283

return filter;

mm/damon/core.c

871

struct damos_filter *filter;

mm/damon/core.c

874

damos_for_each_core_filter(filter, s) {

mm/damon/core.c

876

return filter;

mm/damon/core.c

883

struct damos_filter *filter;

mm/damon/core.c

886

damos_for_each_ops_filter(filter, s) {

mm/damon/core.c

888

return filter;

mm/damon/lru_sort.c

262

struct damos_filter *filter;

mm/damon/lru_sort.c

268

filter = damos_new_filter(DAMOS_FILTER_TYPE_YOUNG, false, false);

mm/damon/lru_sort.c

269

if (!filter)

mm/damon/lru_sort.c

271

damos_add_filter(hot_scheme, filter);

mm/damon/lru_sort.c

274

filter = damos_new_filter(DAMOS_FILTER_TYPE_YOUNG, true, false);

mm/damon/lru_sort.c

275

if (!filter)

mm/damon/lru_sort.c

277

damos_add_filter(cold_scheme, filter);

mm/damon/ops-common.c

258

bool damos_folio_filter_match(struct damos_filter *filter, struct folio *folio)

mm/damon/ops-common.c

264

switch (filter->type) {

mm/damon/ops-common.c

277

matched = filter->memcg_id == mem_cgroup_id(memcg);

mm/damon/ops-common.c

287

matched = filter->sz_range.min <= folio_sz &&

mm/damon/ops-common.c

288

folio_sz <= filter->sz_range.max;

mm/damon/ops-common.c

297

return matched == filter->matching;

mm/damon/ops-common.h

22

bool damos_folio_filter_match(struct damos_filter *filter, struct folio *folio);

mm/damon/paddr.c

128

struct damos_filter *filter;

mm/damon/paddr.c

133

damos_for_each_ops_filter(filter, scheme) {

mm/damon/paddr.c

134

if (damos_folio_filter_match(filter, folio))

mm/damon/paddr.c

135

return !filter->allow;

mm/damon/paddr.c

158

struct damos_filter *filter;

mm/damon/paddr.c

162

damos_for_each_ops_filter(filter, s) {

mm/damon/paddr.c

163

if (filter->type == DAMOS_FILTER_TYPE_YOUNG) {

mm/damon/paddr.c

169

filter = damos_new_filter(

mm/damon/paddr.c

171

if (!filter)

mm/damon/paddr.c

173

damos_add_filter(s, filter);

mm/damon/paddr.c

202

damos_destroy_filter(filter);

mm/damon/reclaim.c

197

struct damos_filter *filter;

mm/damon/reclaim.c

245

filter = damos_new_filter(DAMOS_FILTER_TYPE_ANON, true, false);

mm/damon/reclaim.c

246

if (!filter)

mm/damon/reclaim.c

248

damos_add_filter(scheme, filter);

mm/damon/sysfs-schemes.c

2536

struct damos_filter *filter =

mm/damon/sysfs-schemes.c

2542

if (!filter)

mm/damon/sysfs-schemes.c

2544

if (filter->type == DAMOS_FILTER_TYPE_MEMCG) {

mm/damon/sysfs-schemes.c

2547

&filter->memcg_id);

mm/damon/sysfs-schemes.c

2549

damos_destroy_filter(filter);

mm/damon/sysfs-schemes.c

2552

} else if (filter->type == DAMOS_FILTER_TYPE_ADDR) {

mm/damon/sysfs-schemes.c

2555

damos_destroy_filter(filter);

mm/damon/sysfs-schemes.c

2558

filter->addr_range = sysfs_filter->addr_range;

mm/damon/sysfs-schemes.c

2559

} else if (filter->type == DAMOS_FILTER_TYPE_TARGET) {

mm/damon/sysfs-schemes.c

2560

filter->target_idx = sysfs_filter->target_idx;

mm/damon/sysfs-schemes.c

2561

} else if (filter->type == DAMOS_FILTER_TYPE_HUGEPAGE_SIZE) {

mm/damon/sysfs-schemes.c

2564

damos_destroy_filter(filter);

mm/damon/sysfs-schemes.c

2567

filter->sz_range = sysfs_filter->sz_range;

mm/damon/sysfs-schemes.c

2570

damos_add_filter(scheme, filter);

mm/damon/sysfs-schemes.c

375

struct damon_sysfs_scheme_filter *filter;

mm/damon/sysfs-schemes.c

377

filter = kzalloc_obj(struct damon_sysfs_scheme_filter);

mm/damon/sysfs-schemes.c

378

if (filter)

mm/damon/sysfs-schemes.c

379

filter->handle_layer = layer;

mm/damon/sysfs-schemes.c

380

return filter;

mm/damon/sysfs-schemes.c

427

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

435

if (type_name->type == filter->type)

mm/damon/sysfs-schemes.c

461

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

472

filter->handle_layer,

mm/damon/sysfs-schemes.c

475

filter->type = type_name->type;

mm/damon/sysfs-schemes.c

486

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

489

return sysfs_emit(buf, "%c\n", filter->matching ? 'Y' : 'N');

mm/damon/sysfs-schemes.c

495

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

503

filter->matching = matching;

mm/damon/sysfs-schemes.c

510

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

513

return sysfs_emit(buf, "%c\n", filter->allow ? 'Y' : 'N');

mm/damon/sysfs-schemes.c

519

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

527

filter->allow = allow;

mm/damon/sysfs-schemes.c

534

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

538

filter->memcg_path ? filter->memcg_path : "");

mm/damon/sysfs-schemes.c

544

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

553

kfree(filter->memcg_path);

mm/damon/sysfs-schemes.c

554

filter->memcg_path = path;

mm/damon/sysfs-schemes.c

561

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

564

return sysfs_emit(buf, "%lu\n", filter->addr_range.start);

mm/damon/sysfs-schemes.c

570

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

572

int err = kstrtoul(buf, 0, &filter->addr_range.start);

mm/damon/sysfs-schemes.c

580

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

583

return sysfs_emit(buf, "%lu\n", filter->addr_range.end);

mm/damon/sysfs-schemes.c

589

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

591

int err = kstrtoul(buf, 0, &filter->addr_range.end);

mm/damon/sysfs-schemes.c

599

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

602

return sysfs_emit(buf, "%lu\n", filter->sz_range.min);

mm/damon/sysfs-schemes.c

608

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

610

int err = kstrtoul(buf, 0, &filter->sz_range.min);

mm/damon/sysfs-schemes.c

618

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

621

return sysfs_emit(buf, "%lu\n", filter->sz_range.max);

mm/damon/sysfs-schemes.c

627

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

629

int err = kstrtoul(buf, 0, &filter->sz_range.max);

mm/damon/sysfs-schemes.c

637

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

640

return sysfs_emit(buf, "%d\n", filter->target_idx);

mm/damon/sysfs-schemes.c

646

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

648

int err = kstrtoint(buf, 0, &filter->target_idx);

mm/damon/sysfs-schemes.c

655

struct damon_sysfs_scheme_filter *filter = container_of(kobj,

mm/damon/sysfs-schemes.c

658

kfree(filter->memcg_path);

mm/damon/sysfs-schemes.c

659

kfree(filter);

mm/damon/sysfs-schemes.c

747

struct damon_sysfs_scheme_filter **filters_arr, *filter;

mm/damon/sysfs-schemes.c

761

filter = damon_sysfs_scheme_filter_alloc(

mm/damon/sysfs-schemes.c

763

if (!filter) {

mm/damon/sysfs-schemes.c

768

err = kobject_init_and_add(&filter->kobj,

mm/damon/sysfs-schemes.c

772

kobject_put(&filter->kobj);

mm/damon/sysfs-schemes.c

777

filters_arr[i] = filter;

mm/damon/tests/core-kunit.h

514

struct damos_filter *filter;

mm/damon/tests/core-kunit.h

516

filter = damos_new_filter(DAMOS_FILTER_TYPE_ANON, true, false);

mm/damon/tests/core-kunit.h

517

if (!filter)

mm/damon/tests/core-kunit.h

519

KUNIT_EXPECT_EQ(test, filter->type, DAMOS_FILTER_TYPE_ANON);

mm/damon/tests/core-kunit.h

520

KUNIT_EXPECT_EQ(test, filter->matching, true);

mm/damon/tests/core-kunit.h

521

KUNIT_EXPECT_PTR_EQ(test, filter->list.prev, &filter->list);

mm/damon/tests/core-kunit.h

522

KUNIT_EXPECT_PTR_EQ(test, filter->list.next, &filter->list);

mm/damon/tests/core-kunit.h

523

damos_destroy_filter(filter);

mm/damon/vaddr.c

589

static bool damos_va_filter_young_match(struct damos_filter *filter,

mm/damon/vaddr.c

608

return young == filter->matching;

mm/damon/vaddr.c

615

struct damos_filter *filter;

mm/damon/vaddr.c

621

damos_for_each_ops_filter(filter, scheme) {

mm/damon/vaddr.c

628

if (filter->type == DAMOS_FILTER_TYPE_YOUNG)

mm/damon/vaddr.c

629

matched = damos_va_filter_young_match(filter, folio,

mm/damon/vaddr.c

632

matched = damos_folio_filter_match(filter, folio);

mm/damon/vaddr.c

635

return !filter->allow;

mm/internal.h

1316

void hwpoison_filter_register(hwpoison_filter_func_t *filter);

mm/memory-failure.c

225

void hwpoison_filter_register(hwpoison_filter_func_t *filter)

mm/memory-failure.c

227

rcu_assign_pointer(hwpoison_filter_func, filter);

mm/memory-failure.c

241

hwpoison_filter_func_t *filter;

mm/memory-failure.c

244

filter = rcu_dereference(hwpoison_filter_func);

mm/memory-failure.c

245

if (filter)

mm/memory-failure.c

246

ret = filter(p);

mm/page_alloc.c

4007

unsigned int filter = SHOW_MEM_FILTER_NODES;

mm/page_alloc.c

4017

filter &= ~SHOW_MEM_FILTER_NODES;

mm/page_alloc.c

4019

filter &= ~SHOW_MEM_FILTER_NODES;

mm/page_alloc.c

4021

__show_mem(filter, nodemask, gfp_zone(gfp_mask));

mm/show_mem.c

180

static void show_free_areas(unsigned int filter, nodemask_t *nodemask, int max_zone_idx)

mm/show_mem.c

190

if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))

mm/show_mem.c

227

if (show_mem_node_skip(filter, pgdat->node_id, nodemask))

mm/show_mem.c

290

if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))

mm/show_mem.c

361

if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))

mm/show_mem.c

391

if (show_mem_node_skip(filter, nid, nodemask))

mm/show_mem.c

401

void __show_mem(unsigned int filter, nodemask_t *nodemask, int max_zone_idx)

mm/show_mem.c

407

show_free_areas(filter, nodemask, max_zone_idx);

mm/vmscan.c

2811

unsigned long *filter;

mm/vmscan.c

2814

filter = READ_ONCE(mm_state->filters[gen]);

mm/vmscan.c

2815

if (!filter)

mm/vmscan.c

2820

return test_bit(key[0], filter) && test_bit(key[1], filter);

mm/vmscan.c

2827

unsigned long *filter;

mm/vmscan.c

2830

filter = READ_ONCE(mm_state->filters[gen]);

mm/vmscan.c

2831

if (!filter)

mm/vmscan.c

2836

if (!test_bit(key[0], filter))

mm/vmscan.c

2837

set_bit(key[0], filter);

mm/vmscan.c

2838

if (!test_bit(key[1], filter))

mm/vmscan.c

2839

set_bit(key[1], filter);

mm/vmscan.c

2844

unsigned long *filter;

mm/vmscan.c

2847

filter = mm_state->filters[gen];

mm/vmscan.c

2848

if (filter) {

mm/vmscan.c

2849

bitmap_clear(filter, 0, BIT(BLOOM_FILTER_SHIFT));

mm/vmscan.c

2853

filter = bitmap_zalloc(BIT(BLOOM_FILTER_SHIFT),

mm/vmscan.c

2855

WRITE_ONCE(mm_state->filters[gen], filter);

net/atm/br2684.c

385

memcpy(&brvcc->filter, &fs.filter, sizeof(brvcc->filter));

net/atm/br2684.c

393

if (brvcc->filter.netmask == 0)

net/atm/br2684.c

396

(((struct iphdr *)(skb->data))->daddr & brvcc->filter.

net/atm/br2684.c

397

netmask) == brvcc->filter.prefix)

net/atm/br2684.c

77

struct br2684_filter filter;

net/atm/br2684.c

807

if (brvcc->filter.netmask != 0)

net/atm/br2684.c

809

&brvcc->filter.prefix,

net/atm/br2684.c

810

&brvcc->filter.netmask);

net/bluetooth/hci_sock.c

171

flt = &hci_pi(sk)->filter;

net/bluetooth/hci_sock.c

1979

struct hci_filter *f = &hci_pi(sk)->filter;

net/bluetooth/hci_sock.c

1998

struct hci_filter *f = &hci_pi(sk)->filter;

net/bluetooth/hci_sock.c

2107

struct hci_filter *f = &hci_pi(sk)->filter;

net/bluetooth/hci_sock.c

54

struct hci_filter filter;

net/bluetooth/l2cap_core.c

6566

if (chan->ops->filter) {

net/bluetooth/l2cap_core.c

6567

if (chan->ops->filter(chan, skb))

net/bluetooth/l2cap_sock.c

1807

.filter = l2cap_sock_filter,

net/bridge/br_cfm.c

143

u32 filter = RTEXT_FILTER_CFM_STATUS;

net/bridge/br_cfm.c

145

br_info_notify(event, port->br, NULL, filter);

net/bridge/br_netlink.c

625

const struct net_bridge_port *port, u32 filter)

net/bridge/br_netlink.c

647

skb = nlmsg_new(br_nlmsg_size(dev, filter), GFP_ATOMIC);

net/bridge/br_netlink.c

651

err = br_fill_ifinfo(skb, port, 0, 0, event, 0, filter, dev, false);

net/bridge/br_netlink.c

668

u32 filter = RTEXT_FILTER_BRVLAN_COMPRESSED;

net/bridge/br_netlink.c

670

br_info_notify(event, br, port, filter);

net/bridge/br_private.h

2163

const struct net_bridge_port *port, u32 filter);

net/can/gw.c

1051

nla_memcpy(&ccgw->filter, tb[CGW_FILTER],

net/can/gw.c

122

struct can_filter filter;

net/can/gw.c

577

return can_rx_register(net, gwj->src.dev, gwj->ccgw.filter.can_id,

net/can/gw.c

578

gwj->ccgw.filter.can_mask, can_can_gw_rcv,

net/can/gw.c

584

can_rx_unregister(net, gwj->src.dev, gwj->ccgw.filter.can_id,

net/can/gw.c

585

gwj->ccgw.filter.can_mask, can_can_gw_rcv, gwj);

net/can/gw.c

754

if (gwj->ccgw.filter.can_id || gwj->ccgw.filter.can_mask) {

net/can/gw.c

756

&gwj->ccgw.filter) < 0)

net/can/raw.c

103

struct can_filter *filter; /* pointer to filter(s) */

net/can/raw.c

215

struct sock *sk, struct can_filter *filter,

net/can/raw.c

222

err = can_rx_register(net, dev, filter[i].can_id,

net/can/raw.c

223

filter[i].can_mask,

net/can/raw.c

228

can_rx_unregister(net, dev, filter[i].can_id,

net/can/raw.c

229

filter[i].can_mask,

net/can/raw.c

251

struct sock *sk, struct can_filter *filter,

net/can/raw.c

257

can_rx_unregister(net, dev, filter[i].can_id,

net/can/raw.c

258

filter[i].can_mask, raw_rcv, sk);

net/can/raw.c

278

raw_disable_filters(net, dev, sk, ro->filter, ro->count);

net/can/raw.c

288

err = raw_enable_filters(net, dev, sk, ro->filter, ro->count);

net/can/raw.c

292

raw_disable_filters(net, dev, sk, ro->filter,

net/can/raw.c

320

kfree(ro->filter);

net/can/raw.c

375

ro->filter = &ro->dfilter;

net/can/raw.c

433

kfree(ro->filter);

net/can/raw.c

560

struct can_filter *filter = NULL; /* dyn. alloc'ed filters */

net/can/raw.c

583

filter = memdup_sockptr(optval, optlen);

net/can/raw.c

584

if (IS_ERR(filter))

net/can/raw.c

585

return PTR_ERR(filter);

net/can/raw.c

598

kfree(filter);

net/can/raw.c

611

filter, count);

net/can/raw.c

614

kfree(filter);

net/can/raw.c

619

raw_disable_filters(sock_net(sk), dev, sk, ro->filter,

net/can/raw.c

625

kfree(ro->filter);

net/can/raw.c

631

filter = &ro->dfilter;

net/can/raw.c

633

ro->filter = filter;

net/can/raw.c

795

if (copy_to_user(optval, ro->filter, len))

net/core/dev.c

5053

if (READ_ONCE(tmp_rflow->filter) != RPS_NO_FILTER) {

net/core/dev.c

5069

WRITE_ONCE(rflow->filter, rc);

net/core/dev.c

5072

if (old_rflow->filter == rc)

net/core/dev.c

5073

WRITE_ONCE(old_rflow->filter, RPS_NO_FILTER);

net/core/dev.c

5214

if (READ_ONCE(rflow->filter) == filter_id &&

net/core/filter.c

1055

static bool bpf_check_basics_ok(const struct sock_filter *filter,

net/core/filter.c

1058

if (filter == NULL)

net/core/filter.c

108

dst->filter = compat_ptr(f32.filter);

net/core/filter.c

1080

static int bpf_check_classic(const struct sock_filter *filter,

net/core/filter.c

1088

const struct sock_filter *ftest = &filter[pc];

net/core/filter.c

11359

struct sk_filter *filter;

net/core/filter.c

11364

filter = rcu_dereference_protected(sk->sk_filter,

net/core/filter.c

11366

if (filter) {

net/core/filter.c

11368

sk_filter_uncharge(sk, filter);

net/core/filter.c

11379

struct sk_filter *filter;

net/core/filter.c

11383

filter = rcu_dereference_protected(sk->sk_filter,

net/core/filter.c

11385

if (!filter)

net/core/filter.c

11393

fprog = filter->prog->orig_prog;

net/core/filter.c

11407

if (copy_to_sockptr(optval, fprog->filter, bpf_classic_proglen(fprog)))

net/core/filter.c

1149

switch (filter[flen - 1].code) {

net/core/filter.c

1152

return check_load_and_stores(filter, flen);

net/core/filter.c

1171

fkprog->filter = kmemdup(fp->insns, fsize,

net/core/filter.c

1173

if (!fkprog->filter) {

net/core/filter.c

1186

kfree(fprog->filter);

net/core/filter.c

12581

.filter = tracing_iter_filter,

net/core/filter.c

138

struct sk_filter *filter;

net/core/filter.c

1392

if (!bpf_check_basics_ok(fprog->filter, fprog->len))

net/core/filter.c

1399

memcpy(fp->insns, fprog->filter, fsize);

net/core/filter.c

1439

if (!bpf_check_basics_ok(fprog->filter, fprog->len))

net/core/filter.c

1446

if (copy_from_user(fp->insns, fprog->filter, fsize)) {

net/core/filter.c

1517

if (!bpf_check_basics_ok(fprog->filter, fprog->len))

net/core/filter.c

1524

if (copy_from_user(prog->insns, fprog->filter, fsize)) {

net/core/filter.c

163

filter = rcu_dereference(sk->sk_filter);

net/core/filter.c

164

if (filter) {

net/core/filter.c

169

pkt_len = bpf_prog_run_save_cb(filter->prog, skb);

net/core/filter.c

936

static int check_load_and_stores(const struct sock_filter *filter, int flen)

net/core/filter.c

952

switch (filter[pc].code) {

net/core/filter.c

955

memvalid |= (1 << filter[pc].k);

net/core/filter.c

959

if (!(memvalid & (1 << filter[pc].k))) {

net/core/filter.c

966

masks[pc + 1 + filter[pc].k] &= memvalid;

net/core/filter.c

978

masks[pc + 1 + filter[pc].jt] &= memvalid;

net/core/filter.c

979

masks[pc + 1 + filter[pc].jf] &= memvalid;

net/core/neighbour.c

2802

struct neigh_dump_filter *filter)

net/core/neighbour.c

2811

if (filter->dev_idx || filter->master_idx)

net/core/neighbour.c

2823

if (neigh_ifindex_filtered(n->dev, filter->dev_idx) ||

net/core/neighbour.c

2824

neigh_master_filtered(n->dev, filter->master_idx))

net/core/neighbour.c

2843

struct neigh_dump_filter *filter)

net/core/neighbour.c

2851

if (filter->dev_idx || filter->master_idx)

net/core/neighbour.c

2862

if (neigh_ifindex_filtered(n->dev, filter->dev_idx) ||

net/core/neighbour.c

2863

neigh_master_filtered(n->dev, filter->master_idx))

net/core/neighbour.c

2883

struct neigh_dump_filter *filter,

net/core/neighbour.c

2926

filter->dev_idx = nla_get_u32(tb[i]);

net/core/neighbour.c

2929

filter->master_idx = nla_get_u32(tb[i]);

net/core/neighbour.c

2945

struct neigh_dump_filter filter = {};

net/core/neighbour.c

2960

err = neigh_valid_dump_req(nlh, cb->strict_check, &filter, cb->extack);

net/core/neighbour.c

2979

err = pneigh_dump_table(tbl, skb, cb, &filter);

net/core/neighbour.c

2981

err = neigh_dump_table(tbl, skb, cb, &filter);

net/core/net-sysfs.c

1125

table->flows[count].filter = RPS_NO_FILTER;

net/core/ptp_classifier.c

225

ptp_prog.filter = ptp_filter;

net/core/sock.c

2347

struct sk_filter *filter;

net/core/sock.c

2352

filter = rcu_dereference_check(sk->sk_filter,

net/core/sock.c

2354

if (filter) {

net/core/sock.c

2355

sk_filter_uncharge(sk, filter);

net/core/sock.c

2477

struct sk_filter *filter;

net/core/sock.c

2541

filter = rcu_dereference(sk->sk_filter);

net/core/sock.c

2542

if (filter != NULL)

net/core/sock.c

2547

is_charged = sk_filter_charge(newsk, filter);

net/core/sock.c

2548

RCU_INIT_POINTER(newsk->sk_filter, filter);

net/core/sock_diag.c

107

memcpy(nla_data(attr), fprog->filter, flen);

net/core/sock_diag.c

80

struct sk_filter *filter;

net/core/sock_diag.c

91

filter = rcu_dereference(sk->sk_filter);

net/core/sock_diag.c

92

if (!filter)

net/core/sock_diag.c

95

fprog = filter->prog->orig_prog;

net/ipv4/fib_frontend.c

1008

if (filter->flags || filter->protocol || filter->rt_type ||

net/ipv4/fib_frontend.c

1009

filter->table_id || filter->dev) {

net/ipv4/fib_frontend.c

1010

filter->filter_set = 1;

net/ipv4/fib_frontend.c

1020

struct fib_dump_filter filter = {

net/ipv4/fib_frontend.c

1035

err = ip_valid_fib_dump_req(net, nlh, &filter, cb);

net/ipv4/fib_frontend.c

1041

filter.flags = rtm->rtm_flags & (RTM_F_PREFIX | RTM_F_CLONED);

net/ipv4/fib_frontend.c

1045

if (filter.flags & RTM_F_PREFIX)

net/ipv4/fib_frontend.c

1048

if (filter.table_id) {

net/ipv4/fib_frontend.c

1049

tb = fib_get_table(net, filter.table_id);

net/ipv4/fib_frontend.c

1058

err = fib_table_dump(tb, skb, cb, &filter);

net/ipv4/fib_frontend.c

1075

err = fib_table_dump(tb, skb, cb, &filter);

net/ipv4/fib_frontend.c

941

struct fib_dump_filter *filter,

net/ipv4/fib_frontend.c

949

if (filter->rtnl_held)

net/ipv4/fib_frontend.c

969

filter->dump_routes = false;

net/ipv4/fib_frontend.c

971

filter->dump_exceptions = false;

net/ipv4/fib_frontend.c

973

filter->flags = rtm->rtm_flags;

net/ipv4/fib_frontend.c

974

filter->protocol = rtm->rtm_protocol;

net/ipv4/fib_frontend.c

975

filter->rt_type = rtm->rtm_type;

net/ipv4/fib_frontend.c

976

filter->table_id = rtm->rtm_table;

net/ipv4/fib_frontend.c

991

filter->table_id = nla_get_u32(tb[i]);

net/ipv4/fib_frontend.c

995

if (filter->rtnl_held)

net/ipv4/fib_frontend.c

996

filter->dev = __dev_get_by_index(net, ifindex);

net/ipv4/fib_frontend.c

998

filter->dev = dev_get_by_index_rcu(net, ifindex);

net/ipv4/fib_frontend.c

999

if (!filter->dev)

net/ipv4/fib_trie.c

2244

struct fib_dump_filter *filter)

net/ipv4/fib_trie.c

2251

if (filter->filter_set ||

net/ipv4/fib_trie.c

2252

!filter->dump_exceptions || !filter->dump_routes)

net/ipv4/fib_trie.c

2271

if (filter->filter_set) {

net/ipv4/fib_trie.c

2272

if (filter->rt_type && fa->fa_type != filter->rt_type)

net/ipv4/fib_trie.c

2275

if ((filter->protocol &&

net/ipv4/fib_trie.c

2276

fi->fib_protocol != filter->protocol))

net/ipv4/fib_trie.c

2279

if (filter->dev &&

net/ipv4/fib_trie.c

2280

!fib_info_nh_uses_dev(fi, filter->dev))

net/ipv4/fib_trie.c

2284

if (filter->dump_routes) {

net/ipv4/fib_trie.c

2308

if (filter->dump_exceptions) {

net/ipv4/fib_trie.c

2330

struct netlink_callback *cb, struct fib_dump_filter *filter)

net/ipv4/fib_trie.c

2349

err = fn_trie_dump_leaf(l, tb, skb, cb, filter);

net/ipv4/ipmr.c

2738

struct fib_dump_filter filter = {

net/ipv4/ipmr.c

2745

&filter, cb);

net/ipv4/ipmr.c

2750

if (filter.table_id) {

net/ipv4/ipmr.c

2753

mrt = __ipmr_get_table(sock_net(skb->sk), filter.table_id);

net/ipv4/ipmr.c

2762

&mfc_unres_lock, &filter);

net/ipv4/ipmr.c

2767

_ipmr_fill_mroute, &mfc_unres_lock, &filter);

net/ipv4/ipmr_base.c

303

spinlock_t *lock, struct fib_dump_filter *filter)

net/ipv4/ipmr_base.c

310

if (filter->filter_set)

net/ipv4/ipmr_base.c

317

if (filter->dev &&

net/ipv4/ipmr_base.c

318

!mr_mfc_uses_dev(mrt, mfc, filter->dev))

net/ipv4/ipmr_base.c

358

spinlock_t *lock, struct fib_dump_filter *filter)

net/ipv4/ipmr_base.c

368

if (filter->filter_set) {

net/ipv4/ipmr_base.c

369

if (filter->protocol || filter->flags ||

net/ipv4/ipmr_base.c

370

(filter->rt_type && filter->rt_type != RTN_MULTICAST))

net/ipv4/ipmr_base.c

379

err = mr_table_dump(mrt, skb, cb, fill, lock, filter);

net/ipv4/nexthop.c

3416

struct nh_dump_filter *filter, u8 family)

net/ipv4/nexthop.c

3421

if (filter->group_filter && !nh->is_group)

net/ipv4/nexthop.c

3424

if (!filter->dev_idx && !filter->master_idx && !family)

net/ipv4/nexthop.c

3435

if (filter->dev_idx && (!dev || dev->ifindex != filter->dev_idx))

net/ipv4/nexthop.c

3438

if (filter->master_idx) {

net/ipv4/nexthop.c

3445

if (!master || master->ifindex != filter->master_idx)

net/ipv4/nexthop.c

3453

struct nh_dump_filter *filter,

net/ipv4/nexthop.c

3465

filter->dev_idx = idx;

net/ipv4/nexthop.c

3473

filter->master_idx = idx;

net/ipv4/nexthop.c

3475

filter->group_filter = nla_get_flag(tb[NHA_GROUPS]);

net/ipv4/nexthop.c

3476

filter->fdb_filter = nla_get_flag(tb[NHA_FDB]);

net/ipv4/nexthop.c

3488

struct nh_dump_filter *filter,

net/ipv4/nexthop.c

3500

filter->op_flags = nla_get_u32_default(tb[NHA_OP_FLAGS], 0);

net/ipv4/nexthop.c

3502

return __nh_valid_dump_req(nlh, tb, filter, cb->extack);

net/ipv4/nexthop.c

3582

struct nh_dump_filter *filter = data;

net/ipv4/nexthop.c

3584

if (nh_dump_filtered(nh, filter, nhm->nh_family))

net/ipv4/nexthop.c

3589

cb->nlh->nlmsg_seq, NLM_F_MULTI, filter->op_flags);

net/ipv4/nexthop.c

3598

struct nh_dump_filter filter = {};

net/ipv4/nexthop.c

3601

err = nh_valid_dump_req(cb->nlh, &filter, cb);

net/ipv4/nexthop.c

3606

&rtm_dump_nexthop_cb, &filter);

net/ipv4/nexthop.c

3658

struct nh_dump_filter *filter,

net/ipv4/nexthop.c

3671

err = nh_valid_dump_nhid(tb[NHA_ID], &filter->nh_id, cb->extack);

net/ipv4/nexthop.c

3686

&filter->res_bucket_nh_id,

net/ipv4/nexthop.c

3692

return __nh_valid_dump_req(nlh, tb, filter, cb->extack);

net/ipv4/nexthop.c

3711

struct nh_dump_filter filter;

net/ipv4/nexthop.c

3736

if (nh_dump_filtered(nhge->nh, &dd->filter, nhm->nh_family))

net/ipv4/nexthop.c

3739

if (dd->filter.res_bucket_nh_id &&

net/ipv4/nexthop.c

3740

dd->filter.res_bucket_nh_id != nhge->nh->id)

net/ipv4/nexthop.c

3784

err = nh_valid_dump_bucket_req(cb->nlh, &dd.filter, cb);

net/ipv4/nexthop.c

3788

if (dd.filter.nh_id) {

net/ipv4/nexthop.c

3789

nh = nexthop_find_group_resilient(net, dd.filter.nh_id,

net/ipv4/raw.c

148

__u32 data = raw_sk(sk)->filter.data;

net/ipv4/raw.c

800

memset(&rp->filter, 0, sizeof(rp->filter));

net/ipv4/raw.c

808

if (copy_from_sockptr(&raw_sk(sk)->filter, optval, optlen))

net/ipv4/raw.c

826

copy_to_user(optval, &raw_sk(sk)->filter, len))

net/ipv4/raw.c

951

.useroffset = offsetof(struct raw_sock, filter),

net/ipv4/raw.c

952

.usersize = sizeof_field(struct raw_sock, filter),

net/ipv6/ip6_fib.c

631

.filter.dump_exceptions = true,

net/ipv6/ip6_fib.c

632

.filter.dump_routes = true,

net/ipv6/ip6_fib.c

633

.filter.rtnl_held = false,

net/ipv6/ip6_fib.c

646

err = ip_valid_fib_dump_req(net, nlh, &arg.filter, cb);

net/ipv6/ip6_fib.c

653

arg.filter.flags = RTM_F_PREFIX;

net/ipv6/ip6_fib.c

682

if (arg.filter.table_id) {

net/ipv6/ip6_fib.c

683

tb = fib6_get_table(net, arg.filter.table_id);

net/ipv6/ip6mr.c

2744

struct fib_dump_filter filter = {

net/ipv6/ip6mr.c

2751

&filter, cb);

net/ipv6/ip6mr.c

2756

if (filter.table_id) {

net/ipv6/ip6mr.c

2759

mrt = __ip6mr_get_table(sock_net(skb->sk), filter.table_id);

net/ipv6/ip6mr.c

2768

&mfc_unres_lock, &filter);

net/ipv6/ip6mr.c

2773

_ip6mr_fill_mroute, &mfc_unres_lock, &filter);

net/ipv6/raw.c

108

data = &raw6_sk(sk)->filter.data[0];

net/ipv6/raw.c

118

int rawv6_mh_filter_register(mh_filter_t filter)

net/ipv6/raw.c

120

rcu_assign_pointer(mh_filter, filter);

net/ipv6/raw.c

1214

.useroffset = offsetof(struct raw6_sock, filter),

net/ipv6/raw.c

1215

.usersize = sizeof_field(struct raw6_sock, filter),

net/ipv6/raw.c

125

int rawv6_mh_filter_unregister(mh_filter_t filter)

net/ipv6/raw.c

185

mh_filter_t *filter;

net/ipv6/raw.c

187

filter = rcu_dereference(mh_filter);

net/ipv6/raw.c

188

filtered = filter ? (*filter)(sk, skb) : 0;

net/ipv6/raw.c

944

if (copy_from_sockptr(&raw6_sk(sk)->filter, optval, optlen))

net/ipv6/raw.c

969

if (copy_to_user(optval, &raw6_sk(sk)->filter, len))

net/ipv6/route.c

6053

struct fib_dump_filter *filter = &arg->filter;

net/ipv6/route.c

6061

if ((filter->flags & RTM_F_PREFIX) &&

net/ipv6/route.c

6066

if (filter->filter_set &&

net/ipv6/route.c

6067

((filter->rt_type && rt->fib6_type != filter->rt_type) ||

net/ipv6/route.c

6068

(filter->dev && !fib6_info_uses_dev(rt, filter->dev)) ||

net/ipv6/route.c

6069

(filter->protocol && rt->fib6_protocol != filter->protocol))) {

net/ipv6/route.c

6073

if (filter->filter_set ||

net/ipv6/route.c

6074

!filter->dump_routes || !filter->dump_exceptions) {

net/ipv6/route.c

6078

if (filter->dump_routes) {

net/ipv6/route.c

6092

if (filter->dump_exceptions) {

net/key/af_key.c

1833

struct xfrm_address_filter *filter = NULL;

net/key/af_key.c

1858

filter = kmalloc_obj(*filter);

net/key/af_key.c

1859

if (filter == NULL) {

net/key/af_key.c

1864

memcpy(&filter->saddr, &xfilter->sadb_x_filter_saddr,

net/key/af_key.c

1866

memcpy(&filter->daddr, &xfilter->sadb_x_filter_daddr,

net/key/af_key.c

1868

filter->family = xfilter->sadb_x_filter_family;

net/key/af_key.c

1869

filter->splen = xfilter->sadb_x_filter_splen;

net/key/af_key.c

1870

filter->dplen = xfilter->sadb_x_filter_dplen;

net/key/af_key.c

1877

xfrm_state_walk_init(&pfk->dump.u.state, proto, filter);

net/mac80211/ieee80211_i.h

2457

u64 filter;

net/mac80211/mlme.c

7617

parse_params.filter = care_about_ies;

net/mac80211/parse.c

303

bool calc_crc = params->filter != 0;

net/mac80211/parse.c

392

if (calc_crc && id < 64 && (params->filter & (1ULL << id)))

net/mpls/af_mpls.c

2150

struct fib_dump_filter *filter,

net/mpls/af_mpls.c

2153

return ip_valid_fib_dump_req(net, nlh, filter, cb);

net/mpls/af_mpls.c

2157

struct fib_dump_filter *filter,

net/mpls/af_mpls.c

2179

filter->protocol = rtm->rtm_protocol;

net/mpls/af_mpls.c

2180

filter->filter_set = 1;

net/mpls/af_mpls.c

2194

filter->dev = dev_get_by_index_rcu(net, ifindex);

net/mpls/af_mpls.c

2195

if (!filter->dev)

net/mpls/af_mpls.c

2197

filter->filter_set = 1;

net/mpls/af_mpls.c

2231

struct fib_dump_filter filter = {

net/mpls/af_mpls.c

2242

err = mpls_valid_fib_dump_req(net, nlh, &filter, cb);

net/mpls/af_mpls.c

2249

if ((filter.table_id && filter.table_id != RT_TABLE_MAIN) ||

net/mpls/af_mpls.c

2250

(filter.rt_type && filter.rt_type != RTN_UNICAST) ||

net/mpls/af_mpls.c

2251

filter.flags)

net/mpls/af_mpls.c

2261

if (filter.filter_set)

net/mpls/af_mpls.c

2271

if ((filter.dev && !mpls_rt_uses_dev(rt, filter.dev)) ||

net/mpls/af_mpls.c

2272

(filter.protocol && rt->rt_protocol != filter.protocol))

net/netfilter/nf_conntrack_netlink.c

1000

filter->family = family;

net/netfilter/nf_conntrack_netlink.c

1002

err = ctnetlink_filter_parse_mark(&filter->mark, cda);

net/netfilter/nf_conntrack_netlink.c

1006

err = ctnetlink_filter_parse_status(&filter->status, cda);

net/netfilter/nf_conntrack_netlink.c

1011

err = ctnetlink_parse_zone(cda[CTA_ZONE], &filter->zone);

net/netfilter/nf_conntrack_netlink.c

1014

filter->zone_filter = true;

net/netfilter/nf_conntrack_netlink.c

1018

return filter;

net/netfilter/nf_conntrack_netlink.c

1020

err = ctnetlink_parse_filter(cda[CTA_FILTER], filter);

net/netfilter/nf_conntrack_netlink.c

1024

if (filter->orig_flags) {

net/netfilter/nf_conntrack_netlink.c

1030

err = ctnetlink_parse_tuple_filter(cda, &filter->orig,

net/netfilter/nf_conntrack_netlink.c

1032

filter->family,

net/netfilter/nf_conntrack_netlink.c

1033

&filter->zone,

net/netfilter/nf_conntrack_netlink.c

1034

filter->orig_flags);

net/netfilter/nf_conntrack_netlink.c

1039

if (filter->reply_flags) {

net/netfilter/nf_conntrack_netlink.c

1045

err = ctnetlink_parse_tuple_filter(cda, &filter->reply,

net/netfilter/nf_conntrack_netlink.c

1047

filter->family,

net/netfilter/nf_conntrack_netlink.c

1048

&filter->zone,

net/netfilter/nf_conntrack_netlink.c

1049

filter->reply_flags);

net/netfilter/nf_conntrack_netlink.c

1054

return filter;

net/netfilter/nf_conntrack_netlink.c

1057

kfree(filter);

net/netfilter/nf_conntrack_netlink.c

1070

struct ctnetlink_filter *filter = NULL;

net/netfilter/nf_conntrack_netlink.c

1075

filter = ctnetlink_alloc_filter(cda, family);

net/netfilter/nf_conntrack_netlink.c

1076

if (IS_ERR(filter))

net/netfilter/nf_conntrack_netlink.c

1077

return PTR_ERR(filter);

net/netfilter/nf_conntrack_netlink.c

1080

cb->data = filter;

net/netfilter/nf_conntrack_netlink.c

1155

struct ctnetlink_filter *filter = data;

net/netfilter/nf_conntrack_netlink.c

1159

if (filter == NULL)

net/netfilter/nf_conntrack_netlink.c

1166

if (filter->family && nf_ct_l3num(ct) != filter->family)

net/netfilter/nf_conntrack_netlink.c

1169

if (filter->zone_filter &&

net/netfilter/nf_conntrack_netlink.c

1170

!nf_ct_zone_equal_any(ct, &filter->zone))

net/netfilter/nf_conntrack_netlink.c

1173

if (filter->orig_flags) {

net/netfilter/nf_conntrack_netlink.c

1175

if (!ctnetlink_filter_match_tuple(&filter->orig, tuple,

net/netfilter/nf_conntrack_netlink.c

1176

filter->orig_flags,

net/netfilter/nf_conntrack_netlink.c

1177

filter->family))

net/netfilter/nf_conntrack_netlink.c

1181

if (filter->reply_flags) {

net/netfilter/nf_conntrack_netlink.c

1183

if (!ctnetlink_filter_match_tuple(&filter->reply, tuple,

net/netfilter/nf_conntrack_netlink.c

1184

filter->reply_flags,

net/netfilter/nf_conntrack_netlink.c

1185

filter->family))

net/netfilter/nf_conntrack_netlink.c

1190

if ((READ_ONCE(ct->mark) & filter->mark.mask) != filter->mark.val)

net/netfilter/nf_conntrack_netlink.c

1194

if ((status & filter->status.mask) != filter->status.val)

net/netfilter/nf_conntrack_netlink.c

1593

struct ctnetlink_filter *filter = NULL;

net/netfilter/nf_conntrack_netlink.c

1601

filter = ctnetlink_alloc_filter(cda, family);

net/netfilter/nf_conntrack_netlink.c

1602

if (IS_ERR(filter))

net/netfilter/nf_conntrack_netlink.c

1603

return PTR_ERR(filter);

net/netfilter/nf_conntrack_netlink.c

1605

iter.data = filter;

net/netfilter/nf_conntrack_netlink.c

1609

kfree(filter);

net/netfilter/nf_conntrack_netlink.c

918

struct ctnetlink_filter *filter)

net/netfilter/nf_conntrack_netlink.c

929

filter->orig_flags = nla_get_u32(tb[CTA_FILTER_ORIG_FLAGS]);

net/netfilter/nf_conntrack_netlink.c

932

filter->reply_flags = nla_get_u32(tb[CTA_FILTER_REPLY_FLAGS]);

net/netfilter/nf_conntrack_netlink.c

988

struct ctnetlink_filter *filter;

net/netfilter/nf_conntrack_netlink.c

996

filter = kzalloc_obj(*filter);

net/netfilter/nf_conntrack_netlink.c

997

if (filter == NULL)

net/netfilter/nf_tables_api.c

9409

struct nft_flowtable_filter *filter = cb->data;

net/netfilter/nf_tables_api.c

9433

if (filter && filter->table &&

net/netfilter/nf_tables_api.c

9434

strcmp(filter->table, table->name))

net/netfilter/nf_tables_api.c

9460

struct nft_flowtable_filter *filter = NULL;

net/netfilter/nf_tables_api.c

9463

filter = kzalloc_obj(*filter, GFP_ATOMIC);

net/netfilter/nf_tables_api.c

9464

if (!filter)

net/netfilter/nf_tables_api.c

9467

filter->table = nla_strdup(nla[NFTA_FLOWTABLE_TABLE],

net/netfilter/nf_tables_api.c

9469

if (!filter->table) {

net/netfilter/nf_tables_api.c

9470

kfree(filter);

net/netfilter/nf_tables_api.c

9475

cb->data = filter;

net/netfilter/nf_tables_api.c

9481

struct nft_flowtable_filter *filter = cb->data;

net/netfilter/nf_tables_api.c

9483

if (!filter)

net/netfilter/nf_tables_api.c

9486

kfree(filter->table);

net/netfilter/nf_tables_api.c

9487

kfree(filter);

net/netfilter/nfnetlink_acct.c

199

const struct nfacct_filter *filter = cb->data;

net/netfilter/nfnetlink_acct.c

217

if (filter && (cur->flags & filter->mask) != filter->value)

net/netfilter/nfnetlink_acct.c

249

struct nfacct_filter *filter;

net/netfilter/nfnetlink_acct.c

263

filter = kzalloc_obj(struct nfacct_filter);

net/netfilter/nfnetlink_acct.c

264

if (!filter)

net/netfilter/nfnetlink_acct.c

267

filter->mask = ntohl(nla_get_be32(tb[NFACCT_FILTER_MASK]));

net/netfilter/nfnetlink_acct.c

268

filter->value = ntohl(nla_get_be32(tb[NFACCT_FILTER_VALUE]));

net/netfilter/nfnetlink_acct.c

269

cb->data = filter;

net/netfilter/xt_bpf.c

100

return !!bpf_prog_run_save_cb(info->filter, (struct sk_buff *) skb);

net/netfilter/xt_bpf.c

107

bpf_prog_destroy(info->filter);

net/netfilter/xt_bpf.c

114

bpf_prog_destroy(info->filter);

net/netfilter/xt_bpf.c

126

.usersize = offsetof(struct xt_bpf_info, filter),

net/netfilter/xt_bpf.c

137

.usersize = offsetof(struct xt_bpf_info_v1, filter),

net/netfilter/xt_bpf.c

33

program.filter = insns;

net/netfilter/xt_bpf.c

70

&info->filter);

net/netfilter/xt_bpf.c

80

&info->filter);

net/netfilter/xt_bpf.c

82

return __bpf_mt_check_fd(info->fd, &info->filter);

net/netfilter/xt_bpf.c

84

return __bpf_mt_check_path(info->path, &info->filter);

net/netfilter/xt_bpf.c

93

return bpf_prog_run(info->filter, skb);

net/netlink/af_netlink.c

1505

netlink_filter_fn filter,

net/netlink/af_netlink.c

1525

info.tx_filter = filter;

net/packet/af_packet.c

2076

struct sk_filter *filter;

net/packet/af_packet.c

2079

filter = rcu_dereference(sk->sk_filter);

net/packet/af_packet.c

2080

if (filter != NULL)

net/packet/af_packet.c

2081

res = bpf_prog_run_clear_cb(filter->prog, skb);

net/qrtr/ns.c

526

struct qrtr_server_filter filter;

net/qrtr/ns.c

546

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

net/qrtr/ns.c

547

filter.service = service;

net/qrtr/ns.c

548

filter.instance = instance;

net/qrtr/ns.c

552

if (!server_match(srv, &filter))

net/sched/act_bpf.c

124

if (nla_put_u32(skb, TCA_ACT_BPF_ID, prog->filter->aux->id))

net/sched/act_bpf.c

127

nla = nla_reserve(skb, TCA_ACT_BPF_TAG, sizeof(prog->filter->tag));

net/sched/act_bpf.c

131

memcpy(nla_data(nla), prog->filter->tag, nla_len(nla));

net/sched/act_bpf.c

206

fprog_tmp.filter = bpf_ops;

net/sched/act_bpf.c

216

cfg->filter = fp;

net/sched/act_bpf.c

243

cfg->filter = fp;

net/sched/act_bpf.c

251

struct bpf_prog *filter = cfg->filter;

net/sched/act_bpf.c

253

if (filter) {

net/sched/act_bpf.c

255

bpf_prog_put(filter);

net/sched/act_bpf.c

257

bpf_prog_destroy(filter);

net/sched/act_bpf.c

26

struct bpf_prog *filter;

net/sched/act_bpf.c

271

cfg->filter = rcu_dereference_protected(prog->filter, 1);

net/sched/act_bpf.c

361

rcu_assign_pointer(prog->filter, cfg.filter);

net/sched/act_bpf.c

41

struct bpf_prog *filter;

net/sched/act_bpf.c

47

filter = rcu_dereference(prog->filter);

net/sched/act_bpf.c

50

filter_res = bpf_prog_run_data_pointers(filter, skb);

net/sched/act_bpf.c

53

filter_res = bpf_prog_run_data_pointers(filter, skb);

net/sched/bpf_qdisc.c

350

.filter = bpf_qdisc_kfunc_filter,

net/sched/cls_bpf.c

100

filter_res = bpf_prog_run_data_pointers(prog->filter, skb);

net/sched/cls_bpf.c

103

filter_res = bpf_prog_run_data_pointers(prog->filter, skb);

net/sched/cls_bpf.c

159

cls_bpf.prog = prog ? prog->filter : NULL;

net/sched/cls_bpf.c

160

cls_bpf.oldprog = oldprog ? oldprog->filter : NULL;

net/sched/cls_bpf.c

234

cls_bpf.prog = prog->filter;

net/sched/cls_bpf.c

259

bpf_prog_put(prog->filter);

net/sched/cls_bpf.c

261

bpf_prog_destroy(prog->filter);

net/sched/cls_bpf.c

358

fprog_tmp.filter = bpf_ops;

net/sched/cls_bpf.c

369

prog->filter = fp;

net/sched/cls_bpf.c

39

struct bpf_prog *filter;

net/sched/cls_bpf.c

399

prog->filter = fp;

net/sched/cls_bpf.c

565

if (nla_put_u32(skb, TCA_BPF_ID, prog->filter->aux->id))

net/sched/cls_bpf.c

568

nla = nla_reserve(skb, TCA_BPF_TAG, sizeof(prog->filter->tag));

net/sched/cls_bpf.c

572

memcpy(nla_data(nla), prog->filter->tag, nla_len(nla));

net/sched/cls_bpf.c

667

cls_bpf.prog = add ? prog->filter : NULL;

net/sched/cls_bpf.c

668

cls_bpf.oldprog = add ? NULL : prog->filter;

net/sched/cls_flower.c

224

static bool fl_range_port_dst_cmp(struct cls_fl_filter *filter,

net/sched/cls_flower.c

230

min_mask = ntohs(filter->mask->key.tp_range.tp_min.dst);

net/sched/cls_flower.c

231

max_mask = ntohs(filter->mask->key.tp_range.tp_max.dst);

net/sched/cls_flower.c

232

min_val = ntohs(filter->key.tp_range.tp_min.dst);

net/sched/cls_flower.c

233

max_val = ntohs(filter->key.tp_range.tp_max.dst);

net/sched/cls_flower.c

241

mkey->tp_range.tp_min.dst = filter->mkey.tp_range.tp_min.dst;

net/sched/cls_flower.c

242

mkey->tp_range.tp_max.dst = filter->mkey.tp_range.tp_max.dst;

net/sched/cls_flower.c

247

static bool fl_range_port_src_cmp(struct cls_fl_filter *filter,

net/sched/cls_flower.c

253

min_mask = ntohs(filter->mask->key.tp_range.tp_min.src);

net/sched/cls_flower.c

254

max_mask = ntohs(filter->mask->key.tp_range.tp_max.src);

net/sched/cls_flower.c

255

min_val = ntohs(filter->key.tp_range.tp_min.src);

net/sched/cls_flower.c

256

max_val = ntohs(filter->key.tp_range.tp_max.src);

net/sched/cls_flower.c

264

mkey->tp_range.tp_min.src = filter->mkey.tp_range.tp_min.src;

net/sched/cls_flower.c

265

mkey->tp_range.tp_max.src = filter->mkey.tp_range.tp_max.src;

net/sched/cls_flower.c

281

struct cls_fl_filter *filter, *f;

net/sched/cls_flower.c

283

list_for_each_entry_rcu(filter, &mask->filters, list) {

net/sched/cls_flower.c

284

if (!fl_range_port_dst_cmp(filter, key, mkey))

net/sched/cls_flower.c

287

if (!fl_range_port_src_cmp(filter, key, mkey))

net/sched/cls_route.c

149

(f = head->fastmap[h].filter) != NULL) {

net/sched/cls_route.c

30

struct route4_filter *filter;

net/sched/cls_route.c

86

head->fastmap[h].filter = f;

net/sched/sch_cake.c

1716

struct tcf_proto *filter;

net/sched/sch_cake.c

1721

filter = rcu_dereference_bh(q->filter_list);

net/sched/sch_cake.c

1722

if (!filter)

net/sched/sch_cake.c

1726

result = tcf_classify(skb, NULL, filter, &res, false);

net/sched/sch_fq_codel.c

80

struct tcf_proto *filter;

net/sched/sch_fq_codel.c

89

filter = rcu_dereference_bh(q->filter_list);

net/sched/sch_fq_codel.c

90

if (!filter)

net/sched/sch_fq_codel.c

94

result = tcf_classify(skb, NULL, filter, &res, false);

net/sched/sch_fq_pie.c

85

struct tcf_proto *filter;

net/sched/sch_fq_pie.c

94

filter = rcu_dereference_bh(q->filter_list);

net/sched/sch_fq_pie.c

95

if (!filter)

net/sched/sch_fq_pie.c

99

result = tcf_classify(skb, NULL, filter, &res, false);

net/tipc/group.c

167

u32 filter = TIPC_SUB_PORTS | TIPC_SUB_NO_STATUS;

net/tipc/group.c

189

filter |= global ? TIPC_SUB_CLUSTER_SCOPE : TIPC_SUB_NODE_SCOPE;

net/tipc/group.c

191

filter, &grp->subid))

net/tipc/msg.h

1219

static inline u32 tipc_skb_peek_port(struct sk_buff_head *list, u32 filter)

net/tipc/msg.h

1228

if (!filter || skb_queue_is_last(list, skb))

net/tipc/msg.h

1230

if (dport == filter)

net/tipc/name_table.c

429

u32 filter, lower, upper;

net/tipc/name_table.c

431

filter = sub->s.filter;

net/tipc/name_table.c

438

if (filter & TIPC_SUB_NO_STATUS)

net/tipc/name_table.c

445

if (filter & TIPC_SUB_PORTS)

net/tipc/subscr.c

137

u32 filter = tipc_sub_read(s, filter);

net/tipc/subscr.c

141

if ((filter & TIPC_SUB_PORTS && filter & TIPC_SUB_SERVICE) ||

net/tipc/subscr.c

160

sub->s.filter = filter;

net/tipc/subscr.c

91

u32 filter = sub->s.filter;

net/tipc/subscr.c

95

if (!must && !(filter & TIPC_SUB_PORTS))

net/tipc/subscr.c

97

if (filter & TIPC_SUB_CLUSTER_SCOPE && p->scope == TIPC_NODE_SCOPE)

net/tipc/subscr.c

99

if (filter & TIPC_SUB_NODE_SCOPE && p->scope != TIPC_NODE_SCOPE)

net/tipc/subscr.h

108

int swap_ = !((sub__)->filter & TIPC_FILTER_MASK); \

net/tipc/subscr.h

118

int swap_ = !((evt__)->s.filter & (TIPC_FILTER_MASK)); \

net/tipc/subscr.h

98

int swap_ = !((sub__)->filter & TIPC_FILTER_MASK); \

net/tipc/topsrv.c

367

u32 s_filter = tipc_sub_read(s, filter);

net/tipc/topsrv.c

370

tipc_sub_write(s, filter, s_filter & ~TIPC_SUB_CANCEL);

net/tipc/topsrv.c

574

u32 upper, u32 filter, int *conid)

net/tipc/topsrv.c

584

sub.filter = filter;

net/tipc/topsrv.h

51

u32 upper, u32 filter, int *conid);

net/wireless/nl80211.c

15888

struct cfg80211_nan_func_filter *filter;

net/wireless/nl80211.c

15896

filter = kzalloc_objs(*func->rx_filters, n_entries);

net/wireless/nl80211.c

15897

if (!filter)

net/wireless/nl80211.c

15902

filter[i].filter = nla_memdup(attr, GFP_KERNEL);

net/wireless/nl80211.c

15903

if (!filter[i].filter)

net/wireless/nl80211.c

15906

filter[i].len = nla_len(attr);

net/wireless/nl80211.c

15911

func->tx_filters = filter;

net/wireless/nl80211.c

15914

func->rx_filters = filter;

net/wireless/nl80211.c

15922

kfree(filter[i].filter);

net/wireless/nl80211.c

15925

kfree(filter);

net/wireless/util.c

2687

kfree(f->rx_filters[i].filter);

net/wireless/util.c

2690

kfree(f->tx_filters[i].filter);

net/xfrm/xfrm_state.c

2636

struct xfrm_address_filter *filter)

net/xfrm/xfrm_state.c

2638

if (filter) {

net/xfrm/xfrm_state.c

2639

if ((filter->family == AF_INET ||

net/xfrm/xfrm_state.c

2640

filter->family == AF_INET6) &&

net/xfrm/xfrm_state.c

2641

x->props.family != filter->family)

net/xfrm/xfrm_state.c

2644

return addr_match(&x->props.saddr, &filter->saddr,

net/xfrm/xfrm_state.c

2645

filter->splen) &&

net/xfrm/xfrm_state.c

2646

addr_match(&x->id.daddr, &filter->daddr,

net/xfrm/xfrm_state.c

2647

filter->dplen);

net/xfrm/xfrm_state.c

2674

if (!__xfrm_state_filter_match(state, walk->filter))

net/xfrm/xfrm_state.c

2695

struct xfrm_address_filter *filter)

net/xfrm/xfrm_state.c

2701

walk->filter = filter;

net/xfrm/xfrm_state.c

2707

kfree(walk->filter);

net/xfrm/xfrm_user.c

1515

struct xfrm_address_filter *filter = NULL;

net/xfrm/xfrm_user.c

1525

filter = kmemdup(nla_data(attrs[XFRMA_ADDRESS_FILTER]),

net/xfrm/xfrm_user.c

1526

sizeof(*filter), GFP_KERNEL);

net/xfrm/xfrm_user.c

1527

if (filter == NULL)

net/xfrm/xfrm_user.c

1533

if (filter->splen > (sizeof(xfrm_address_t) << 3) ||

net/xfrm/xfrm_user.c

1534

filter->dplen > (sizeof(xfrm_address_t) << 3)) {

net/xfrm/xfrm_user.c

1535

kfree(filter);

net/xfrm/xfrm_user.c

1543

xfrm_state_walk_init(walk, proto, filter);

samples/bpf/tracex5_user.c

24

struct sock_filter filter[] = {

samples/bpf/tracex5_user.c

28

.len = (unsigned short)ARRAY_SIZE(filter),

samples/bpf/tracex5_user.c

29

.filter = filter,

samples/damon/mtier.c

162

filter = damos_new_filter(DAMOS_FILTER_TYPE_YOUNG, true, promote);

samples/damon/mtier.c

163

if (!filter)

samples/damon/mtier.c

165

damos_add_filter(scheme, filter);

samples/damon/mtier.c

81

struct damos_filter *filter;

samples/seccomp/bpf-direct.c

113

struct sock_filter filter[] = {

samples/seccomp/bpf-direct.c

146

.len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),

samples/seccomp/bpf-direct.c

147

.filter = filter,

samples/seccomp/bpf-fancy.c

35

struct sock_filter filter[] = {

samples/seccomp/bpf-fancy.c

82

.filter = filter,

samples/seccomp/bpf-fancy.c

83

.len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),

samples/seccomp/bpf-fancy.c

86

bpf_resolve_jumps(&l, filter, sizeof(filter)/sizeof(*filter));

samples/seccomp/bpf-helper.c

20

struct sock_filter *filter, size_t count)

samples/seccomp/bpf-helper.c

32

struct sock_filter *instr = &filter[offset];

samples/seccomp/bpf-helper.c

90

void seccomp_bpf_print(struct sock_filter *filter, size_t count)

samples/seccomp/bpf-helper.c

92

struct sock_filter *end = filter + count;

samples/seccomp/bpf-helper.c

93

for ( ; filter < end; ++filter)

samples/seccomp/bpf-helper.c

95

filter->code, filter->jt, filter->jf, filter->k);

samples/seccomp/bpf-helper.h

36

struct sock_filter *filter, size_t count);

samples/seccomp/bpf-helper.h

38

void seccomp_bpf_print(struct sock_filter *filter, size_t count);

samples/seccomp/dropper.c

30

struct sock_filter filter[] = {

samples/seccomp/dropper.c

42

.len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),

samples/seccomp/dropper.c

43

.filter = filter,

samples/seccomp/dropper.c

47

filter[4] = kill;

samples/seccomp/user-trap.c

101

.len = (unsigned short)ARRAY_SIZE(filter),

samples/seccomp/user-trap.c

102

.filter = filter,

samples/seccomp/user-trap.c

92

struct sock_filter filter[] = {

samples/watch_queue/watch_test.c

150

static struct watch_notification_filter filter = {

samples/watch_queue/watch_test.c

175

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

scripts/kconfig/gconf.c

1150

GtkTreeModel *filter;

scripts/kconfig/gconf.c

1162

filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(tree1), NULL);

scripts/kconfig/gconf.c

1164

gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter),

scripts/kconfig/gconf.c

1166

gtk_tree_view_set_model(view, filter);

scripts/kconfig/gconf.c

1200

GtkTreeModel *filter;

scripts/kconfig/gconf.c

1213

filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(tree2), NULL);

scripts/kconfig/gconf.c

1215

gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter),

scripts/kconfig/gconf.c

1217

gtk_tree_view_set_model(view, filter);

scripts/kconfig/gconf.c

139

GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER(gtk_tree_view_get_model(view));

scripts/kconfig/gconf.c

141

gtk_tree_model_filter_refilter(filter);

sound/core/seq/seq_clientmgr.c

1187

info->filter = cptr->filter;

sound/core/seq/seq_clientmgr.c

1251

client->filter = client_info->filter;

sound/core/seq/seq_clientmgr.c

507

if ((dest->filter & SNDRV_SEQ_FILTER_USE_EVENT) &&

sound/core/seq/seq_clientmgr.c

534

! (client->filter & SNDRV_SEQ_FILTER_BOUNCE) ||

sound/core/seq/seq_clientmgr.c

632

if (!(dest->filter & SNDRV_SEQ_FILTER_NO_CONVERT))

sound/core/seq/seq_clientmgr.c

639

if (!(dest->filter & SNDRV_SEQ_FILTER_NO_CONVERT))

sound/core/seq/seq_clientmgr.h

41

unsigned int filter; /* filter flags */

sound/core/seq/seq_dummy.c

190

client->filter = SNDRV_SEQ_FILTER_NO_CONVERT;

sound/core/seq/seq_ump_client.c

366

unsigned int filter;

sound/core/seq/seq_ump_client.c

372

filter = ~(1U << 0); /* always allow groupless messages */

sound/core/seq/seq_ump_client.c

375

filter &= ~(1U << (p + 1));

sound/core/seq/seq_ump_client.c

377

cptr->group_filter = filter;

sound/core/timer.c

1349

if ((tu->filter & (1 << event)) == 0 || !tu->tread)

sound/core/timer.c

1382

if ((tu->filter & ((1 << SNDRV_TIMER_EVENT_RESOLUTION) |

sound/core/timer.c

1391

if ((tu->filter & (1 << SNDRV_TIMER_EVENT_RESOLUTION)) &&

sound/core/timer.c

1401

if ((tu->filter & (1 << SNDRV_TIMER_EVENT_TICK)) == 0)

sound/core/timer.c

1821

if (params.filter & ~((1<<SNDRV_TIMER_EVENT_RESOLUTION)|

sound/core/timer.c

1877

tu->filter = params.filter;

sound/core/timer.c

85

unsigned int filter;

sound/pci/au88x0/au88x0_a3d.c

708

static void vortex_a3d_translate_filter(a3d_atmos_t filter, int *params)

sound/pci/au88x0/au88x0_a3d.c

825

vortex_a3d_translate_filter(a->filter, params);

sound/pci/au88x0/au88x0_a3d.c

827

a3dsrc_SetAtmosTarget(a, a->filter[0],

sound/pci/au88x0/au88x0_a3d.c

828

a->filter[1], a->filter[2],

sound/pci/au88x0/au88x0_a3d.c

829

a->filter[3], a->filter[4]);

sound/pci/au88x0/au88x0_a3d.c

830

a3dsrc_SetAtmosCurrent(a, a->filter[0],

sound/pci/au88x0/au88x0_a3d.c

831

a->filter[1], a->filter[2],

sound/pci/au88x0/au88x0_a3d.c

832

a->filter[3], a->filter[4]);

sound/pci/au88x0/au88x0_a3d.h

43

a3d_atmos_t filter;

sound/soc/codecs/88pm860x-codec.c

138

unsigned int filter;

sound/soc/dwc/dwc-i2s.c

687

dev->play_dma_data.pd.filter = pdata->filter;

sound/soc/dwc/dwc-i2s.c

688

dev->capture_dma_data.pd.filter = pdata->filter;

sound/soc/fsl/fsl_asrc_dma.c

257

__dma_request_channel(&mask, filter, &pair->dma_data,

sound/soc/fsl/imx-pcm-dma.c

34

.compat_filter_fn = filter,

sound/soc/renesas/siu_pcm.c

322

siu_stream->chan = dma_request_channel(mask, filter, param);

sound/soc/samsung/dma.h

15

int samsung_asoc_dma_platform_register(struct device *dev, dma_filter_fn filter,

sound/soc/samsung/dmaengine.c

17

int samsung_asoc_dma_platform_register(struct device *dev, dma_filter_fn filter,

sound/soc/samsung/dmaengine.c

28

pcm_conf->compat_filter_fn = filter;

sound/soc/samsung/i2s.c

1449

pri_dai->filter = i2s_pdata->dma_filter;

sound/soc/samsung/i2s.c

1490

ret = samsung_asoc_dma_platform_register(&pdev->dev, pri_dai->filter,

sound/soc/samsung/i2s.c

1503

sec_dai->filter = i2s_pdata->dma_filter;

sound/soc/samsung/i2s.c

1517

sec_dai->filter, "tx-sec", NULL,

sound/soc/samsung/i2s.c

84

dma_filter_fn filter;

sound/soc/samsung/pcm.c

492

dma_filter_fn filter;

sound/soc/samsung/pcm.c

545

filter = NULL;

sound/soc/samsung/pcm.c

549

filter = pcm_pdata->dma_filter;

sound/soc/samsung/pcm.c

555

ret = samsung_asoc_dma_platform_register(&pdev->dev, filter,

sound/soc/samsung/spdif.c

366

dma_filter_fn filter;

sound/soc/samsung/spdif.c

427

filter = NULL;

sound/soc/samsung/spdif.c

430

filter = spdif_pdata->dma_filter;

sound/soc/samsung/spdif.c

434

ret = samsung_asoc_dma_platform_register(&pdev->dev, filter,

sound/soc/spear/spdif_in.c

260

pdata->filter);

sound/soc/spear/spdif_out.c

315

pdata->filter);

sound/soc/spear/spear_pcm.c

42

bool (*filter)(struct dma_chan *chan, void *slave))

sound/soc/spear/spear_pcm.c

45

config->compat_filter_fn = filter;

sound/soc/spear/spear_pcm.h

11

bool (*filter)(struct dma_chan *chan, void *slave));

tools/bpf/bpf_dbg.c

502

.filter = f,

tools/firewire/nosy-dump.c

898

uint32_t filter;

tools/firewire/nosy-dump.c

956

filter = ~0;

tools/firewire/nosy-dump.c

958

filter &= ~(1 << TCODE_STREAM_DATA);

tools/firewire/nosy-dump.c

960

filter &= ~(1 << TCODE_CYCLE_START);

tools/firewire/nosy-dump.c

962

filter = ~(1 << TCODE_CYCLE_START);

tools/firewire/nosy-dump.c

964

ioctl(fd, NOSY_IOC_FILTER, filter);

tools/include/uapi/linux/filter.h

33

struct sock_filter *filter;

tools/lib/perf/evsel.c

500

int perf_evsel__apply_filter(struct perf_evsel *evsel, const char *filter)

tools/lib/perf/evsel.c

507

(void *)filter, i);

tools/lib/perf/include/internal/evsel.h

143

int perf_evsel__apply_filter(struct perf_evsel *evsel, const char *filter);

tools/mm/page_owner_sort.c

101

static int filter;

tools/mm/page_owner_sort.c

455

if ((filter & FILTER_PID) && !match_num_list(get_pid(buf), fc.pids, fc.pids_size))

tools/mm/page_owner_sort.c

457

if ((filter & FILTER_TGID) &&

tools/mm/page_owner_sort.c

463

if ((filter & FILTER_COMM) &&

tools/mm/page_owner_sort.c

712

filter = filter | FILTER_PID;

tools/mm/page_owner_sort.c

721

filter = filter | FILTER_TGID;

tools/mm/page_owner_sort.c

730

filter = filter | FILTER_COMM;

tools/mm/page_owner_sort.c

858

if (cull & CULL_PID || filter & FILTER_PID)

tools/mm/page_owner_sort.c

860

if (cull & CULL_TGID || filter & FILTER_TGID)

tools/mm/page_owner_sort.c

862

if (cull & CULL_COMM || filter & FILTER_COMM)

tools/perf/arch/x86/util/intel-pt.c

283

return evsel->filter;

tools/perf/arch/x86/util/intel-pt.c

289

static size_t intel_pt_filter_bytes(const char *filter)

tools/perf/arch/x86/util/intel-pt.c

291

size_t len = filter ? strlen(filter) : 0;

tools/perf/arch/x86/util/intel-pt.c

301

const char *filter = intel_pt_find_filter(evlist, ptr->intel_pt_pmu);

tools/perf/arch/x86/util/intel-pt.c

304

intel_pt_filter_bytes(filter);

tools/perf/arch/x86/util/intel-pt.c

334

const char *filter;

tools/perf/arch/x86/util/intel-pt.c

357

filter = intel_pt_find_filter(session->evlist, ptr->intel_pt_pmu);

tools/perf/arch/x86/util/intel-pt.c

358

filter_str_len = filter ? strlen(filter) : 0;

tools/perf/arch/x86/util/intel-pt.c

400

size_t len = intel_pt_filter_bytes(filter);

tools/perf/arch/x86/util/intel-pt.c

402

strncpy((char *)info, filter, len);

tools/perf/arch/x86/util/iostat.c

249

const char *filter)

tools/perf/arch/x86/util/iostat.c

261

filter_copy = strdup(filter);

tools/perf/bench/sched-seccomp-notify.c

51

struct sock_filter filter[] = {

tools/perf/bench/sched-seccomp-notify.c

60

.len = (unsigned short)ARRAY_SIZE(filter),

tools/perf/bench/sched-seccomp-notify.c

61

.filter = filter,

tools/perf/builtin-ftrace.c

1547

struct strfilter *filter = (struct strfilter *)arg;

tools/perf/builtin-ftrace.c

1549

if (strfilter__compare(filter, str))

tools/perf/builtin-ftrace.c

1556

struct strfilter *filter;

tools/perf/builtin-ftrace.c

1563

filter = strfilter__new(str, &err);

tools/perf/builtin-ftrace.c

1564

if (!filter)

tools/perf/builtin-ftrace.c

1567

ret = strfilter__or(filter, str, &err);

tools/perf/builtin-ftrace.c

1572

strfilter__delete(filter);

tools/perf/builtin-ftrace.c

1577

list_function_cb, filter);

tools/perf/builtin-ftrace.c

1578

strfilter__delete(filter);

tools/perf/builtin-probe.c

328

strfilter__delete(params->filter);

tools/perf/builtin-probe.c

414

static int del_perf_probe_caches(struct strfilter *filter)

tools/perf/builtin-probe.c

432

if (probe_cache__filter_purge(cache, filter) < 0 ||

tools/perf/builtin-probe.c

440

static int perf_del_probe_events(struct strfilter *filter)

tools/perf/builtin-probe.c

443

char *str = strfilter__string(filter);

tools/perf/builtin-probe.c

453

return del_perf_probe_caches(filter);

tools/perf/builtin-probe.c

467

ret = probe_file__get_events(kfd, filter, klist);

tools/perf/builtin-probe.c

478

ret2 = probe_file__get_events(ufd, filter, ulist);

tools/perf/builtin-probe.c

48

struct strfilter *filter;

tools/perf/builtin-probe.c

686

ret = show_perf_probe_events(params->filter);

tools/perf/builtin-probe.c

692

params->filter, params->uprobes);

tools/perf/builtin-probe.c

704

if (!params->filter)

tools/perf/builtin-probe.c

705

params->filter = strfilter__new(DEFAULT_VAR_FILTER,

tools/perf/builtin-probe.c

709

params->filter);

tools/perf/builtin-probe.c

715

ret = perf_del_probe_events(params->filter);

tools/perf/builtin-probe.c

87

if (!params->filter) {

tools/perf/builtin-probe.c

88

params->filter = strfilter__new(str, &err);

tools/perf/builtin-probe.c

89

if (!params->filter)

tools/perf/builtin-probe.c

92

ret = strfilter__or(params->filter, str, &err);

tools/perf/builtin-record.c

1465

pos->filter ?: "BPF", evsel__name(pos));

tools/perf/builtin-stat.c

922

counter->filter, evsel__name(counter));

tools/perf/builtin-timechart.c

1659

char *filter = NULL;

tools/perf/builtin-timechart.c

1739

if (asprintf(&filter, "common_pid != %d", getpid()) < 0) {

tools/perf/builtin-timechart.c

1757

*p++ = filter;

tools/perf/builtin-timechart.c

1768

*p++ = filter;

tools/perf/builtin-timechart.c

1779

*p++ = filter;

tools/perf/builtin-top.c

1062

counter->filter ?: "BPF", evsel__name(counter), errno,

tools/perf/builtin-trace.c

3499

char *filter = asprintf__tp_filter_pids(1, &pid);

tools/perf/builtin-trace.c

3513

if (rec_argv == NULL || filter == NULL)

tools/perf/builtin-trace.c

3536

rec_argv[j++] = filter;

tools/perf/builtin-trace.c

3551

free(filter);

tools/perf/builtin-trace.c

3708

char *filter = asprintf_expr_inout_ints("id", !trace->not_ev_qualifier,

tools/perf/builtin-trace.c

3712

if (filter == NULL)

tools/perf/builtin-trace.c

3715

if (!evsel__append_tp_filter(trace->syscalls.events.sys_enter, filter)) {

tools/perf/builtin-trace.c

3717

err = evsel__append_tp_filter(sys_exit, filter);

tools/perf/builtin-trace.c

3720

free(filter);

tools/perf/builtin-trace.c

4258

char *tok, *left = evsel->filter, *new_filter = evsel->filter;

tools/perf/builtin-trace.c

4299

arg, evsel->name, evsel->filter);

tools/perf/builtin-trace.c

4327

if (new_filter != evsel->filter)

tools/perf/builtin-trace.c

4333

right_size, right, arg, evsel->name, evsel->filter);

tools/perf/builtin-trace.c

4338

arg, evsel->name, evsel->filter);

tools/perf/builtin-trace.c

4348

if (new_filter != evsel->filter) {

tools/perf/builtin-trace.c

4363

if (evsel->filter == NULL)

tools/perf/builtin-trace.c

4505

trace->syscalls.events.sys_exit->filter);

tools/perf/builtin-trace.c

4677

evsel->filter, evsel__name(evsel));

tools/perf/trace/beauty/include/uapi/sound/asound.h

967

unsigned int filter; /* event filter (bitmask of SNDRV_TIMER_EVENT_*) */

tools/perf/ui/browser.c

522

if (!browser->filter || !browser->filter(browser, pos)) {

tools/perf/ui/browser.c

651

if (!browser->filter || !browser->filter(browser, *pos)) {

tools/perf/ui/browser.c

82

if (!browser->filter || !browser->filter(browser, pos))

tools/perf/ui/browser.c

95

if (!browser->filter || !browser->filter(browser, pos))

tools/perf/ui/browser.h

31

bool (*filter)(struct ui_browser *browser, void *entry);

tools/perf/ui/browsers/annotate-data.c

231

if (!uib->filter || !uib->filter(uib, &entry->node))

tools/perf/ui/browsers/annotate-data.c

257

if (!uib->filter || !uib->filter(uib, &entry->node))

tools/perf/ui/browsers/annotate-data.c

274

if (uib->filter && uib->filter(uib, &entry->node))

tools/perf/ui/browsers/annotate-data.c

284

if (uib->filter && uib->filter(uib, &entry->node))

tools/perf/ui/browsers/annotate-data.c

316

if (!uib->filter || !uib->filter(uib, &entry->node)) {

tools/perf/ui/browsers/annotate.c

1169

.filter = disasm_line__filter,

tools/perf/ui/browsers/hists.c

3625

.filter = filter_group_entries,

tools/perf/util/auxtrace.c

2395

const char *filter)

tools/perf/util/auxtrace.c

2398

const char *fstr = filter;

tools/perf/util/auxtrace.c

2805

char *filter;

tools/perf/util/auxtrace.c

2816

err = asprintf(&filter, "%s 0x%"PRIx64"/0x%"PRIx64"%s%s",

tools/perf/util/auxtrace.c

2819

err = asprintf(&filter, "%s 0x%"PRIx64"%s%s",

tools/perf/util/auxtrace.c

2823

return err < 0 ? NULL : filter;

tools/perf/util/auxtrace.c

2826

static int parse_addr_filter(struct evsel *evsel, const char *filter,

tools/perf/util/auxtrace.c

2835

err = addr_filters__parse_bare_filter(&filts, filter);

tools/perf/util/auxtrace.c

2869

pr_err("Failed to parse address filter: '%s'\n", filter);

tools/perf/util/auxtrace.c

2893

char *filter;

tools/perf/util/auxtrace.c

2897

filter = evsel->filter;

tools/perf/util/auxtrace.c

2899

if (!filter || !max_nr)

tools/perf/util/auxtrace.c

2901

evsel->filter = NULL;

tools/perf/util/auxtrace.c

2902

err = parse_addr_filter(evsel, filter, max_nr);

tools/perf/util/auxtrace.c

2903

free(filter);

tools/perf/util/auxtrace.c

2906

pr_debug("Address filter: %s\n", evsel->filter);

tools/perf/util/auxtrace.h

635

const char *filter);

tools/perf/util/bpf-filter.y

52

filter:

tools/perf/util/bpf-filter.y

53

filter ',' filter_term

tools/perf/util/bpf_counter.c

631

filter_map_fd = bpf_map__fd(evsel->follower_skel->maps.filter);

tools/perf/util/bpf_skel/bperf_follower.bpf.c

123

parent_fval = bpf_map_lookup_elem(&filter, &parent_key);

tools/perf/util/bpf_skel/bperf_follower.bpf.c

133

bpf_map_update_elem(&filter, &child_key, &child_fval, BPF_NOEXIST);

tools/perf/util/bpf_skel/bperf_follower.bpf.c

155

fval = bpf_map_lookup_elem(&filter, &pid);

tools/perf/util/bpf_skel/bperf_follower.bpf.c

30

} filter SEC(".maps");

tools/perf/util/bpf_skel/bperf_follower.bpf.c

72

fval = bpf_map_lookup_elem(&filter, &filter_key);

tools/perf/util/bpf_skel/bperf_follower.bpf.c

78

bpf_map_delete_elem(&filter, &filter_key);

tools/perf/util/evlist.c

1110

if (evsel->filter) {

tools/perf/util/evlist.c

1111

err = perf_evsel__apply_filter(&evsel->core, evsel->filter);

tools/perf/util/evlist.c

1133

int evlist__set_tp_filter(struct evlist *evlist, const char *filter)

tools/perf/util/evlist.c

1138

if (filter == NULL)

tools/perf/util/evlist.c

1145

err = evsel__set_filter(evsel, filter);

tools/perf/util/evlist.c

1153

int evlist__append_tp_filter(struct evlist *evlist, const char *filter)

tools/perf/util/evlist.c

1158

if (filter == NULL)

tools/perf/util/evlist.c

1165

err = evsel__append_tp_filter(evsel, filter);

tools/perf/util/evlist.c

1175

char *filter;

tools/perf/util/evlist.c

1180

if (asprintf(&filter, "common_pid != %d", pids[i]) < 0)

tools/perf/util/evlist.c

1185

if (asprintf(&tmp, "%s && common_pid != %d", filter, pids[i]) < 0)

tools/perf/util/evlist.c

1188

free(filter);

tools/perf/util/evlist.c

1189

filter = tmp;

tools/perf/util/evlist.c

1193

return filter;

tools/perf/util/evlist.c

1195

free(filter);

tools/perf/util/evlist.c

1201

char *filter = asprintf__tp_filter_pids(npids, pids);

tools/perf/util/evlist.c

1202

int ret = evlist__set_tp_filter(evlist, filter);

tools/perf/util/evlist.c

1204

free(filter);

tools/perf/util/evlist.c

1210

char *filter = asprintf__tp_filter_pids(npids, pids);

tools/perf/util/evlist.c

1211

int ret = evlist__append_tp_filter(evlist, filter);

tools/perf/util/evlist.c

1213

free(filter);

tools/perf/util/evlist.h

147

int evlist__set_tp_filter(struct evlist *evlist, const char *filter);

tools/perf/util/evlist.h

150

int evlist__append_tp_filter(struct evlist *evlist, const char *filter);

tools/perf/util/evsel.c

1750

int evsel__set_filter(struct evsel *evsel, const char *filter)

tools/perf/util/evsel.c

1752

char *new_filter = strdup(filter);

tools/perf/util/evsel.c

1755

free(evsel->filter);

tools/perf/util/evsel.c

1756

evsel->filter = new_filter;

tools/perf/util/evsel.c

1763

static int evsel__append_filter(struct evsel *evsel, const char *fmt, const char *filter)

tools/perf/util/evsel.c

1767

if (evsel->filter == NULL)

tools/perf/util/evsel.c

1768

return evsel__set_filter(evsel, filter);

tools/perf/util/evsel.c

1770

if (asprintf(&new_filter, fmt, evsel->filter, filter) > 0) {

tools/perf/util/evsel.c

1771

free(evsel->filter);

tools/perf/util/evsel.c

1772

evsel->filter = new_filter;

tools/perf/util/evsel.c

1779

int evsel__append_tp_filter(struct evsel *evsel, const char *filter)

tools/perf/util/evsel.c

1781

return evsel__append_filter(evsel, "(%s) && (%s)", filter);

tools/perf/util/evsel.c

1784

int evsel__append_addr_filter(struct evsel *evsel, const char *filter)

tools/perf/util/evsel.c

1786

return evsel__append_filter(evsel, "%s,%s", filter);

tools/perf/util/evsel.c

1871

zfree(&evsel->filter);

tools/perf/util/evsel.c

516

if (orig->filter) {

tools/perf/util/evsel.c

517

evsel->filter = strdup(orig->filter);

tools/perf/util/evsel.c

518

if (evsel->filter == NULL)

tools/perf/util/evsel.h

348

int evsel__set_filter(struct evsel *evsel, const char *filter);

tools/perf/util/evsel.h

349

int evsel__append_tp_filter(struct evsel *evsel, const char *filter);

tools/perf/util/evsel.h

350

int evsel__append_addr_filter(struct evsel *evsel, const char *filter);

tools/perf/util/evsel.h

67

char *filter;

tools/perf/util/hist.c

2229

enum hist_filter filter)

tools/perf/util/hist.c

2231

h->filtered &= ~(1 << filter);

tools/perf/util/hist.c

2239

parent->filtered &= ~(1 << filter);

tools/perf/util/hist.c

2331

static void hists__filter_by_type(struct hists *hists, int type, filter_fn_t filter)

tools/perf/util/hist.c

2343

if (filter(hists, h))

tools/perf/util/intel-bts.c

414

u32 filter = btsq->bts->branches_filter;

tools/perf/util/intel-bts.c

438

if (filter && !(filter & btsq->sample_flags))

tools/perf/util/intel-pt.c

152

char *filter;

tools/perf/util/intel-pt.c

3836

zfree(&pt->filter);

tools/perf/util/intel-pt.c

4500

const char *filter = (const char *)info;

tools/perf/util/intel-pt.c

4509

pt->filter = memdup(filter, len);

tools/perf/util/intel-pt.c

4510

if (!pt->filter) {

tools/perf/util/intel-pt.c

4515

mem_bswap_64(pt->filter, len);

tools/perf/util/intel-pt.c

4516

if (pt->filter[len - 1]) {

tools/perf/util/intel-pt.c

4522

filter);

tools/perf/util/intel-pt.c

4526

intel_pt_print_info_str("Filter string", pt->filter);

tools/perf/util/intel-pt.c

4721

zfree(&pt->filter);

tools/perf/util/lock-contention.c

113

struct callstack_filter *filter;

tools/perf/util/lock-contention.c

137

list_for_each_entry(filter, &callstack_filters, list) {

tools/perf/util/lock-contention.c

138

if (strstr(sym->name, filter->name))

tools/perf/util/probe-event.c

1312

struct strfilter *filter __maybe_unused)

tools/perf/util/probe-event.c

2694

struct strfilter *filter)

tools/perf/util/probe-event.c

2699

if (strfilter__compare(filter, tev->event))

tools/perf/util/probe-event.c

2705

return strfilter__compare(filter, tmp);

tools/perf/util/probe-event.c

2709

struct strfilter *filter)

tools/perf/util/probe-event.c

2727

if (!filter_probe_trace_event(&tev, filter))

tools/perf/util/probe-event.c

2751

int show_perf_probe_events(struct strfilter *filter)

tools/perf/util/probe-event.c

2758

return probe_cache__show_all_caches(filter);

tools/perf/util/probe-event.c

2769

ret = __show_perf_probe_events(kp_fd, true, filter);

tools/perf/util/probe-event.c

2771

ret = __show_perf_probe_events(up_fd, false, filter);

tools/perf/util/probe-event.h

174

int show_perf_probe_events(struct strfilter *filter);

tools/perf/util/probe-event.h

178

struct strfilter *filter);

tools/perf/util/probe-event.h

180

struct strfilter *filter, bool user);

tools/perf/util/probe-file.c

1015

struct strfilter *filter)

tools/perf/util/probe-file.c

1023

return strfilter__compare(filter, ptr);

tools/perf/util/probe-file.c

1027

struct strfilter *filter)

tools/perf/util/probe-file.c

1032

if (probe_cache_entry__compare(entry, filter)) {

tools/perf/util/probe-file.c

1042

struct strfilter *filter)

tools/perf/util/probe-file.c

1047

if (probe_cache_entry__compare(entry, filter))

tools/perf/util/probe-file.c

1054

int probe_cache__show_all_caches(struct strfilter *filter)

tools/perf/util/probe-file.c

1059

char *buf = strfilter__string(filter);

tools/perf/util/probe-file.c

1077

probe_cache__show_entries(pcache, filter);

tools/perf/util/probe-file.c

324

int probe_file__get_events(int fd, struct strfilter *filter,

tools/perf/util/probe-file.c

341

if ((p && strfilter__compare(filter, p + 1)) ||

tools/perf/util/probe-file.c

342

strfilter__compare(filter, ent->s)) {

tools/perf/util/probe-file.h

47

int probe_file__get_events(int fd, struct strfilter *filter,

tools/perf/util/probe-file.h

63

struct strfilter *filter);

tools/perf/util/probe-file.h

68

int probe_cache__show_all_caches(struct strfilter *filter);

tools/perf/util/strfilter.c

162

struct strfilter *filter = zalloc(sizeof(*filter));

tools/perf/util/strfilter.c

165

if (filter)

tools/perf/util/strfilter.c

166

filter->root = strfilter_node__new(rules, &ep);

tools/perf/util/strfilter.c

168

if (!filter || !filter->root || *ep != '\0') {

tools/perf/util/strfilter.c

171

strfilter__delete(filter);

tools/perf/util/strfilter.c

172

filter = NULL;

tools/perf/util/strfilter.c

175

return filter;

tools/perf/util/strfilter.c

178

static int strfilter__append(struct strfilter *filter, bool _or,

tools/perf/util/strfilter.c

184

if (!filter || !rules)

tools/perf/util/strfilter.c

193

root = strfilter_node__alloc(_or ? OP_or : OP_and, filter->root, right);

tools/perf/util/strfilter.c

199

filter->root = root;

tools/perf/util/strfilter.c

207

int strfilter__or(struct strfilter *filter, const char *rules, const char **err)

tools/perf/util/strfilter.c

209

return strfilter__append(filter, true, rules, err);

tools/perf/util/strfilter.c

212

int strfilter__and(struct strfilter *filter, const char *rules,

tools/perf/util/strfilter.c

215

return strfilter__append(filter, false, rules, err);

tools/perf/util/strfilter.c

239

bool strfilter__compare(struct strfilter *filter, const char *str)

tools/perf/util/strfilter.c

241

if (!filter)

tools/perf/util/strfilter.c

243

return strfilter_node__compare(filter->root, str);

tools/perf/util/strfilter.c

298

char *strfilter__string(struct strfilter *filter)

tools/perf/util/strfilter.c

30

void strfilter__delete(struct strfilter *filter)

tools/perf/util/strfilter.c

303

len = strfilter_node__sprint(filter->root, NULL);

tools/perf/util/strfilter.c

309

strfilter_node__sprint(filter->root, ret);

tools/perf/util/strfilter.c

32

if (filter) {

tools/perf/util/strfilter.c

33

strfilter_node__delete(filter->root);

tools/perf/util/strfilter.c

34

free(filter);

tools/perf/util/strfilter.h

42

int strfilter__or(struct strfilter *filter,

tools/perf/util/strfilter.h

55

int strfilter__and(struct strfilter *filter,

tools/perf/util/strfilter.h

65

bool strfilter__compare(struct strfilter *filter, const char *str);

tools/perf/util/strfilter.h

73

void strfilter__delete(struct strfilter *filter);

tools/perf/util/strfilter.h

82

char *strfilter__string(struct strfilter *filter);

tools/perf/util/thread.h

296

return RC_CHK_ACCESS(thread)->filter;

tools/perf/util/thread.h

299

static inline void thread__set_filter(struct thread *thread, bool filter)

tools/perf/util/thread.h

301

RC_CHK_ACCESS(thread)->filter = filter;

tools/perf/util/thread.h

61

bool filter;

tools/perf/util/thread_map.c

102

items = scandir(path, &namelist, filter, NULL);

tools/perf/util/thread_map.c

183

items = scandir(name, &namelist, filter, NULL);

tools/perf/util/thread_map.c

43

items = scandir(name, &namelist, filter, NULL);

tools/perf/util/util.c

335

bool (*filter)(const char *, struct dirent *))

tools/perf/util/util.c

352

if (!filter || filter(name, d))

tools/perf/util/util.c

535

int (*filter)(const struct dirent *),

tools/perf/util/util.c

545

err = scandir(path, namelist, filter, compar);

tools/perf/util/util.h

41

struct strlist *lsdir(const char *name, bool (*filter)(const char *, struct dirent *));

tools/perf/util/util.h

63

int (*filter)(const struct dirent *),

tools/testing/selftests/bpf/prog_tests/lwt_helpers.h

102

if (filter && filter(buf, ret) > 0)

tools/testing/selftests/bpf/prog_tests/lwt_helpers.h

70

static int wait_for_packet(int fd, filter_t filter, struct timeval *timeout)

tools/testing/selftests/bpf/prog_tests/lwt_redirect.c

169

filter_t filter = need_mac ? expect_icmp : expect_icmp_nomac;

tools/testing/selftests/bpf/prog_tests/lwt_redirect.c

173

ret = wait_for_packet(tap_fd, filter, &timeo);

tools/testing/selftests/bpf/prog_tests/lwt_redirect.c

182

ret = wait_for_packet(psock, filter, &timeo);

tools/testing/selftests/bpf/test_progs.c

289

static bool match_subtest(struct test_filter_set *filter,

tools/testing/selftests/bpf/test_progs.c

295

for (i = 0; i < filter->cnt; i++) {

tools/testing/selftests/bpf/test_progs.c

296

if (glob_match(test_name, filter->tests[i].name)) {

tools/testing/selftests/bpf/test_progs.c

297

if (!filter->tests[i].subtest_cnt)

tools/testing/selftests/bpf/test_progs.c

300

for (j = 0; j < filter->tests[i].subtest_cnt; j++) {

tools/testing/selftests/bpf/test_progs.c

302

filter->tests[i].subtests[j]))

tools/testing/selftests/bpf/veristat.c

221

struct filter *allow_filters;

tools/testing/selftests/bpf/veristat.c

222

struct filter *deny_filters;

tools/testing/selftests/bpf/veristat.c

2963

static bool is_join_stat_filter_matched(struct filter *f, const struct verif_stats_join *stats)

tools/testing/selftests/bpf/veristat.c

2989

struct filter *f;

tools/testing/selftests/bpf/veristat.c

311

static int append_filter(struct filter **filters, int *cnt, const char *str);

tools/testing/selftests/bpf/veristat.c

3176

static bool is_stat_filter_matched(struct filter *f, const struct verif_stats *stats)

tools/testing/selftests/bpf/veristat.c

3198

struct filter *f;

tools/testing/selftests/bpf/veristat.c

518

struct filter *f;

tools/testing/selftests/bpf/veristat.c

589

static int append_filter(struct filter **filters, int *cnt, const char *str)

tools/testing/selftests/bpf/veristat.c

591

struct filter *f;

tools/testing/selftests/clone3/clone3.c

170

filter_function filter;

tools/testing/selftests/clone3/clone3.c

187

.filter = not_root,

tools/testing/selftests/clone3/clone3.c

272

.filter = not_root,

tools/testing/selftests/clone3/clone3.c

287

.filter = not_root,

tools/testing/selftests/clone3/clone3.c

302

.filter = no_timenamespace,

tools/testing/selftests/clone3/clone3.c

323

if (tests[i].filter && tests[i].filter()) {

tools/testing/selftests/connector/proc_filter.c

256

filter = 1;

tools/testing/selftests/connector/proc_filter.c

263

if (filter) {

tools/testing/selftests/connector/proc_filter.c

297

if (filter) {

tools/testing/selftests/connector/proc_filter.c

32

static int filter;

tools/testing/selftests/connector/proc_filter.c

47

if (filter)

tools/testing/selftests/connector/proc_filter.c

63

if (filter) {

tools/testing/selftests/drivers/net/gro.c

178

struct sock_filter filter[] = {

tools/testing/selftests/drivers/net/gro.c

194

.len = ARRAY_SIZE(filter),

tools/testing/selftests/drivers/net/gro.c

195

.filter = filter,

tools/testing/selftests/drivers/net/hw/toeplitz.c

319

struct sock_filter filter[] = {

tools/testing/selftests/drivers/net/hw/toeplitz.c

331

prog.filter = filter;

tools/testing/selftests/drivers/net/hw/toeplitz.c

332

prog.len = ARRAY_SIZE(filter);

tools/testing/selftests/drivers/net/hw/toeplitz.c

355

struct sock_filter filter[] = {

tools/testing/selftests/drivers/net/hw/toeplitz.c

360

prog.filter = filter;

tools/testing/selftests/drivers/net/hw/toeplitz.c

361

prog.len = ARRAY_SIZE(filter);

tools/testing/selftests/kvm/arm64/smccc_filter.c

105

KVM_ARM_VM_SMCCC_FILTER, &filter);

tools/testing/selftests/kvm/arm64/smccc_filter.c

55

struct kvm_smccc_filter filter = {

tools/testing/selftests/kvm/arm64/smccc_filter.c

62

KVM_ARM_VM_SMCCC_FILTER, &filter);

tools/testing/selftests/kvm/arm64/smccc_filter.c

96

struct kvm_smccc_filter filter = {

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

728

struct kvm_msr_filter filter = {

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

746

nflags = sizeof(filter.flags) * BITS_PER_BYTE;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

748

filter.flags = BIT_ULL(i);

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

749

test_user_exit_msr_ioctl(vm, KVM_X86_SET_MSR_FILTER, &filter,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

753

filter.flags = KVM_MSR_FILTER_DEFAULT_ALLOW;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

754

nflags = sizeof(filter.ranges[0].flags) * BITS_PER_BYTE;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

756

filter.ranges[0].flags = BIT_ULL(i);

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

757

test_user_exit_msr_ioctl(vm, KVM_X86_SET_MSR_FILTER, &filter,

tools/testing/selftests/landlock/audit.h

142

const struct audit_filter *const filter,

tools/testing/selftests/landlock/audit.h

148

NLMSG_ALIGN(filter->exe_len),

tools/testing/selftests/landlock/audit.h

156

.fields[0] = filter->record_type,

tools/testing/selftests/landlock/audit.h

158

.values[0] = filter->exe_len,

tools/testing/selftests/landlock/audit.h

159

.buflen = filter->exe_len,

tools/testing/selftests/landlock/audit.h

163

if (filter->record_type != AUDIT_EXE)

tools/testing/selftests/landlock/audit.h

166

memcpy(msg.rule.buf, filter->exe, filter->exe_len);

tools/testing/selftests/landlock/audit.h

397

static int audit_init_filter_exe(struct audit_filter *filter, const char *path)

tools/testing/selftests/landlock/audit.h

402

filter->record_type = AUDIT_EXE;

tools/testing/selftests/landlock/audit.h

404

int ret = readlink("/proc/self/exe", filter->exe,

tools/testing/selftests/landlock/audit.h

405

sizeof(filter->exe) - 1);

tools/testing/selftests/landlock/audit.h

409

filter->exe_len = ret;

tools/testing/selftests/landlock/audit.h

418

filter->exe_len = strlen(absolute_path);

tools/testing/selftests/landlock/audit.h

419

if (filter->exe_len > sizeof(filter->exe))

tools/testing/selftests/landlock/audit.h

422

memcpy(filter->exe, absolute_path, filter->exe_len);

tools/testing/selftests/landlock/audit.h

427

static int audit_cleanup(int audit_fd, struct audit_filter *filter)

tools/testing/selftests/landlock/audit.h

431

if (audit_fd < 0 || !filter) {

tools/testing/selftests/landlock/audit.h

442

filter = &new_filter;

tools/testing/selftests/landlock/audit.h

443

err = audit_init_filter_exe(filter, NULL);

tools/testing/selftests/landlock/audit.h

449

audit_filter_exe(audit_fd, filter, AUDIT_DEL_RULE);

tools/testing/selftests/landlock/audit.h

461

static int audit_init_with_exe_filter(struct audit_filter *filter)

tools/testing/selftests/landlock/audit.h

469

err = audit_init_filter_exe(filter, NULL);

tools/testing/selftests/landlock/audit.h

473

err = audit_filter_exe(fd, filter, AUDIT_ADD_RULE);

tools/testing/selftests/net/ipsec.c

1027

struct xfrm_address_filter filter = {};

tools/testing/selftests/net/ipsec.c

1041

filter.family = AF_INET;

tools/testing/selftests/net/ipsec.c

1042

filter.splen = 0x1f; /* 0xffffffff mask see addr_match() */

tools/testing/selftests/net/ipsec.c

1043

memcpy(&filter.saddr, &src, sizeof(src));

tools/testing/selftests/net/ipsec.c

1045

&filter, sizeof(filter)))

tools/testing/selftests/net/lib/csum.c

497

struct sock_filter filter[] = {

tools/testing/selftests/net/lib/csum.c

509

prog.filter = filter;

tools/testing/selftests/net/lib/csum.c

510

prog.len = ARRAY_SIZE(filter);

tools/testing/selftests/net/psock_fanout.c

148

bpf_prog.filter = bpf_filter;

tools/testing/selftests/net/psock_lib.h

63

bpf_prog.filter = bpf_filter;

tools/testing/selftests/net/reuseport_bpf.c

143

.filter = code,

tools/testing/selftests/net/reuseport_bpf.c

362

cprog.filter = ccode;

tools/testing/selftests/net/reuseport_bpf_cpu.c

87

.filter = code,

tools/testing/selftests/net/skf_net_off.c

94

struct sock_fprog filter = {

tools/testing/selftests/net/skf_net_off.c

99

if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter)))

tools/testing/selftests/net/tcp_ao/lib/aolib.h

738

const char *event, const char *filter);

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

503

char *filter;

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

507

filter = test_sprintf("net_cookie == %zu || net_cookie == %zu",

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

509

if (!filter)

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

519

ret = setup_trace_event(tracer, event_name, filter);

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

525

free(filter);

tools/testing/selftests/net/tcp_ao/lib/ftrace.c

307

const char *event, const char *filter)

tools/testing/selftests/net/tcp_ao/lib/ftrace.c

322

ret = test_echo(filter_path, 0, "%s", filter);

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

887

static void filter_keys_checked(int sk, struct tcp_ao_getsockopt *filter,

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

896

memcpy(&filtered_keys[0], filter, sizeof(struct tcp_ao_getsockopt));

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

914

memset(filter, 0, sizeof(struct tcp_ao_getsockopt));

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

921

struct tcp_ao_getsockopt filter = {};

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

927

filter.rcvid = original_keys[f].rcvid;

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

928

filter.sndid = original_keys[f].sndid;

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

929

memcpy(&filter.addr, &original_keys[f].addr,

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

931

filter.prefix = original_keys[f].prefix;

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

932

filter_keys_checked(sk, &filter, &original_keys[f], 1,

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

945

filter.is_current = 1;

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

946

filter_keys_checked(sk, &filter, &original_keys[f], 1, "by is_current");

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

958

filter.is_rnext = 1;

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

959

filter_keys_checked(sk, &filter, &original_keys[f], 1, "by is_rnext");

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

976

filter.rcvid = original_keys[f].rcvid;

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

977

filter.sndid = original_keys[f].sndid;

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

978

filter.addr.ss_family = test_family;

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

979

filter_keys_checked(sk, &filter, expected_keys, nmatches,

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

983

filter.get_all = 1;

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

984

filter.nkeys = FILTER_TEST_NKEYS / 2;

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

986

if (getsockopt(sk, IPPROTO_TCP, TCP_AO_GET_KEYS, &filter, &len))

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

988

if (filter.nkeys == FILTER_TEST_NKEYS)

tools/testing/selftests/net/tcp_ao/setsockopt-closed.c

992

FILTER_TEST_NKEYS, filter.nkeys);

tools/testing/selftests/sched_ext/runner.c

135

const char *filter = NULL;

tools/testing/selftests/sched_ext/runner.c

157

filter = optarg;

tools/testing/selftests/sched_ext/runner.c

179

if (filter && should_skip_test(test, filter)) {

tools/testing/selftests/sched_ext/runner.c

83

static bool should_skip_test(const struct scx_test *test, const char * filter)

tools/testing/selftests/sched_ext/runner.c

85

return !strstr(test->name, filter);

tools/testing/selftests/seccomp/seccomp_benchmark.c

174

.filter = bitmap_filter,

tools/testing/selftests/seccomp/seccomp_benchmark.c

176

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_benchmark.c

181

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_benchmark.c

182

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

1074

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

1083

self->prog.filter = malloc(sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1084

ASSERT_NE(NULL, self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1085

memcpy(self->prog.filter, filter, sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1086

self->prog.len = (unsigned short)ARRAY_SIZE(filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1091

if (self->prog.filter)

tools/testing/selftests/seccomp/seccomp_bpf.c

1092

free(self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1231

self->_x.filter = malloc(sizeof(_x##_insns)); \

tools/testing/selftests/seccomp/seccomp_bpf.c

1232

ASSERT_NE(NULL, self->_x.filter); \

tools/testing/selftests/seccomp/seccomp_bpf.c

1233

memcpy(self->_x.filter, &_x##_insns, sizeof(_x##_insns)); \

tools/testing/selftests/seccomp/seccomp_bpf.c

1245

#define FILTER_FREE(_x) if (self->_x.filter) free(self->_x.filter)

tools/testing/selftests/seccomp/seccomp_bpf.c

1682

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

1692

self->prog.filter = malloc(sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1693

ASSERT_NE(NULL, self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1694

memcpy(self->prog.filter, filter, sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1695

self->prog.len = (unsigned short)ARRAY_SIZE(filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1708

if (self->prog.filter)

tools/testing/selftests/seccomp/seccomp_bpf.c

1709

free(self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

2145

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2159

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

2160

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

2252

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2260

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

2261

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

2275

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2283

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

2284

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

2300

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2308

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

2309

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

2323

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2327

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

2328

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

2375

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2379

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

2380

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

2502

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2506

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

2507

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

2581

self->root_prog.filter = malloc(sizeof(root_filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

2582

ASSERT_NE(NULL, self->root_prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

2583

memcpy(self->root_prog.filter, &root_filter, sizeof(root_filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

2586

self->apply_prog.filter = malloc(sizeof(apply_filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

2587

ASSERT_NE(NULL, self->apply_prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

2588

memcpy(self->apply_prog.filter, &apply_filter, sizeof(apply_filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

2617

if (self->root_prog.filter)

tools/testing/selftests/seccomp/seccomp_bpf.c

2618

free(self->root_prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

2619

if (self->apply_prog.filter)

tools/testing/selftests/seccomp/seccomp_bpf.c

2620

free(self->apply_prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

2679

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2687

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

2688

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

3028

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3052

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

3053

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

3212

.filter = allow_filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

3216

.filter = kill_filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

3310

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3314

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

3315

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

3362

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3371

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

3372

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

3388

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3392

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

3393

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

413

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

417

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

418

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

449

struct sock_filter *filter;

tools/testing/selftests/seccomp/seccomp_bpf.c

453

filter = calloc(count, sizeof(*filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

454

ASSERT_NE(NULL, filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

457

filter[i] = allow[0];

tools/testing/selftests/seccomp/seccomp_bpf.c

462

prog.filter = filter;

tools/testing/selftests/seccomp/seccomp_bpf.c

486

struct sock_filter *filter;

tools/testing/selftests/seccomp/seccomp_bpf.c

490

filter = calloc(count, sizeof(*filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

491

ASSERT_NE(NULL, filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

494

filter[i] = allow[0];

tools/testing/selftests/seccomp/seccomp_bpf.c

4972

.filter = allow_filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

499

prog.filter = filter;

tools/testing/selftests/seccomp/seccomp_bpf.c

5014

.filter = allow_filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

521

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5216

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5220

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

5221

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

5229

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5237

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

5238

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

5246

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

525

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

5259

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

526

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

5260

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

5268

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5282

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

5283

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

544

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

548

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

549

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

569

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

573

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

574

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

587

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

590

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

591

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

605

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

609

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

610

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

627

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

631

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

632

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

649

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

653

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

654

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

670

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

674

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

675

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

688

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

696

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

697

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

716

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

729

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

730

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

756

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

768

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

769

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

838

.filter = filter_thread,

tools/testing/selftests/seccomp/seccomp_bpf.c

850

.filter = filter_process,

tools/testing/selftests/seccomp/seccomp_bpf.c

948

struct sock_filter filter[] = {

tools/testing/selftests/seccomp/seccomp_bpf.c

953

.len = (unsigned short)ARRAY_SIZE(filter),

tools/testing/selftests/seccomp/seccomp_bpf.c

954

.filter = filter,

tools/testing/selftests/seccomp/seccomp_bpf.c

976

.filter = _read_filter_##name, \

tools/testing/selftests/vfio/lib/drivers/dsa/registers.h

475

u64 filter:8;

tools/tracing/rtla/src/trace.c

261

if (free_event->filter)

tools/tracing/rtla/src/trace.c

262

free(free_event->filter);

tools/tracing/rtla/src/trace.c

299

int trace_event_add_filter(struct trace_events *event, char *filter)

tools/tracing/rtla/src/trace.c

301

if (event->filter)

tools/tracing/rtla/src/trace.c

302

free(event->filter);

tools/tracing/rtla/src/trace.c

304

event->filter = strdup(filter);

tools/tracing/rtla/src/trace.c

305

if (!event->filter)

tools/tracing/rtla/src/trace.c

332

char filter[1024];

tools/tracing/rtla/src/trace.c

335

if (!tevent->filter)

tools/tracing/rtla/src/trace.c

342

tevent->event ? : "*", tevent->filter);

tools/tracing/rtla/src/trace.c

344

snprintf(filter, 1024, "!%s\n", tevent->filter);

tools/tracing/rtla/src/trace.c

347

tevent->event, "filter", filter);

tools/tracing/rtla/src/trace.c

350

tevent->event ? : "*", tevent->filter);

tools/tracing/rtla/src/trace.c

463

char filter[1024];

tools/tracing/rtla/src/trace.c

466

if (!tevent->filter)

tools/tracing/rtla/src/trace.c

471

tevent->filter, tevent->system);

tools/tracing/rtla/src/trace.c

475

snprintf(filter, 1024, "%s\n", tevent->filter);

tools/tracing/rtla/src/trace.c

478

tevent->event ? : "*", tevent->filter);

tools/tracing/rtla/src/trace.c

481

tevent->event, "filter", filter);

tools/tracing/rtla/src/trace.c

484

tevent->event ? : "*", tevent->filter);

tools/tracing/rtla/src/trace.h

48

int trace_event_add_filter(struct trace_events *event, char *filter);

tools/tracing/rtla/src/trace.h

9

char *filter;