arch/x86/events/intel/pt.c

1385

struct pt_filters *filters;

arch/x86/events/intel/pt.c

1391

filters = kzalloc_node(sizeof(struct pt_filters), GFP_KERNEL, node);

arch/x86/events/intel/pt.c

1392

if (!filters)

arch/x86/events/intel/pt.c

1396

memcpy(filters, event->parent->hw.addr_filters,

arch/x86/events/intel/pt.c

1397

sizeof(*filters));

arch/x86/events/intel/pt.c

1399

event->hw.addr_filters = filters;

arch/x86/events/intel/pt.c

1431

static int pt_event_addr_filters_validate(struct list_head *filters)

arch/x86/events/intel/pt.c

1436

list_for_each_entry(filter, filters, entry) {

arch/x86/events/intel/pt.c

1457

struct pt_filters *filters = event->hw.addr_filters;

arch/x86/events/intel/pt.c

1461

if (!filters)

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

1493

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

arch/x86/events/intel/pt.c

1495

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

arch/x86/events/intel/pt.c

1499

filters->nr_filters = range;

arch/x86/events/intel/pt.c

466

struct pt_filters *filters = event->hw.addr_filters;

arch/x86/events/intel/pt.c

471

if (!filters)

arch/x86/events/intel/pt.c

476

for (range = 0; range < filters->nr_filters; range++) {

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

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

496

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

arch/x86/events/intel/pt.h

126

struct pt_filters filters;

drivers/gpio/gpio-idio-16.c

151

if (config->filters) {

drivers/gpio/gpio-idio-16.h

27

bool filters;

drivers/gpio/gpio-pci-idio-16.c

95

config.filters = true;

drivers/gpu/drm/nouveau/dispnv04/tvmodesnv17.c

319

uint32_t (*filters[])[4][7] = {&tv_enc->state.hfilter,

drivers/gpu/drm/nouveau/dispnv04/tvmodesnv17.c

346

(*filters[k])[j][i] = (c + id5/2) >> 39

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

158

struct etm_filters *filters;

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

161

filters = kzalloc_node(sizeof(struct etm_filters), GFP_KERNEL, node);

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

162

if (!filters)

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

166

memcpy(filters, event->parent->hw.addr_filters,

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

167

sizeof(*filters));

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

169

event->hw.addr_filters = filters;

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

749

static int etm_addr_filters_validate(struct list_head *filters)

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

755

list_for_each_entry(filter, filters, entry) {

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

793

struct etm_filters *filters = event->hw.addr_filters;

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

801

etm_filter = &filters->etm_filter[i];

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

821

filters->nr_filters = i;

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

1080

struct etm_filters *filters = event->hw.addr_filters;

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

1100

filters->ssstatus = (control & BIT(9));

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

1730

struct etm_filters *filters = event->hw.addr_filters;

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

1732

if (!filters)

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

1742

if (!filters->nr_filters)

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

1745

for (i = 0; i < filters->nr_filters; i++) {

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

1746

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

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

1793

if (filters->ssstatus)

drivers/media/dvb-frontends/rtl2830.c

616

set_bit(index, &dev->filters);

drivers/media/dvb-frontends/rtl2830.c

618

clear_bit(index, &dev->filters);

drivers/media/dvb-frontends/rtl2830.c

621

buf[0] = (dev->filters >> 0) & 0xff;

drivers/media/dvb-frontends/rtl2830.c

622

buf[1] = (dev->filters >> 8) & 0xff;

drivers/media/dvb-frontends/rtl2830.c

623

buf[2] = (dev->filters >> 16) & 0xff;

drivers/media/dvb-frontends/rtl2830.c

624

buf[3] = (dev->filters >> 24) & 0xff;

drivers/media/dvb-frontends/rtl2830_priv.h

26

unsigned long filters;

drivers/media/dvb-frontends/rtl2832.c

990

set_bit(index, &dev->filters);

drivers/media/dvb-frontends/rtl2832.c

992

clear_bit(index, &dev->filters);

drivers/media/dvb-frontends/rtl2832.c

995

buf[0] = (dev->filters >> 0) & 0xff;

drivers/media/dvb-frontends/rtl2832.c

996

buf[1] = (dev->filters >> 8) & 0xff;

drivers/media/dvb-frontends/rtl2832.c

997

buf[2] = (dev->filters >> 16) & 0xff;

drivers/media/dvb-frontends/rtl2832.c

998

buf[3] = (dev->filters >> 24) & 0xff;

drivers/media/dvb-frontends/rtl2832_priv.h

33

unsigned long filters; /* PID filter */

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

381

ft = img_ir_free_timing_dynamic(regs->ft, &hw->filters[type]);

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

448

hw->filters[RC_FILTER_WAKEUP] = *filter;

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

738

img_ir_write_filter(priv, &hw->filters[RC_FILTER_WAKEUP]);

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

768

&hw->filters[RC_FILTER_NORMAL]);

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

243

struct img_ir_filter filters[RC_FILTER_MAX];

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

354

if (m->filters[adap->id][i] == 8192)

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

368

if (m->filters[adap->id][i] == 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

394

m->filters[adap->id][index] = onoff ? pid : 0;

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

65

u16 filters[M9206_MAX_ADAPTERS][M9206_MAX_FILTERS];

drivers/net/ethernet/broadcom/bcmsysport.c

1066

for_each_set_bit(index, priv->filters, RXCHK_BRCM_TAG_MAX) {

drivers/net/ethernet/broadcom/bcmsysport.c

2125

for_each_set_bit(index, priv->filters, RXCHK_BRCM_TAG_MAX) {

drivers/net/ethernet/broadcom/bcmsysport.c

2167

index = find_first_zero_bit(priv->filters, RXCHK_BRCM_TAG_MAX);

drivers/net/ethernet/broadcom/bcmsysport.c

2182

set_bit(index, priv->filters);

drivers/net/ethernet/broadcom/bcmsysport.c

2200

clear_bit(index, priv->filters);

drivers/net/ethernet/broadcom/bcmsysport.c

2678

for_each_set_bit(index, priv->filters, RXCHK_BRCM_TAG_MAX) {

drivers/net/ethernet/broadcom/bcmsysport.h

762

DECLARE_BITMAP(filters, RXCHK_BRCM_TAG_MAX);

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

435

struct bnx2x_vf_mac_vlan_filters *filters,

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

446

for (i = 0; i < filters->count; i++) {

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

448

&filters->filters[i], drv_only);

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

454

if (i != filters->count) {

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

456

i, filters->count);

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

458

if (!filters->filters[i].applied)

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

460

filters->filters[i].add = !filters->filters[i].add;

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

462

&filters->filters[i],

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

468

kfree(filters);

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

124

struct bnx2x_vf_mac_vlan_filter filters[];

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

452

struct bnx2x_vf_mac_vlan_filters *filters,

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

1657

fl = kzalloc_flex(*fl, filters, tlv->n_mac_vlan_filters);

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

1662

struct vfpf_q_mac_vlan_filter *msg_filter = &tlv->filters[i];

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

1666

memset(&fl->filters[j], 0, sizeof(fl->filters[j]));

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

1668

fl->filters[j].mac = msg_filter->mac;

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

1669

fl->filters[j].type |= BNX2X_VF_FILTER_MAC;

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

1672

fl->filters[j].vid = msg_filter->vlan_tag;

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

1673

fl->filters[j].type |= BNX2X_VF_FILTER_VLAN;

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

1675

fl->filters[j].add = !!(msg_filter->flags & VFPF_Q_FILTER_SET);

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

1687

static int bnx2x_vf_filters_contain(struct vfpf_set_q_filters_tlv *filters,

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

1692

for (i = 0; i < filters->n_mac_vlan_filters; i++)

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

1693

if ((filters->filters[i].flags & flags) == flags)

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

1711

struct vfpf_set_q_filters_tlv *filters)

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

1715

if (filters->flags & VFPF_SET_Q_FILTERS_MAC_VLAN_CHANGED)

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

1716

for (i = 0; i < filters->n_mac_vlan_filters; i++)

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

1718

&filters->filters[i]);

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

1720

if (filters->flags & VFPF_SET_Q_FILTERS_RX_MASK_CHANGED)

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

1721

DP(msglvl, "RX-MASK=0x%x\n", filters->rx_mask);

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

1723

if (filters->flags & VFPF_SET_Q_FILTERS_MULTICAST_CHANGED)

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

1724

for (i = 0; i < filters->n_multicast; i++)

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

1725

DP(msglvl, "MULTICAST=%pM\n", filters->multicast[i]);

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

1840

struct vfpf_set_q_filters_tlv *filters)

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

1854

for (i = 0; i < filters->n_mac_vlan_filters; i++) {

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

1855

if (!(filters->filters[i].flags &

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

1865

filters->n_mac_vlan_filters);

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

1870

filter = &filters->filters[i];

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

1890

struct vfpf_set_q_filters_tlv *filters)

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

1899

if (bnx2x_vf_filters_contain(filters,

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

1909

if (filters->vf_qid > vf_rxq_count(vf)) {

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

1922

struct vfpf_set_q_filters_tlv *filters = &mbx->msg->req.set_q_filters;

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

1925

rc = bnx2x_filters_validate_mac(bp, vf, filters);

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

1929

rc = bnx2x_filters_validate_vlan(bp, vf, filters);

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

1935

filters->vf_qid);

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

1938

bnx2x_vf_mbx_dp_q_filters(bp, BNX2X_MSG_IOV, filters);

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

742

req->filters[0].flags = VFPF_Q_FILTER_DEST_MAC_VALID;

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

744

req->filters[0].flags |= VFPF_Q_FILTER_SET;

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

750

memcpy(req->filters[0].mac, addr, ETH_ALEN);

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

777

memcpy(req->filters[0].mac, bp->dev->dev_addr,

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

951

req->filters[0].flags = VFPF_Q_FILTER_VLAN_TAG_VALID;

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

954

req->filters[0].flags |= VFPF_Q_FILTER_SET;

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

965

req->filters[0].vlan_tag = vid;

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

325

struct vfpf_q_mac_vlan_filter filters[PFVF_MAX_FILTERS];

drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h

1075

struct i40e_filter_data filters[8];

drivers/net/ethernet/intel/i40e/i40e_common.c

5086

struct i40e_aqc_cloud_filters_element_data *filters,

drivers/net/ethernet/intel/i40e/i40e_common.c

5098

buff_len = filter_count * sizeof(*filters);

drivers/net/ethernet/intel/i40e/i40e_common.c

5104

status = i40e_asq_send_command(hw, &desc, filters, buff_len, NULL);

drivers/net/ethernet/intel/i40e/i40e_common.c

5123

struct i40e_aqc_cloud_filters_element_bb *filters,

drivers/net/ethernet/intel/i40e/i40e_common.c

5136

buff_len = filter_count * sizeof(*filters);

drivers/net/ethernet/intel/i40e/i40e_common.c

5147

tnl_type = le16_get_bits(filters[i].element.flags,

drivers/net/ethernet/intel/i40e/i40e_common.c

5155

ti = le32_to_cpu(filters[i].element.tenant_id);

drivers/net/ethernet/intel/i40e/i40e_common.c

5156

filters[i].element.tenant_id = cpu_to_le32(ti << 8);

drivers/net/ethernet/intel/i40e/i40e_common.c

5160

status = i40e_asq_send_command(hw, &desc, filters, buff_len, NULL);

drivers/net/ethernet/intel/i40e/i40e_common.c

5179

struct i40e_aqc_cloud_filters_element_data *filters,

drivers/net/ethernet/intel/i40e/i40e_common.c

5191

buff_len = filter_count * sizeof(*filters);

drivers/net/ethernet/intel/i40e/i40e_common.c

5197

status = i40e_asq_send_command(hw, &desc, filters, buff_len, NULL);

drivers/net/ethernet/intel/i40e/i40e_common.c

5216

struct i40e_aqc_cloud_filters_element_bb *filters,

drivers/net/ethernet/intel/i40e/i40e_common.c

5229

buff_len = filter_count * sizeof(*filters);

drivers/net/ethernet/intel/i40e/i40e_common.c

5240

tnl_type = le16_get_bits(filters[i].element.flags,

drivers/net/ethernet/intel/i40e/i40e_common.c

5248

ti = le32_to_cpu(filters[i].element.tenant_id);

drivers/net/ethernet/intel/i40e/i40e_common.c

5249

filters[i].element.tenant_id = cpu_to_le32(ti << 8);

drivers/net/ethernet/intel/i40e/i40e_common.c

5253

status = i40e_asq_send_command(hw, &desc, filters, buff_len, NULL);

drivers/net/ethernet/intel/i40e/i40e_prototype.h

284

struct i40e_aqc_cloud_filters_element_bb *filters,

drivers/net/ethernet/intel/i40e/i40e_prototype.h

288

struct i40e_aqc_cloud_filters_element_data *filters,

drivers/net/ethernet/intel/i40e/i40e_prototype.h

292

struct i40e_aqc_cloud_filters_element_data *filters,

drivers/net/ethernet/intel/i40e/i40e_prototype.h

296

struct i40e_aqc_cloud_filters_element_bb *filters,

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

1018

vlan = &vvfl_v2->filters[i].outer;

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

1020

vlan = &vvfl_v2->filters[i].inner;

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

840

len = virtchnl_struct_size(vvfl_v2, filters, count);

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

845

len = virtchnl_struct_size(vvfl_v2, filters,

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

869

vlan = &vvfl_v2->filters[i].outer;

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

871

vlan = &vvfl_v2->filters[i].inner;

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

991

len = virtchnl_struct_size(vvfl_v2, filters, count);

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

996

len = virtchnl_struct_size(vvfl_v2, filters,

drivers/net/ethernet/intel/ice/virt/virtchnl.c

1748

struct virtchnl_vlan_filter *vlan_fltr = &vfl->filters[i];

drivers/net/ethernet/intel/ice/virt/virtchnl.c

1832

struct virtchnl_vlan_filter *vlan_fltr = &vfl->filters[i];

drivers/net/ethernet/intel/ice/virt/virtchnl.c

1938

struct virtchnl_vlan_filter *vlan_fltr = &vfl->filters[i];

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

316

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3194

INIT_LIST_HEAD(&priv->filters);

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

451

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

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

468

if (last_filter && (&last_filter->next != priv->filters.next))

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

469

list_move(&priv->filters, &last_filter->next);

drivers/net/ethernet/mellanox/mlx4/mlx4_en.h

629

struct list_head filters;

drivers/net/vmxnet3/vmxnet3_defs.h

714

struct Vmxnet3_PM_PktFilter filters[VMXNET3_PM_MAX_FILTERS];

drivers/net/vmxnet3/vmxnet3_drv.c

4440

pmConf->filters[i].patternSize = ETH_ALEN;

drivers/net/vmxnet3/vmxnet3_drv.c

4441

pmConf->filters[i].maskSize = 1;

drivers/net/vmxnet3/vmxnet3_drv.c

4442

memcpy(pmConf->filters[i].pattern, netdev->dev_addr, ETH_ALEN);

drivers/net/vmxnet3/vmxnet3_drv.c

4443

pmConf->filters[i].mask[0] = 0x3F; /* LSB ETH_ALEN bits */

drivers/net/vmxnet3/vmxnet3_drv.c

4464

pmConf->filters[i].patternSize = ETH_HLEN + /* Ethernet header*/

drivers/net/vmxnet3/vmxnet3_drv.c

4468

pmConf->filters[i].maskSize =

drivers/net/vmxnet3/vmxnet3_drv.c

4469

(pmConf->filters[i].patternSize - 1) / 8 + 1;

drivers/net/vmxnet3/vmxnet3_drv.c

4472

ehdr = (struct ethhdr *)pmConf->filters[i].pattern;

drivers/net/vmxnet3/vmxnet3_drv.c

4476

ahdr = (struct arphdr *)&pmConf->filters[i].pattern[ETH_HLEN];

drivers/net/vmxnet3/vmxnet3_drv.c

4487

pmConf->filters[i].mask[0] = 0x00;

drivers/net/vmxnet3/vmxnet3_drv.c

4488

pmConf->filters[i].mask[1] = 0x30; /* ETH_P_ARP */

drivers/net/vmxnet3/vmxnet3_drv.c

4489

pmConf->filters[i].mask[2] = 0x30; /* ARPOP_REQUEST */

drivers/net/vmxnet3/vmxnet3_drv.c

4490

pmConf->filters[i].mask[3] = 0x00;

drivers/net/vmxnet3/vmxnet3_drv.c

4491

pmConf->filters[i].mask[4] = 0xC0; /* IPv4 TIP */

drivers/net/vmxnet3/vmxnet3_drv.c

4492

pmConf->filters[i].mask[5] = 0x03; /* IPv4 TIP */

drivers/net/wireless/ath/ath5k/base.c

1499

unsigned int filters;

drivers/net/wireless/ath/ath5k/base.c

1549

filters = AR5K_RXERR_DECRYPT;

drivers/net/wireless/ath/ath5k/base.c

1551

filters |= AR5K_RXERR_CRC;

drivers/net/wireless/ath/ath5k/base.c

1553

if (rs->rs_status & ~filters)

drivers/net/wireless/intel/iwlwifi/fw/acpi.c

1011

BUILD_BUG_ON(ARRAY_SIZE(filters->filter_cfg_chains) !=

drivers/net/wireless/intel/iwlwifi/fw/acpi.c

1014

for (i = 0; i < ARRAY_SIZE(filters->filter_cfg_chains); i++) {

drivers/net/wireless/intel/iwlwifi/fw/acpi.c

1022

*filters = tmp;

drivers/net/wireless/intel/iwlwifi/fw/acpi.c

993

struct iwl_phy_specific_cfg *filters = &fwrt->phy_filters;

drivers/net/wireless/intel/iwlwifi/fw/uefi.c

860

struct iwl_phy_specific_cfg *filters = &fwrt->phy_filters;

drivers/net/wireless/intel/iwlwifi/fw/uefi.c

873

BUILD_BUG_ON(ARRAY_SIZE(filters->filter_cfg_chains) !=

drivers/net/wireless/intel/iwlwifi/fw/uefi.c

876

for (int i = 0; i < ARRAY_SIZE(filters->filter_cfg_chains); i++) {

drivers/net/wireless/intel/iwlwifi/fw/uefi.c

877

filters->filter_cfg_chains[i] = cpu_to_le32(data->chains[i]);

drivers/net/wireless/intel/iwlwifi/mei/internal.h

15

const struct iwl_sap_oob_filters *filters,

drivers/net/wireless/intel/iwlwifi/mei/main.c

134

struct iwl_sap_oob_filters filters;

drivers/net/wireless/intel/iwlwifi/mei/main.c

179

struct iwl_mei_filters __rcu *filters;

drivers/net/wireless/intel/iwlwifi/mei/main.c

2186

kfree(rcu_access_pointer(mei->filters));

drivers/net/wireless/intel/iwlwifi/mei/main.c

602

struct iwl_mei_filters *filters = rcu_dereference(mei->filters);

drivers/net/wireless/intel/iwlwifi/mei/main.c

616

if (filters)

drivers/net/wireless/intel/iwlwifi/mei/main.c

617

res = iwl_mei_rx_filter(skb, &filters->filters, &rx_for_csme);

drivers/net/wireless/intel/iwlwifi/mei/main.c

695

const struct iwl_sap_csme_filters *filters)

drivers/net/wireless/intel/iwlwifi/mei/main.c

702

rcu_dereference_protected(mei->filters,

drivers/net/wireless/intel/iwlwifi/mei/main.c

710

new_filters->filters = filters->filters;

drivers/net/wireless/intel/iwlwifi/mei/main.c

712

rcu_assign_pointer(mei->filters, new_filters);

drivers/net/wireless/intel/iwlwifi/mei/net.c

139

const struct iwl_sap_oob_filters *filters,

drivers/net/wireless/intel/iwlwifi/mei/net.c

144

for (filt = &filters->flex_filters[0];

drivers/net/wireless/intel/iwlwifi/mei/net.c

145

filt < &filters->flex_filters[0] + ARRAY_SIZE(filters->flex_filters);

drivers/net/wireless/intel/iwlwifi/mei/net.c

189

const struct iwl_sap_oob_filters *filters,

drivers/net/wireless/intel/iwlwifi/mei/net.c

192

const struct iwl_sap_ipv4_filter *filt = &filters->ipv4_filter;

drivers/net/wireless/intel/iwlwifi/mei/net.c

203

match = !filters->ipv4_filter.ipv4_addr ||

drivers/net/wireless/intel/iwlwifi/mei/net.c

204

filters->ipv4_filter.ipv4_addr == iphdr->daddr;

drivers/net/wireless/intel/iwlwifi/mei/net.c

221

filters, rx_handler_res);

drivers/net/wireless/intel/iwlwifi/mei/net.c

248

if ((filters->icmpv6_flags & cpu_to_le32(SAP_ICMPV6_FILTER_ENABLED) &&

drivers/net/wireless/intel/iwlwifi/mei/net.c

250

if (filters->icmpv6_flags &

drivers/net/wireless/intel/iwlwifi/mei/net.c

267

const struct iwl_sap_oob_filters *filters,

drivers/net/wireless/intel/iwlwifi/mei/net.c

279

const struct iwl_sap_oob_filters *filters,

drivers/net/wireless/intel/iwlwifi/mei/net.c

285

const struct iwl_sap_oob_filters *filters,

drivers/net/wireless/intel/iwlwifi/mei/net.c

304

if (iwl_mei_rx_filter_eth(ethhdr, filters,

drivers/net/wireless/intel/iwlwifi/mei/net.c

323

*pass_to_csme = filt_handler(skb, filters, &rx_handler_res);

drivers/net/wireless/intel/iwlwifi/mei/net.c

329

const struct iwl_sap_oob_filters *filters,

drivers/net/wireless/intel/iwlwifi/mei/net.c

335

ret = iwl_mei_rx_pass_to_csme(orig_skb, filters, pass_to_csme);

drivers/net/wireless/intel/iwlwifi/mei/net.c

34

const struct iwl_sap_oob_filters *filters,

drivers/net/wireless/intel/iwlwifi/mei/net.c

45

for (filt = &filters->eth_filters[0];

drivers/net/wireless/intel/iwlwifi/mei/net.c

46

filt < &filters->eth_filters[0] + ARRAY_SIZE(filters->eth_filters);

drivers/net/wireless/intel/iwlwifi/mei/net.c

81

const struct iwl_sap_oob_filters *filters,

drivers/net/wireless/intel/iwlwifi/mei/net.c

84

const struct iwl_sap_ipv4_filter *filt = &filters->ipv4_filter;

drivers/net/wireless/intel/iwlwifi/mei/sap.h

718

struct iwl_sap_oob_filters filters;

drivers/net/wireless/st/cw1200/pm.c

22

struct wsm_udp_port_filter filters[WSM_MAX_FILTER_ELEMENTS];

drivers/net/wireless/st/cw1200/pm.c

28

struct wsm_ether_type_filter filters[WSM_MAX_FILTER_ELEMENTS];

drivers/net/wireless/st/cw1200/pm.c

33

.filters = {

drivers/net/wireless/st/cw1200/pm.c

57

.filters = {

include/kunit/attributes.h

42

struct kunit_attr_filter kunit_next_attr_filter(char **filters, int *err);

include/kunit/test.h

383

char *filters,

include/linux/avf/virtchnl.h

1882

valid_len = virtchnl_struct_size(vfl, filters,

include/linux/avf/virtchnl.h

806

struct virtchnl_vlan_filter filters[];

include/linux/io_uring_types.h

226

struct io_bpf_filter __rcu **filters;

include/linux/mmzone.h

539

unsigned long *filters[NR_BLOOM_FILTERS];

include/linux/perf_event.h

555

int (*addr_filters_validate) (struct list_head *filters);

include/linux/watch_queue.h

35

struct watch_type_filter filters[] __counted_by(nr_filters);

include/uapi/linux/watch_queue.h

62

struct watch_notification_type_filter filters[];

io_uring/bpf_filter.c

100

struct io_bpf_filters *filters;

io_uring/bpf_filter.c

103

filters = container_of(head, struct io_bpf_filters, rcu_head);

io_uring/bpf_filter.c

104

scoped_guard(spinlock, &filters->lock) {

io_uring/bpf_filter.c

105

filter = filters->filters;

io_uring/bpf_filter.c

135

kfree(filters->filters);

io_uring/bpf_filter.c

136

kfree(filters);

io_uring/bpf_filter.c

139

static void __io_put_bpf_filters(struct io_bpf_filters *filters)

io_uring/bpf_filter.c

141

if (refcount_dec_and_test(&filters->refs))

io_uring/bpf_filter.c

142

call_rcu(&filters->rcu_head, io_free_bpf_filters);

io_uring/bpf_filter.c

153

struct io_bpf_filters *filters __free(kfree) = NULL;

io_uring/bpf_filter.c

155

filters = kzalloc_obj(*filters, GFP_KERNEL_ACCOUNT);

io_uring/bpf_filter.c

156

if (!filters)

io_uring/bpf_filter.c

159

filters->filters = kzalloc_objs(struct io_bpf_filter *, IORING_OP_LAST,

io_uring/bpf_filter.c

161

if (!filters->filters)

io_uring/bpf_filter.c

164

refcount_set(&filters->refs, 1);

io_uring/bpf_filter.c

165

spin_lock_init(&filters->lock);

io_uring/bpf_filter.c

166

return no_free_ptr(filters);

io_uring/bpf_filter.c

268

struct io_bpf_filters *filters;

io_uring/bpf_filter.c

272

filters = io_new_bpf_filters();

io_uring/bpf_filter.c

273

if (IS_ERR(filters))

io_uring/bpf_filter.c

274

return filters;

io_uring/bpf_filter.c

285

srcf = rcu_dereference(src->bpf_filters->filters[i]);

io_uring/bpf_filter.c

289

rcu_assign_pointer(filters->filters[i], &dummy_filter);

io_uring/bpf_filter.c

300

rcu_assign_pointer(filters->filters[i], srcf);

io_uring/bpf_filter.c

303

return filters;

io_uring/bpf_filter.c

306

__io_put_bpf_filters(filters);

io_uring/bpf_filter.c

362

struct io_bpf_filters *filters, *old_filters = NULL;

io_uring/bpf_filter.c

384

filters = res->bpf_filters;

io_uring/bpf_filter.c

385

if (!filters) {

io_uring/bpf_filter.c

386

filters = io_new_bpf_filters();

io_uring/bpf_filter.c

387

if (IS_ERR(filters)) {

io_uring/bpf_filter.c

388

ret = PTR_ERR(filters);

io_uring/bpf_filter.c

392

filters = io_bpf_filter_cow(res);

io_uring/bpf_filter.c

393

if (IS_ERR(filters)) {

io_uring/bpf_filter.c

394

ret = PTR_ERR(filters);

io_uring/bpf_filter.c

420

res->bpf_filters = filters;

io_uring/bpf_filter.c

427

spin_lock_bh(&filters->lock);

io_uring/bpf_filter.c

428

old_filter = rcu_dereference(filters->filters[reg.filter.opcode]);

io_uring/bpf_filter.c

431

rcu_assign_pointer(filters->filters[reg.filter.opcode], filter);

io_uring/bpf_filter.c

441

old_filter = rcu_dereference(filters->filters[i]);

io_uring/bpf_filter.c

444

rcu_assign_pointer(filters->filters[i], &dummy_filter);

io_uring/bpf_filter.c

448

spin_unlock_bh(&filters->lock);

io_uring/bpf_filter.c

452

if (filters != res->bpf_filters)

io_uring/bpf_filter.c

453

__io_put_bpf_filters(filters);

io_uring/bpf_filter.c

57

int __io_uring_run_bpf_filters(struct io_bpf_filter __rcu **filters,

io_uring/bpf_filter.c

65

if (!rcu_access_pointer(filters[req->opcode]))

io_uring/bpf_filter.c

73

filter = rcu_dereference(filters[req->opcode]);

io_uring/bpf_filter.h

18

static inline int io_uring_run_bpf_filters(struct io_bpf_filter __rcu **filters,

io_uring/bpf_filter.h

21

if (filters)

io_uring/bpf_filter.h

22

return __io_uring_run_bpf_filters(filters, req);

io_uring/bpf_filter.h

34

static inline int io_uring_run_bpf_filters(struct io_bpf_filter __rcu **filters,

io_uring/bpf_filter.h

9

int __io_uring_run_bpf_filters(struct io_bpf_filter __rcu **filters, struct io_kiocb *req);

io_uring/io_uring.c

2185

ctx->restrictions.bpf_filters->filters);

io_uring/io_uring.c

2927

WRITE_ONCE(ctx->bpf_filters, dst->bpf_filters->filters);

io_uring/register.c

939

ctx->restrictions.bpf_filters->filters);

kernel/bpf/btf.c

234

btf_kfunc_filter_t filters[BTF_KFUNC_FILTER_MAX_CNT];

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/bpf/btf.c

8815

if (hook_filter->filters[i](prog, kfunc_btf_id))

kernel/events/core.c

11742

perf_addr_filter_new(struct perf_event *event, struct list_head *filters)

kernel/events/core.c

11752

list_add_tail(&filter->entry, filters);

kernel/events/core.c

11757

static void free_filters_list(struct list_head *filters)

kernel/events/core.c

11761

list_for_each_entry_safe(filter, iter, filters, entry) {

kernel/events/core.c

11939

struct list_head *filters)

kernel/events/core.c

11965

filter = perf_addr_filter_new(event, filters);

kernel/events/core.c

12088

free_filters_list(filters);

kernel/events/core.c

12097

LIST_HEAD(filters);

kernel/events/core.c

12109

ret = perf_event_parse_addr_filter(event, filter_str, &filters);

kernel/events/core.c

12113

ret = event->pmu->addr_filters_validate(&filters);

kernel/events/core.c

12118

perf_addr_filters_splice(event, &filters);

kernel/events/core.c

12126

free_filters_list(&filters);

kernel/watch_queue.c

170

wt = &wf->filters[i];

kernel/watch_queue.c

342

tf = memdup_array_user(_filter->filters, filter.nr_filters, sizeof(*tf));

kernel/watch_queue.c

361

wfilter = kzalloc_flex(*wfilter, filters, nr_filter);

kernel/watch_queue.c

366

q = wfilter->filters;

lib/kunit/attributes.c

336

struct kunit_attr_filter kunit_next_attr_filter(char **filters, int *err)

lib/kunit/attributes.c

342

char *input = *filters;

lib/kunit/attributes.c

392

*filters = input;

lib/kunit/executor.c

168

char *filters,

lib/kunit/executor.c

195

if (filters) {

lib/kunit/executor.c

196

filter_count = kunit_get_filter_count(filters);

lib/kunit/executor.c

203

parsed_filters[j] = kunit_next_attr_filter(&filters, err);

lib/kunit/executor_test.c

122

char filters[] = "speed>slow, module!=example", *filter = filters;

lib/kunit/executor_test.c

125

filter_count = kunit_get_filter_count(filters);

lib/kunit/executor_test.c

132

KUNIT_ASSERT_EQ_MSG(test, err, 0, "failed to parse filter from '%s'", filters);

mm/damon/core.c

984

static bool damos_filters_default_reject(struct list_head *filters)

mm/damon/core.c

988

if (list_empty(filters))

mm/damon/core.c

990

last_filter = list_last_entry(filters, struct damos_filter, list);

mm/damon/sysfs-schemes.c

1954

struct damon_sysfs_scheme_filters *filters;

mm/damon/sysfs-schemes.c

2108

struct damon_sysfs_scheme_filters *filters =

mm/damon/sysfs-schemes.c

2112

if (!filters)

mm/damon/sysfs-schemes.c

2114

err = kobject_init_and_add(&filters->kobj,

mm/damon/sysfs-schemes.c

2118

kobject_put(&filters->kobj);

mm/damon/sysfs-schemes.c

2120

*filters_ptr = filters;

mm/damon/sysfs-schemes.c

2130

&scheme->filters);

mm/damon/sysfs-schemes.c

2149

kobject_put(&scheme->filters->kobj);

mm/damon/sysfs-schemes.c

2150

scheme->filters = NULL;

mm/damon/sysfs-schemes.c

2224

kobject_put(&scheme->filters->kobj);

mm/damon/sysfs-schemes.c

2225

scheme->filters = NULL;

mm/damon/sysfs-schemes.c

2252

damon_sysfs_scheme_filters_rm_dirs(scheme->filters);

mm/damon/sysfs-schemes.c

2253

kobject_put(&scheme->filters->kobj);

mm/damon/sysfs-schemes.c

2752

err = damon_sysfs_add_scheme_filters(scheme, sysfs_scheme->filters);

mm/damon/sysfs-schemes.c

723

struct damon_sysfs_scheme_filters *filters;

mm/damon/sysfs-schemes.c

725

filters = kzalloc_obj(struct damon_sysfs_scheme_filters);

mm/damon/sysfs-schemes.c

726

if (filters)

mm/damon/sysfs-schemes.c

727

filters->handle_layer = layer;

mm/damon/sysfs-schemes.c

728

return filters;

mm/damon/sysfs-schemes.c

732

struct damon_sysfs_scheme_filters *filters)

mm/damon/sysfs-schemes.c

734

struct damon_sysfs_scheme_filter **filters_arr = filters->filters_arr;

mm/damon/sysfs-schemes.c

737

for (i = 0; i < filters->nr; i++)

mm/damon/sysfs-schemes.c

739

filters->nr = 0;

mm/damon/sysfs-schemes.c

741

filters->filters_arr = NULL;

mm/damon/sysfs-schemes.c

745

struct damon_sysfs_scheme_filters *filters, int nr_filters)

mm/damon/sysfs-schemes.c

750

damon_sysfs_scheme_filters_rm_dirs(filters);

mm/damon/sysfs-schemes.c

758

filters->filters_arr = filters_arr;

mm/damon/sysfs-schemes.c

762

filters->handle_layer);

mm/damon/sysfs-schemes.c

764

damon_sysfs_scheme_filters_rm_dirs(filters);

mm/damon/sysfs-schemes.c

770

&filters->kobj, "%d", i);

mm/damon/sysfs-schemes.c

773

damon_sysfs_scheme_filters_rm_dirs(filters);

mm/damon/sysfs-schemes.c

778

filters->nr++;

mm/damon/sysfs-schemes.c

786

struct damon_sysfs_scheme_filters *filters = container_of(kobj,

mm/damon/sysfs-schemes.c

789

return sysfs_emit(buf, "%d\n", filters->nr);

mm/damon/sysfs-schemes.c

795

struct damon_sysfs_scheme_filters *filters;

mm/damon/sysfs-schemes.c

803

filters = container_of(kobj, struct damon_sysfs_scheme_filters, kobj);

mm/damon/sysfs-schemes.c

807

err = damon_sysfs_scheme_filters_add_dirs(filters, nr);

mm/vmscan.c

2814

filter = READ_ONCE(mm_state->filters[gen]);

mm/vmscan.c

2830

filter = READ_ONCE(mm_state->filters[gen]);

mm/vmscan.c

2847

filter = mm_state->filters[gen];

mm/vmscan.c

2855

WRITE_ONCE(mm_state->filters[gen], filter);

mm/vmscan.c

5728

bitmap_free(mm_state->filters[i]);

mm/vmscan.c

5729

mm_state->filters[i] = NULL;

net/can/j1939/j1939-priv.h

306

struct j1939_filter *filters;

net/can/j1939/socket.c

271

f = jsk->filters;

net/can/j1939/socket.c

664

kfree(jsk->filters);

net/can/j1939/socket.c

699

struct j1939_filter *filters = NULL, *ofilters;

net/can/j1939/socket.c

710

if (optlen % sizeof(*filters) != 0)

net/can/j1939/socket.c

717

count = optlen / sizeof(*filters);

net/can/j1939/socket.c

718

filters = memdup_sockptr(optval, optlen);

net/can/j1939/socket.c

719

if (IS_ERR(filters))

net/can/j1939/socket.c

720

return PTR_ERR(filters);

net/can/j1939/socket.c

722

for (f = filters, c = count; c; f++, c--) {

net/can/j1939/socket.c

731

ofilters = jsk->filters;

net/can/j1939/socket.c

732

jsk->filters = filters;

net/core/rtnetlink.c

5938

const struct rtnl_stats_dump_filters *filters,

net/core/rtnetlink.c

5942

unsigned int filter_mask = filters->mask[0];

net/core/rtnetlink.c

6026

off_filter_mask = filters->mask[IFLA_STATS_LINK_OFFLOAD_XSTATS];

net/core/rtnetlink.c

6103

const struct rtnl_stats_dump_filters *filters)

net/core/rtnetlink.c

6106

unsigned int filter_mask = filters->mask[0];

net/core/rtnetlink.c

6145

off_filter_mask = filters->mask[IFLA_STATS_LINK_OFFLOAD_XSTATS];

net/core/rtnetlink.c

6191

struct rtnl_stats_dump_filters *filters,

net/core/rtnetlink.c

6205

if (!(filters->mask[0] & IFLA_STATS_FILTER_BIT(at))) {

net/core/rtnetlink.c

6209

filters->mask[at] = nla_get_u32(tb[at]);

net/core/rtnetlink.c

6218

struct rtnl_stats_dump_filters *filters,

net/core/rtnetlink.c

6225

filters->mask[0] = filter_mask;

net/core/rtnetlink.c

6226

for (i = 1; i < ARRAY_SIZE(filters->mask); i++)

net/core/rtnetlink.c

6227

filters->mask[i] = -1U;

net/core/rtnetlink.c

6236

filters, extack);

net/core/rtnetlink.c

6276

struct rtnl_stats_dump_filters filters;

net/core/rtnetlink.c

6303

err = rtnl_stats_get_parse(nlh, ifsm->filter_mask, &filters, extack);

net/core/rtnetlink.c

6307

nskb = nlmsg_new(if_nlmsg_stats_size(dev, &filters), GFP_KERNEL);

net/core/rtnetlink.c

6313

0, &filters, &idxattr, &prividx, extack);

net/core/rtnetlink.c

6328

struct rtnl_stats_dump_filters filters;

net/core/rtnetlink.c

6352

err = rtnl_stats_get_parse(cb->nlh, ifsm->filter_mask, &filters,

net/core/rtnetlink.c

6361

flags, &filters,

net/sched/cls_flow.c

307

list_for_each_entry_rcu(f, &head->filters, list) {

net/sched/cls_flow.c

34

struct list_head filters;

net/sched/cls_flow.c

557

list_add_tail_rcu(&fnew->list, &head->filters);

net/sched/cls_flow.c

586

*last = list_empty(&head->filters);

net/sched/cls_flow.c

597

INIT_LIST_HEAD(&head->filters);

net/sched/cls_flow.c

608

list_for_each_entry_safe(f, next, &head->filters, list) {

net/sched/cls_flow.c

623

list_for_each_entry(f, &head->filters, list)

net/sched/cls_flow.c

696

list_for_each_entry(f, &head->filters, list) {

net/sched/cls_flower.c

103

struct list_head filters;

net/sched/cls_flower.c

2258

INIT_LIST_HEAD_RCU(&newmask->filters);

net/sched/cls_flower.c

2562

list_add_tail_rcu(&fnew->list, &fnew->mask->filters);

net/sched/cls_flower.c

283

list_for_each_entry_rcu(filter, &mask->filters, list) {

net/sched/cls_flower.c

383

WARN_ON(!list_empty(&mask->filters));

net/sched/cls_flower.c

608

list_for_each_entry_safe(f, next, &mask->filters, list) {

samples/watch_queue/watch_test.c

152

.filters = {

sound/soc/meson/axg-pdm.c

150

const struct axg_pdm_filters *filters = priv->cfg->filters;

sound/soc/meson/axg-pdm.c

151

unsigned int os = filters->hcic.ds;

sound/soc/meson/axg-pdm.c

160

os *= filters->lpf[i].ds;

sound/soc/meson/axg-pdm.c

299

const struct axg_pdm_hcic *hcic = &priv->cfg->filters->hcic;

sound/soc/meson/axg-pdm.c

317

const struct axg_pdm_lpf *lpf = &priv->cfg->filters->lpf[index];

sound/soc/meson/axg-pdm.c

335

const struct axg_pdm_hpf *hpf = &priv->cfg->filters->hpf;

sound/soc/meson/axg-pdm.c

349

const struct axg_pdm_lpf *lpf = priv->cfg->filters->lpf;

sound/soc/meson/axg-pdm.c

574

.filters = &axg_default_filters,

sound/soc/meson/axg-pdm.c

87

const struct axg_pdm_filters *filters;

tools/perf/builtin-ftrace.c

1777

OPT_CALLBACK('T', "trace-funcs", &ftrace.filters, "func",

tools/perf/builtin-ftrace.c

1802

OPT_CALLBACK('T', "trace-funcs", &ftrace.filters, "func",

tools/perf/builtin-ftrace.c

1823

OPT_CALLBACK('T', "trace-funcs", &ftrace.filters, "func",

tools/perf/builtin-ftrace.c

1854

INIT_LIST_HEAD(&ftrace.filters);

tools/perf/builtin-ftrace.c

1913

if (list_empty(&ftrace.filters) && list_empty(&ftrace.event_pair)) {

tools/perf/builtin-ftrace.c

1920

if (!list_empty(&ftrace.filters) && !list_empty(&ftrace.event_pair)) {

tools/perf/builtin-ftrace.c

2017

delete_filter_func(&ftrace.filters);

tools/perf/builtin-ftrace.c

471

ret = __set_tracing_filter("set_ftrace_filter", &ftrace->filters);

tools/perf/builtin-ftrace.c

727

bool func = !list_empty(&ftrace->filters) ||

tools/perf/builtin-lock.c

1003

addrs = realloc(filters.addrs,

tools/perf/builtin-lock.c

1004

(filters.nr_addrs + 1) * sizeof(*addrs));

tools/perf/builtin-lock.c

1010

addrs[filters.nr_addrs++] = map__unmap_ip(kmap, sym->start);

tools/perf/builtin-lock.c

1011

filters.addrs = addrs;

tools/perf/builtin-lock.c

1042

if (filters.nr_types) {

tools/perf/builtin-lock.c

1045

for (i = 0; i < filters.nr_types; i++) {

tools/perf/builtin-lock.c

1046

if (flags == filters.types[i]) {

tools/perf/builtin-lock.c

1056

if (filters.nr_addrs) {

tools/perf/builtin-lock.c

1059

for (i = 0; i < filters.nr_addrs; i++) {

tools/perf/builtin-lock.c

1060

if (addr == filters.addrs[i]) {

tools/perf/builtin-lock.c

1534

zfree(&filters.types);

tools/perf/builtin-lock.c

1535

filters.nr_types = 0;

tools/perf/builtin-lock.c

1537

zfree(&filters.addrs);

tools/perf/builtin-lock.c

1538

filters.nr_addrs = 0;

tools/perf/builtin-lock.c

1540

for (int i = 0; i < filters.nr_syms; i++)

tools/perf/builtin-lock.c

1541

free(filters.syms[i]);

tools/perf/builtin-lock.c

1543

zfree(&filters.syms);

tools/perf/builtin-lock.c

1544

filters.nr_syms = 0;

tools/perf/builtin-lock.c

1546

zfree(&filters.cgrps);

tools/perf/builtin-lock.c

1547

filters.nr_cgrps = 0;

tools/perf/builtin-lock.c

1549

for (int i = 0; i < filters.nr_slabs; i++)

tools/perf/builtin-lock.c

1550

free(filters.slabs[i]);

tools/perf/builtin-lock.c

1552

zfree(&filters.slabs);

tools/perf/builtin-lock.c

1553

filters.nr_slabs = 0;

tools/perf/builtin-lock.c

2006

.filters = &filters,

tools/perf/builtin-lock.c

2277

tmp = realloc(filters.types, (filters.nr_types + 1) * sizeof(*filters.types));

tools/perf/builtin-lock.c

2281

tmp[filters.nr_types++] = flags;

tools/perf/builtin-lock.c

2282

filters.types = tmp;

tools/perf/builtin-lock.c

2351

tmp = realloc(filters.addrs, (filters.nr_addrs + 1) * sizeof(*filters.addrs));

tools/perf/builtin-lock.c

2357

tmp[filters.nr_addrs++] = addr;

tools/perf/builtin-lock.c

2358

filters.addrs = tmp;

tools/perf/builtin-lock.c

2372

tmp = realloc(filters.syms, (filters.nr_syms + 1) * sizeof(*filters.syms));

tools/perf/builtin-lock.c

2379

tmp[filters.nr_syms++] = sym;

tools/perf/builtin-lock.c

2380

filters.syms = tmp;

tools/perf/builtin-lock.c

2394

tmp = realloc(filters.slabs, (filters.nr_slabs + 1) * sizeof(*filters.slabs));

tools/perf/builtin-lock.c

2400

tmp[filters.nr_slabs++] = sym;

tools/perf/builtin-lock.c

2401

filters.slabs = tmp;

tools/perf/builtin-lock.c

2485

tmp = realloc(filters.cgrps, (filters.nr_cgrps + 1) * sizeof(*filters.cgrps));

tools/perf/builtin-lock.c

2491

tmp[filters.nr_cgrps++] = cgrp->id;

tools/perf/builtin-lock.c

2492

filters.cgrps = tmp;

tools/perf/builtin-lock.c

64

static struct lock_filter filters;

tools/perf/builtin-lock.c

993

for (i = 0; i < filters.nr_syms; i++) {

tools/perf/builtin-lock.c

995

filters.syms[i],

tools/perf/builtin-lock.c

999

filters.syms[i]);

tools/perf/util/bpf-filter.c

520

fd = bpf_map__fd(skel->maps.filters);

tools/perf/util/bpf-filter.c

687

bpf_map__set_max_entries(skel->maps.filters, MAX_FILTERS);

tools/perf/util/bpf_ftrace.c

28

if (!list_empty(&ftrace->filters)) {

tools/perf/util/bpf_ftrace.c

29

if (!list_is_singular(&ftrace->filters)) {

tools/perf/util/bpf_ftrace.c

33

func = list_first_entry(&ftrace->filters, struct filter_entry, list);

tools/perf/util/bpf_lock_contention.c

231

if (con->filters->nr_types) {

tools/perf/util/bpf_lock_contention.c

233

ntypes = con->filters->nr_types;

tools/perf/util/bpf_lock_contention.c

235

if (con->filters->nr_cgrps) {

tools/perf/util/bpf_lock_contention.c

237

ncgrps = con->filters->nr_cgrps;

tools/perf/util/bpf_lock_contention.c

241

if (con->filters->nr_syms) {

tools/perf/util/bpf_lock_contention.c

246

for (i = 0; i < con->filters->nr_syms; i++) {

tools/perf/util/bpf_lock_contention.c

248

con->filters->syms[i],

tools/perf/util/bpf_lock_contention.c

252

con->filters->syms[i]);

tools/perf/util/bpf_lock_contention.c

256

addrs = realloc(con->filters->addrs,

tools/perf/util/bpf_lock_contention.c

257

(con->filters->nr_addrs + 1) * sizeof(*addrs));

tools/perf/util/bpf_lock_contention.c

263

addrs[con->filters->nr_addrs++] = map__unmap_ip(kmap, sym->start);

tools/perf/util/bpf_lock_contention.c

264

con->filters->addrs = addrs;

tools/perf/util/bpf_lock_contention.c

266

naddrs = con->filters->nr_addrs;

tools/perf/util/bpf_lock_contention.c

302

if (con->aggr_mode == LOCK_AGGR_CGROUP || con->filters->nr_cgrps) {

tools/perf/util/bpf_lock_contention.c

309

if (con->filters->nr_slabs && has_slab_iter) {

tools/perf/util/bpf_lock_contention.c

311

nslabs = con->filters->nr_slabs;

tools/perf/util/bpf_lock_contention.c

355

if (con->filters->nr_types) {

tools/perf/util/bpf_lock_contention.c

360

for (i = 0; i < con->filters->nr_types; i++)

tools/perf/util/bpf_lock_contention.c

361

bpf_map_update_elem(fd, &con->filters->types[i], &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

364

if (con->filters->nr_addrs) {

tools/perf/util/bpf_lock_contention.c

369

for (i = 0; i < con->filters->nr_addrs; i++)

tools/perf/util/bpf_lock_contention.c

370

bpf_map_update_elem(fd, &con->filters->addrs[i], &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

373

if (con->filters->nr_cgrps) {

tools/perf/util/bpf_lock_contention.c

378

for (i = 0; i < con->filters->nr_cgrps; i++)

tools/perf/util/bpf_lock_contention.c

379

bpf_map_update_elem(fd, &con->filters->cgrps[i], &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

399

if (con->filters->nr_slabs) {

tools/perf/util/bpf_lock_contention.c

415

for (i = 0; i < con->filters->nr_slabs; i++) {

tools/perf/util/bpf_lock_contention.c

416

if (!strcmp(con->filters->slabs[i], data.name)) {

tools/perf/util/bpf_skel/sample_filter.bpf.c

16

} filters SEC(".maps");

tools/perf/util/bpf_skel/sample_filter.bpf.c

244

entry = bpf_map_lookup_elem(&filters, &k);

tools/perf/util/ftrace.h

16

struct list_head filters;

tools/perf/util/lock-contention.h

148

struct lock_filter *filters;

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

589

static int append_filter(struct filter **filters, int *cnt, const char *str)

tools/testing/selftests/bpf/veristat.c

596

tmp = realloc(*filters, (*cnt + 1) * sizeof(**filters));

tools/testing/selftests/bpf/veristat.c

599

*filters = tmp;

tools/testing/selftests/bpf/veristat.c

601

f = &(*filters)[*cnt];