arch/arm64/kvm/hyp/include/hyp/switch.h

846

const exit_handler_fn *handlers)

arch/arm64/kvm/hyp/include/hyp/switch.h

848

exit_handler_fn fn = handlers[kvm_vcpu_trap_get_class(vcpu)];

arch/arm64/kvm/hyp/include/hyp/switch.h

879

const exit_handler_fn *handlers)

arch/arm64/kvm/hyp/include/hyp/switch.h

910

if (kvm_hyp_handle_exit(vcpu, exit_code, handlers))

arch/arm64/kvm/hyp/nvhe/switch.c

212

const exit_handler_fn *handlers = kvm_get_exit_handler_array(vcpu);

arch/arm64/kvm/hyp/nvhe/switch.c

238

return __fixup_guest_exit(vcpu, exit_code, handlers);

arch/m68k/fpsp040/fpsp.h

16

| All FPSP handlers begin by executing:

arch/m68k/fpsp040/fpsp.h

48

| On exit, the handlers execute:

arch/m68k/fpsp040/fpsp.h

59

| type that was generated. Some handlers may omit the "frestore"

arch/powerpc/include/asm/pmac_pfunc.h

179

struct pmf_handlers *handlers,

arch/powerpc/platforms/powermac/pfunc_core.c

124

#define PMF_PARSE_CALL(name, cmd, handlers, p...) \

arch/powerpc/platforms/powermac/pfunc_core.c

128

if (handlers == NULL) \

arch/powerpc/platforms/powermac/pfunc_core.c

130

if (handlers->name) \

arch/powerpc/platforms/powermac/pfunc_core.c

131

return handlers->name(cmd->func, cmd->instdata, \

arch/powerpc/platforms/powermac/pfunc_core.c

542

struct pmf_handlers *handlers;

arch/powerpc/platforms/powermac/pfunc_core.c

580

struct pmf_handlers *handlers,

arch/powerpc/platforms/powermac/pfunc_core.c

596

handlers ? "executing" : "parsing");

arch/powerpc/platforms/powermac/pfunc_core.c

621

rc = pmf_parsers[ccode](&cmd, handlers);

arch/powerpc/platforms/powermac/pfunc_core.c

630

if (handlers == NULL)

arch/powerpc/platforms/powermac/pfunc_core.c

702

struct pmf_handlers *handlers,

arch/powerpc/platforms/powermac/pfunc_core.c

709

if (handlers == NULL)

arch/powerpc/platforms/powermac/pfunc_core.c

730

dev->handlers = handlers;

arch/powerpc/platforms/powermac/pfunc_core.c

751

if (!try_module_get(func->dev->handlers->owner))

arch/powerpc/platforms/powermac/pfunc_core.c

775

module_put(func->dev->handlers->owner);

arch/powerpc/platforms/powermac/pfunc_core.c

880

func->dev->handlers->irq_enable(func);

arch/powerpc/platforms/powermac/pfunc_core.c

911

func->dev->handlers->irq_disable(func);

arch/powerpc/platforms/powermac/pfunc_core.c

946

if (dev->handlers->begin)

arch/powerpc/platforms/powermac/pfunc_core.c

947

instdata = dev->handlers->begin(func, args);

arch/powerpc/platforms/powermac/pfunc_core.c

948

rc = pmf_parse_one(func, dev->handlers, instdata, args);

arch/powerpc/platforms/powermac/pfunc_core.c

949

if (dev->handlers->end)

arch/powerpc/platforms/powermac/pfunc_core.c

950

dev->handlers->end(func, instdata);

arch/um/os-Linux/signal.c

188

static void (*handlers[_NSIG])(int sig, struct siginfo *si, mcontext_t *mc) = {

arch/um/os-Linux/signal.c

210

(*handlers[sig])(sig, (struct siginfo *)si, mc);

drivers/acpi/prmt.c

108

module_info_size = struct_size(tm, handlers, module_info->handler_info_count);

drivers/acpi/prmt.c

150

th = &tm->handlers[cur_handler];

drivers/acpi/prmt.c

224

cur_handler = &cur_module->handlers[i];

drivers/acpi/prmt.c

72

struct prm_handler_info handlers[] __counted_by(handler_count);

drivers/char/ipmi/ipmi_ipmb.c

44

struct ipmi_smi_handlers handlers;

drivers/char/ipmi/ipmi_ipmb.c

523

iidev->handlers.flags = IPMI_SMI_CAN_HANDLE_IPMB_DIRECT;

drivers/char/ipmi/ipmi_ipmb.c

524

iidev->handlers.start_processing = ipmi_ipmb_start_processing;

drivers/char/ipmi/ipmi_ipmb.c

525

iidev->handlers.shutdown = ipmi_ipmb_shutdown;

drivers/char/ipmi/ipmi_ipmb.c

526

iidev->handlers.sender = ipmi_ipmb_sender;

drivers/char/ipmi/ipmi_ipmb.c

527

iidev->handlers.request_events = ipmi_ipmb_request_events;

drivers/char/ipmi/ipmi_ipmb.c

542

rv = ipmi_register_smi(&iidev->handlers,

drivers/char/ipmi/ipmi_msghandler.c

1020

if (!intf->handlers->set_need_watch)

drivers/char/ipmi/ipmi_msghandler.c

1035

intf->handlers->set_need_watch(intf->send_info,

drivers/char/ipmi/ipmi_msghandler.c

1045

if (!intf->handlers->set_need_watch)

drivers/char/ipmi/ipmi_msghandler.c

1068

intf->handlers->set_need_watch(intf->send_info,

drivers/char/ipmi/ipmi_msghandler.c

1329

if (!intf->handlers->get_smi_info)

drivers/char/ipmi/ipmi_msghandler.c

1332

rv = intf->handlers->get_smi_info(intf->send_info, data);

drivers/char/ipmi/ipmi_msghandler.c

1554

if (intf->handlers->set_maintenance_mode)

drivers/char/ipmi/ipmi_msghandler.c

1560

intf->handlers->set_maintenance_mode(

drivers/char/ipmi/ipmi_msghandler.c

1889

const struct ipmi_smi_handlers *handlers,

drivers/char/ipmi/ipmi_msghandler.c

1901

rv = handlers->sender(intf->send_info, smi_msg);

drivers/char/ipmi/ipmi_msghandler.c

2146

if (!(intf->handlers->flags & IPMI_SMI_CAN_HANDLE_IPMB_DIRECT))

drivers/char/ipmi/ipmi_msghandler.c

2398

rv = smi_send(intf, intf->handlers, smi_msg, priority);

drivers/char/ipmi/ipmi_msghandler.c

3543

if (intf->handlers->poll)

drivers/char/ipmi/ipmi_msghandler.c

3544

intf->handlers->poll(intf->send_info);

drivers/char/ipmi/ipmi_msghandler.c

3609

const struct ipmi_smi_handlers *handlers,

drivers/char/ipmi/ipmi_msghandler.c

3653

intf->handlers = handlers;

drivers/char/ipmi/ipmi_msghandler.c

3703

rv = handlers->start_processing(send_info, intf);

drivers/char/ipmi/ipmi_msghandler.c

3754

if (intf->handlers->shutdown)

drivers/char/ipmi/ipmi_msghandler.c

3755

intf->handlers->shutdown(intf->send_info);

drivers/char/ipmi/ipmi_msghandler.c

3845

if (intf->handlers->shutdown)

drivers/char/ipmi/ipmi_msghandler.c

3846

intf->handlers->shutdown(intf->send_info);

drivers/char/ipmi/ipmi_msghandler.c

3997

if (smi_send(intf, intf->handlers, msg, 0) == IPMI_CC_NO_ERROR)

drivers/char/ipmi/ipmi_msghandler.c

4076

if (smi_send(intf, intf->handlers, msg, 0) == IPMI_CC_NO_ERROR)

drivers/char/ipmi/ipmi_msghandler.c

4274

if (smi_send(intf, intf->handlers, msg, 0) == IPMI_CC_NO_ERROR)

drivers/char/ipmi/ipmi_msghandler.c

460

const struct ipmi_smi_handlers *handlers;

drivers/char/ipmi/ipmi_msghandler.c

4891

cc = intf->handlers->sender(intf->send_info, newmsg);

drivers/char/ipmi/ipmi_msghandler.c

5080

if (intf->handlers) {

drivers/char/ipmi/ipmi_msghandler.c

5089

if (smi_send(intf, intf->handlers, smi_msg, 0) != IPMI_CC_NO_ERROR) {

drivers/char/ipmi/ipmi_msghandler.c

5177

intf->handlers->request_events(intf->send_info);

drivers/char/ipmi/ipmi_msghandler.c

5349

else if (intf->handlers->flush_messages)

drivers/char/ipmi/ipmi_msghandler.c

5350

intf->handlers->flush_messages(intf->send_info);

drivers/char/ipmi/ipmi_msghandler.c

5549

if (!intf->handlers || intf->intf_num == -1)

drivers/char/ipmi/ipmi_msghandler.c

5553

if (!intf->handlers->poll)

drivers/char/ipmi/ipmi_msghandler.c

5574

if (intf->handlers->set_run_to_completion)

drivers/char/ipmi/ipmi_msghandler.c

5575

intf->handlers->set_run_to_completion(intf->send_info,

drivers/char/ipmi/ipmi_si_intf.c

1238

static const struct ipmi_smi_handlers handlers = {

drivers/char/ipmi/ipmi_si_intf.c

1318

smi_result = smi_info->handlers->event(smi_info->si_sm, 0);

drivers/char/ipmi/ipmi_si_intf.c

1323

smi_result = smi_info->handlers->event(

drivers/char/ipmi/ipmi_si_intf.c

1326

smi_result = smi_info->handlers->event(

drivers/char/ipmi/ipmi_si_intf.c

136

const struct si_sm_handlers *handlers;

drivers/char/ipmi/ipmi_si_intf.c

1361

smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);

drivers/char/ipmi/ipmi_si_intf.c

1367

resp_len = smi_info->handlers->get_result(smi_info->si_sm,

drivers/char/ipmi/ipmi_si_intf.c

1404

smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);

drivers/char/ipmi/ipmi_si_intf.c

1414

resp_len = smi_info->handlers->get_result(smi_info->si_sm,

drivers/char/ipmi/ipmi_si_intf.c

1452

smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);

drivers/char/ipmi/ipmi_si_intf.c

1462

resp_len = smi_info->handlers->get_result(smi_info->si_sm,

drivers/char/ipmi/ipmi_si_intf.c

1570

smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);

drivers/char/ipmi/ipmi_si_intf.c

1578

resp_len = smi_info->handlers->get_result(smi_info->si_sm,

drivers/char/ipmi/ipmi_si_intf.c

1599

smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);

drivers/char/ipmi/ipmi_si_intf.c

1607

resp_len = smi_info->handlers->get_result(smi_info->si_sm,

drivers/char/ipmi/ipmi_si_intf.c

1987

new_smi->handlers = &kcs_smi_handlers;

drivers/char/ipmi/ipmi_si_intf.c

1991

new_smi->handlers = &smic_smi_handlers;

drivers/char/ipmi/ipmi_si_intf.c

1995

new_smi->handlers = &bt_smi_handlers;

drivers/char/ipmi/ipmi_si_intf.c

2014

new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);

drivers/char/ipmi/ipmi_si_intf.c

2019

new_smi->io.io_size = new_smi->handlers->init_data(new_smi->si_sm,

drivers/char/ipmi/ipmi_si_intf.c

2030

if (new_smi->handlers->detect(new_smi->si_sm)) {

drivers/char/ipmi/ipmi_si_intf.c

2093

rv = ipmi_register_smi(&handlers,

drivers/char/ipmi/ipmi_si_intf.c

2285

if (smi_info->handlers)

drivers/char/ipmi/ipmi_si_intf.c

2290

if (smi_info->handlers)

drivers/char/ipmi/ipmi_si_intf.c

2291

smi_info->handlers->cleanup(smi_info->si_sm);

drivers/char/ipmi/ipmi_si_intf.c

334

err = smi_info->handlers->start_transaction(

drivers/char/ipmi/ipmi_si_intf.c

367

smi_info->handlers->start_transaction(smi_info->si_sm, msg, size);

drivers/char/ipmi/ipmi_si_intf.c

565

= smi_info->handlers->get_result(

drivers/char/ipmi/ipmi_si_intf.c

586

len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);

drivers/char/ipmi/ipmi_si_intf.c

608

smi_info->handlers->get_result(smi_info->si_sm, msg, 3);

drivers/char/ipmi/ipmi_si_intf.c

621

= smi_info->handlers->get_result(

drivers/char/ipmi/ipmi_si_intf.c

659

= smi_info->handlers->get_result(

drivers/char/ipmi/ipmi_si_intf.c

701

smi_info->handlers->get_result(smi_info->si_sm, msg, 4);

drivers/char/ipmi/ipmi_si_intf.c

719

smi_info->handlers->start_transaction(

drivers/char/ipmi/ipmi_si_intf.c

739

smi_info->handlers->get_result(smi_info->si_sm, msg, 4);

drivers/char/ipmi/ipmi_si_intf.c

785

si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);

drivers/char/ipmi/ipmi_si_intf.c

788

si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);

drivers/char/ipmi/ipmi_ssif.c

1871

ssif_info->handlers.owner = THIS_MODULE;

drivers/char/ipmi/ipmi_ssif.c

1872

ssif_info->handlers.start_processing = ssif_start_processing;

drivers/char/ipmi/ipmi_ssif.c

1873

ssif_info->handlers.shutdown = shutdown_ssif;

drivers/char/ipmi/ipmi_ssif.c

1874

ssif_info->handlers.get_smi_info = get_smi_info;

drivers/char/ipmi/ipmi_ssif.c

1875

ssif_info->handlers.sender = sender;

drivers/char/ipmi/ipmi_ssif.c

1876

ssif_info->handlers.request_events = request_events;

drivers/char/ipmi/ipmi_ssif.c

1877

ssif_info->handlers.set_need_watch = ssif_set_need_watch;

drivers/char/ipmi/ipmi_ssif.c

1907

rv = ipmi_register_smi(&ssif_info->handlers,

drivers/char/ipmi/ipmi_ssif.c

209

struct ipmi_smi_handlers handlers;

drivers/firewire/core-transaction.c

1027

struct fw_address_handler *handler, **handlers;

drivers/firewire/core-transaction.c

1050

handlers = buffer_on_kernel_stack;

drivers/firewire/core-transaction.c

1059

if (handlers == buffer_on_kernel_stack)

drivers/firewire/core-transaction.c

1062

buffer_on_kernel_heap = handlers;

drivers/firewire/core-transaction.c

1073

if (handlers == buffer_on_kernel_stack) {

drivers/firewire/core-transaction.c

1078

handlers = buffer_on_kernel_heap;

drivers/firewire/core-transaction.c

1082

handlers[count++] = handler;

drivers/firewire/core-transaction.c

1088

handler = handlers[i];

drivers/firewire/core-transaction.c

1095

if (handlers != buffer_on_kernel_stack)

drivers/firewire/core-transaction.c

1096

kfree(handlers);

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

127

const struct pipe_fault_handler *handlers,

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

133

for (handler = handlers; handler && handler->fault; handler++) {

drivers/hid/hid-wiimote-core.c

1594

static const struct wiiproto_handler handlers[] = {

drivers/hid/hid-wiimote-core.c

1633

for (i = 0; handlers[i].id; ++i) {

drivers/hid/hid-wiimote-core.c

1634

h = &handlers[i];

drivers/hid/hid-wiimote-core.c

1643

if (!handlers[i].id)

drivers/infiniband/hw/efa/efa_com.c

830

if (group < EFA_MAX_HANDLERS && aenq_handlers->handlers[group])

drivers/infiniband/hw/efa/efa_com.c

831

return aenq_handlers->handlers[group];

drivers/infiniband/hw/efa/efa_com.h

150

efa_aenq_handler handlers[EFA_MAX_HANDLERS];

drivers/infiniband/hw/efa/efa_main.c

62

.handlers = {

drivers/media/platform/amphion/vpu_msgs.c

199

static struct vpu_msg_handler handlers[] = {

drivers/media/platform/amphion/vpu_msgs.c

232

for (i = 0; i < ARRAY_SIZE(handlers); i++) {

drivers/media/platform/amphion/vpu_msgs.c

233

if (handlers[i].id == msg_id) {

drivers/media/platform/amphion/vpu_msgs.c

234

handler = &handlers[i];

drivers/media/platform/qcom/venus/hfi_msgs.c

697

static const struct hfi_done_handler handlers[] = {

drivers/media/platform/qcom/venus/hfi_msgs.c

815

for (i = 0; i < ARRAY_SIZE(handlers); i++) {

drivers/media/platform/qcom/venus/hfi_msgs.c

816

handler = &handlers[i];

drivers/message/fusion/mptbase.c

7701

int handlers = 0;

drivers/message/fusion/mptbase.c

7774

handlers++;

drivers/message/fusion/mptbase.c

7791

*evHandlers = handlers;

drivers/mfd/menelaus.c

163

void (*handlers[16])(struct menelaus_chip *);

drivers/mfd/menelaus.c

235

the_menelaus->handlers[irq] = handler;

drivers/mfd/menelaus.c

249

the_menelaus->handlers[irq] = NULL;

drivers/mfd/menelaus.c

782

handler = menelaus->handlers[irq];

drivers/net/ethernet/amazon/ena/ena_com.c

2283

if ((group < ENA_MAX_HANDLERS) && aenq_handlers->handlers[group])

drivers/net/ethernet/amazon/ena/ena_com.c

2284

return aenq_handlers->handlers[group];

drivers/net/ethernet/amazon/ena/ena_com.h

417

ena_aenq_handler handlers[ENA_MAX_HANDLERS];

drivers/net/ethernet/amazon/ena/ena_netdev.c

4372

.handlers = {

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

708

t3c_tid->client->handlers &&

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

709

t3c_tid->client->handlers[CPL_ACT_OPEN_RPL]) {

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

710

return t3c_tid->client->handlers[CPL_ACT_OPEN_RPL] (dev, skb,

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

727

if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers &&

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

728

t3c_tid->client->handlers[p->opcode]) {

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

729

return t3c_tid->client->handlers[p->opcode] (dev, skb,

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

745

if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers &&

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

746

t3c_tid->client->handlers[p->opcode]) {

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

747

return t3c_tid->client->handlers[p->opcode]

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

772

if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers &&

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

773

t3c_tid->client->handlers[CPL_PASS_ACCEPT_REQ]) {

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

774

return t3c_tid->client->handlers[CPL_PASS_ACCEPT_REQ]

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

812

if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers &&

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

813

t3c_tid->client->handlers[p->opcode]) {

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

814

return t3c_tid->client->handlers[p->opcode]

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

866

if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers &&

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

867

t3c_tid->client->handlers[CPL_ACT_ESTABLISH]) {

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

868

return t3c_tid->client->handlers[CPL_ACT_ESTABLISH]

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

912

if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers &&

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

913

t3c_tid->client->handlers[opcode]) {

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

914

return t3c_tid->client->handlers[opcode] (dev, skb,

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.h

86

cxgb3_cpl_handler_func *handlers;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

2643

struct qed_queue_cid *handlers[QED_MAX_VF_CHAINS_PER_PF];

drivers/net/ethernet/qlogic/qed/qed_sriov.c

2693

handlers[i] = vf->vf_queues[qid].cids[qid_usage_idx].p_cid;

drivers/net/ethernet/qlogic/qed/qed_sriov.c

2696

rc = qed_sp_eth_rx_queues_update(p_hwfn, (void **)&handlers,

drivers/net/wireless/intel/iwlegacy/3945-mac.c

1185

if (il->handlers[pkt->hdr.cmd]) {

drivers/net/wireless/intel/iwlegacy/3945-mac.c

1188

il->isr_stats.handlers[pkt->hdr.cmd]++;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

1189

il->handlers[pkt->hdr.cmd] (il, rxb);

drivers/net/wireless/intel/iwlegacy/3945-mac.c

818

il->handlers[N_ALIVE] = il3945_hdl_alive;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

819

il->handlers[C_ADD_STA] = il3945_hdl_add_sta;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

820

il->handlers[N_ERROR] = il_hdl_error;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

821

il->handlers[N_CHANNEL_SWITCH] = il_hdl_csa;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

822

il->handlers[N_SPECTRUM_MEASUREMENT] = il_hdl_spectrum_measurement;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

823

il->handlers[N_PM_SLEEP] = il_hdl_pm_sleep;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

824

il->handlers[N_PM_DEBUG_STATS] = il_hdl_pm_debug_stats;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

825

il->handlers[N_BEACON] = il3945_hdl_beacon;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

832

il->handlers[C_STATS] = il3945_hdl_c_stats;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

833

il->handlers[N_STATS] = il3945_hdl_stats;

drivers/net/wireless/intel/iwlegacy/3945-mac.c

836

il->handlers[N_CARD_STATE] = il3945_hdl_card_state;

drivers/net/wireless/intel/iwlegacy/3945.c

2449

il->handlers[C_TX] = il3945_hdl_tx;

drivers/net/wireless/intel/iwlegacy/3945.c

2450

il->handlers[N_3945_RX] = il3945_hdl_rx;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4167

il->handlers[N_ALIVE] = il4965_hdl_alive;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4168

il->handlers[N_ERROR] = il_hdl_error;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4169

il->handlers[N_CHANNEL_SWITCH] = il_hdl_csa;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4170

il->handlers[N_SPECTRUM_MEASUREMENT] = il_hdl_spectrum_measurement;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4171

il->handlers[N_PM_SLEEP] = il_hdl_pm_sleep;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4172

il->handlers[N_PM_DEBUG_STATS] = il_hdl_pm_debug_stats;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4173

il->handlers[N_BEACON] = il4965_hdl_beacon;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4180

il->handlers[C_STATS] = il4965_hdl_c_stats;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4181

il->handlers[N_STATS] = il4965_hdl_stats;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4186

il->handlers[N_CARD_STATE] = il4965_hdl_card_state;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4188

il->handlers[N_MISSED_BEACONS] = il4965_hdl_missed_beacon;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4190

il->handlers[N_RX_PHY] = il4965_hdl_rx_phy;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4191

il->handlers[N_RX_MPDU] = il4965_hdl_rx;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4192

il->handlers[N_RX] = il4965_hdl_rx;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4194

il->handlers[N_COMPRESSED_BA] = il4965_hdl_compressed_ba;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4196

il->handlers[C_TX] = il4965_hdl_tx;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4255

if (il->handlers[pkt->hdr.cmd]) {

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4258

il->isr_stats.handlers[pkt->hdr.cmd]++;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4259

il->handlers[pkt->hdr.cmd] (il, rxb);

drivers/net/wireless/intel/iwlegacy/common.c

1456

il->handlers[C_SCAN] = il_hdl_scan;

drivers/net/wireless/intel/iwlegacy/common.c

1457

il->handlers[N_SCAN_START] = il_hdl_scan_start;

drivers/net/wireless/intel/iwlegacy/common.c

1458

il->handlers[N_SCAN_RESULTS] = il_hdl_scan_results;

drivers/net/wireless/intel/iwlegacy/common.c

1459

il->handlers[N_SCAN_COMPLETE] = il_hdl_scan_complete;

drivers/net/wireless/intel/iwlegacy/common.h

1025

u32 handlers[IL_CN_MAX];

drivers/net/wireless/intel/iwlegacy/common.h

1142

void (*handlers[IL_CN_MAX]) (struct il_priv *il,

drivers/net/wireless/intel/iwlegacy/debug.c

694

if (il->isr_stats.handlers[cnt] > 0)

drivers/net/wireless/intel/iwlegacy/debug.c

699

il->isr_stats.handlers[cnt]);

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

947

void (**handlers)(struct iwl_priv *priv, struct iwl_rx_cmd_buffer *rxb);

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

949

handlers = priv->rx_handlers;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

951

handlers[REPLY_ERROR] = iwlagn_rx_reply_error;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

952

handlers[CHANNEL_SWITCH_NOTIFICATION] = iwlagn_rx_csa;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

953

handlers[SPECTRUM_MEASURE_NOTIFICATION] =

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

955

handlers[PM_SLEEP_NOTIFICATION] = iwlagn_rx_pm_sleep_notif;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

956

handlers[PM_DEBUG_STATISTIC_NOTIFIC] =

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

958

handlers[BEACON_NOTIFICATION] = iwlagn_rx_beacon_notif;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

959

handlers[REPLY_ADD_STA] = iwl_add_sta_callback;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

961

handlers[REPLY_WIPAN_NOA_NOTIFICATION] = iwlagn_rx_noa_notification;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

968

handlers[REPLY_STATISTICS_CMD] = iwlagn_rx_reply_statistics;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

969

handlers[STATISTICS_NOTIFICATION] = iwlagn_rx_statistics;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

973

handlers[CARD_STATE_NOTIFICATION] = iwlagn_rx_card_state_notif;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

974

handlers[MISSED_BEACONS_NOTIFICATION] =

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

978

handlers[REPLY_RX_PHY_CMD] = iwlagn_rx_reply_rx_phy;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

979

handlers[REPLY_RX_MPDU_CMD] = iwlagn_rx_reply_rx;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

982

handlers[REPLY_COMPRESSED_BA] =

drivers/ntb/ntb_transport.c

2021

const struct ntb_queue_handlers *handlers)

drivers/ntb/ntb_transport.c

2053

qp->rx_handler = handlers->rx_handler;

drivers/ntb/ntb_transport.c

2054

qp->tx_handler = handlers->tx_handler;

drivers/ntb/ntb_transport.c

2055

qp->event_handler = handlers->event_handler;

drivers/remoteproc/remoteproc_core.c

1016

rproc_handle_resource_t handlers[RSC_LAST])

drivers/remoteproc/remoteproc_core.c

1058

handler = handlers[hdr->type];

drivers/scsi/cxgbi/cxgb3i/cxgb3i.c

77

.handlers = cxgb3i_cpl_handlers,

drivers/soc/fsl/qbman/qman_test_stash.c

161

struct list_head handlers;

drivers/soc/fsl/qbman/qman_test_stash.c

326

INIT_LIST_HEAD(&hp_cpu->handlers);

drivers/soc/fsl/qbman/qman_test_stash.c

337

list_add_tail(&handler->node, &hp_cpu->handlers);

drivers/soc/fsl/qbman/qman_test_stash.c

350

list_for_each_safe(loop, tmp, &hp_cpu->handlers) {

drivers/soc/fsl/qbman/qman_test_stash.c

453

&hp_cpu->handlers,

drivers/soc/fsl/qbman/qman_test_stash.c

477

handler = list_first_entry(&hp_cpu->handlers, struct hp_handler, node);

drivers/soc/fsl/qbman/qman_test_stash.c

496

&hp_cpu->handlers,

drivers/soc/qcom/qmi_interface.c

398

if (!qmi->handlers)

drivers/soc/qcom/qmi_interface.c

401

for (handler = qmi->handlers; handler->fn; handler++) {

drivers/soc/qcom/qmi_interface.c

623

const struct qmi_msg_handler *handlers)

drivers/soc/qcom/qmi_interface.c

638

qmi->handlers = handlers;

fs/btrfs/props.c

167

const struct hlist_head *handlers;

fs/btrfs/props.c

187

handlers = find_prop_handlers_by_hash(key.offset);

fs/btrfs/props.c

188

if (!handlers)

fs/btrfs/props.c

223

handler = find_prop_handler(name_buf, handlers);

fs/btrfs/props.c

48

const struct hlist_head *handlers)

fs/btrfs/props.c

52

if (!handlers) {

fs/btrfs/props.c

55

handlers = find_prop_handlers_by_hash(hash);

fs/btrfs/props.c

56

if (!handlers)

fs/btrfs/props.c

60

hlist_for_each_entry(h, handlers, node)

fs/ext4/fsmap.c

707

struct ext4_getfsmap_dev handlers[EXT4_GETFSMAP_DEVS];

fs/ext4/fsmap.c

721

memset(handlers, 0, sizeof(handlers));

fs/ext4/fsmap.c

722

handlers[0].gfd_dev = new_encode_dev(sb->s_bdev->bd_dev);

fs/ext4/fsmap.c

723

handlers[0].gfd_fn = ext4_getfsmap_datadev;

fs/ext4/fsmap.c

725

handlers[1].gfd_dev = new_encode_dev(

fs/ext4/fsmap.c

727

handlers[1].gfd_fn = ext4_getfsmap_logdev;

fs/ext4/fsmap.c

730

sort(handlers, EXT4_GETFSMAP_DEVS, sizeof(struct ext4_getfsmap_dev),

fs/ext4/fsmap.c

762

if (!handlers[i].gfd_fn)

fs/ext4/fsmap.c

764

if (head->fmh_keys[0].fmr_device > handlers[i].gfd_dev)

fs/ext4/fsmap.c

766

if (head->fmh_keys[1].fmr_device < handlers[i].gfd_dev)

fs/ext4/fsmap.c

776

if (handlers[i].gfd_dev == head->fmh_keys[1].fmr_device)

fs/ext4/fsmap.c

778

if (handlers[i].gfd_dev > head->fmh_keys[0].fmr_device)

fs/ext4/fsmap.c

781

info.gfi_dev = handlers[i].gfd_dev;

fs/ext4/fsmap.c

784

error = handlers[i].gfd_fn(sb, dkeys, &info);

fs/xattr.c

1126

const struct xattr_handler *handler, * const *handlers = dentry->d_sb->s_xattr;

fs/xattr.c

1129

for_each_xattr_handler(handlers, handler) {

fs/xattr.c

164

const struct xattr_handler * const *handlers = inode->i_sb->s_xattr;

fs/xattr.c

173

for_each_xattr_handler(handlers, handler) {

fs/xattr.c

46

#define for_each_xattr_handler(handlers, handler) \

fs/xattr.c

47

if (handlers) \

fs/xattr.c

48

for ((handler) = *(handlers)++; \

fs/xattr.c

50

(handler) = *(handlers)++)

fs/xattr.c

58

const struct xattr_handler * const *handlers = inode->i_sb->s_xattr;

fs/xattr.c

66

for_each_xattr_handler(handlers, handler) {

fs/xfs/xfs_fsmap.c

1160

struct xfs_getfsmap_dev handlers[XFS_GETFSMAP_DEVS];

fs/xfs/xfs_fsmap.c

1182

memset(handlers, 0, sizeof(handlers));

fs/xfs/xfs_fsmap.c

1183

handlers[0].nr_sectors = XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);

fs/xfs/xfs_fsmap.c

1184

handlers[0].dev = xfs_getfsmap_device(mp, XFS_DEV_DATA);

fs/xfs/xfs_fsmap.c

1186

handlers[0].fn = xfs_getfsmap_datadev_rmapbt;

fs/xfs/xfs_fsmap.c

1188

handlers[0].fn = xfs_getfsmap_datadev_bnobt;

fs/xfs/xfs_fsmap.c

1190

handlers[1].nr_sectors = XFS_FSB_TO_BB(mp,

fs/xfs/xfs_fsmap.c

1192

handlers[1].dev = xfs_getfsmap_device(mp, XFS_DEV_LOG);

fs/xfs/xfs_fsmap.c

1193

handlers[1].fn = xfs_getfsmap_logdev;

fs/xfs/xfs_fsmap.c

1201

handlers[2].nr_sectors = XFS_FSB_TO_BB(mp, mp->m_sb.sb_rblocks);

fs/xfs/xfs_fsmap.c

1202

handlers[2].dev = xfs_getfsmap_device(mp, XFS_DEV_RT);

fs/xfs/xfs_fsmap.c

1204

handlers[2].fn = xfs_getfsmap_rtdev_rmapbt;

fs/xfs/xfs_fsmap.c

1206

handlers[2].fn = xfs_getfsmap_rtdev_rtbitmap;

fs/xfs/xfs_fsmap.c

1210

xfs_sort(handlers, XFS_GETFSMAP_DEVS, sizeof(struct xfs_getfsmap_dev),

fs/xfs/xfs_fsmap.c

1240

if (!handlers[i].fn)

fs/xfs/xfs_fsmap.c

1242

if (head->fmh_keys[0].fmr_device > handlers[i].dev)

fs/xfs/xfs_fsmap.c

1244

if (head->fmh_keys[1].fmr_device < handlers[i].dev)

fs/xfs/xfs_fsmap.c

1253

if (handlers[i].dev == head->fmh_keys[1].fmr_device) {

fs/xfs/xfs_fsmap.c

1255

info.end_daddr = min(handlers[i].nr_sectors - 1,

fs/xfs/xfs_fsmap.c

1258

info.end_daddr = handlers[i].nr_sectors - 1;

fs/xfs/xfs_fsmap.c

1265

if (handlers[i].dev > head->fmh_keys[0].fmr_device)

fs/xfs/xfs_fsmap.c

1275

info.dev = handlers[i].dev;

fs/xfs/xfs_fsmap.c

1280

error = handlers[i].fn(tp, dkeys, &info);

include/linux/ipmi_smi.h

296

const struct ipmi_smi_handlers *handlers,

include/linux/ipmi_smi.h

301

#define ipmi_register_smi(handlers, send_info, dev, slave_addr) \

include/linux/ipmi_smi.h

302

ipmi_add_smi(THIS_MODULE, handlers, send_info, dev, slave_addr)

include/linux/ntb_transport.h

76

const struct ntb_queue_handlers *handlers);

include/linux/soc/qcom/qmi.h

237

const struct qmi_msg_handler *handlers;

include/linux/soc/qcom/qmi.h

247

const struct qmi_msg_handler *handlers);

include/net/bluetooth/hci_core.h

2375

const struct hci_mgmt_handler *handlers;

include/net/rtnetlink.h

56

int __rtnl_register_many(const struct rtnl_msg_handler *handlers, int n);

include/net/rtnetlink.h

57

void __rtnl_unregister_many(const struct rtnl_msg_handler *handlers, int n);

include/net/rtnetlink.h

59

#define rtnl_register_many(handlers) \

include/net/rtnetlink.h

60

__rtnl_register_many(handlers, ARRAY_SIZE(handlers))

include/net/rtnetlink.h

61

#define rtnl_unregister_many(handlers) \

include/net/rtnetlink.h

62

__rtnl_unregister_many(handlers, ARRAY_SIZE(handlers))

net/bluetooth/hci_sock.c

1659

chan->handlers[opcode].func == NULL) {

net/bluetooth/hci_sock.c

1666

handler = &chan->handlers[opcode];

net/bluetooth/mgmt.c

10599

.handlers = mgmt_handlers,

net/core/rtnetlink.c

530

int __rtnl_register_many(const struct rtnl_msg_handler *handlers, int n)

net/core/rtnetlink.c

535

for (i = 0, handler = handlers; i < n; i++, handler++) {

net/core/rtnetlink.c

542

"handlers, %pS\n", handlers);

net/core/rtnetlink.c

544

__rtnl_unregister_many(handlers, i);

net/core/rtnetlink.c

553

void __rtnl_unregister_many(const struct rtnl_msg_handler *handlers, int n)

net/core/rtnetlink.c

558

for (i = n - 1, handler = handlers + n - 1; i >= 0; i--, handler--)

net/wireless/wext-core.c

702

const struct iw_handler_def *handlers = NULL;

net/wireless/wext-core.c

710

handlers = dev->ieee80211_ptr->wiphy->wext;

net/wireless/wext-core.c

715

handlers = dev->wireless_handlers;

net/wireless/wext-core.c

718

if (!handlers)

net/wireless/wext-core.c

723

if (index < handlers->num_standard)

net/wireless/wext-core.c

724

return handlers->standard[index];

net/wireless/wext-core.c

729

if (index < handlers->num_private)

net/wireless/wext-core.c

730

return handlers->private[index];

tools/perf/builtin-sched.c

1916

struct evsel_str_handler handlers[] = {

tools/perf/builtin-sched.c

1942

handlers[2].handler = process_sched_wakeup_ignore;

tools/perf/builtin-sched.c

1944

if (perf_session__set_tracepoints_handlers(session, handlers))

tools/perf/builtin-sched.c

3277

struct evsel_str_handler handlers[] = {

tools/perf/builtin-sched.c

3349

handlers[1].handler = timehist_sched_wakeup_ignore;

tools/perf/builtin-sched.c

3352

if (perf_session__set_tracepoints_handlers(session, handlers))

tools/perf/builtin-trace.c

4691

const struct evsel_str_handler handlers[] = {

tools/perf/builtin-trace.c

4736

err = perf_session__set_tracepoints_handlers(session, handlers);

tools/testing/selftests/kvm/include/kvm_util.h

115

vm_vaddr_t handlers;

tools/testing/selftests/kvm/lib/arm64/processor.c

506

struct handlers *handlers = (struct handlers *)exception_handlers;

tools/testing/selftests/kvm/lib/arm64/processor.c

530

if (handlers && handlers->exception_handlers[vector][ec])

tools/testing/selftests/kvm/lib/arm64/processor.c

531

return handlers->exception_handlers[vector][ec](regs);

tools/testing/selftests/kvm/lib/arm64/processor.c

539

vm->handlers = __vm_vaddr_alloc(vm, sizeof(struct handlers),

tools/testing/selftests/kvm/lib/arm64/processor.c

542

*(vm_vaddr_t *)addr_gva2hva(vm, (vm_vaddr_t)(&exception_handlers)) = vm->handlers;

tools/testing/selftests/kvm/lib/arm64/processor.c

548

struct handlers *handlers = addr_gva2hva(vm, vm->handlers);

tools/testing/selftests/kvm/lib/arm64/processor.c

553

handlers->exception_handlers[vector][ec] = handler;

tools/testing/selftests/kvm/lib/arm64/processor.c

559

struct handlers *handlers = addr_gva2hva(vm, vm->handlers);

tools/testing/selftests/kvm/lib/arm64/processor.c

563

handlers->exception_handlers[vector][0] = handler;

tools/testing/selftests/kvm/lib/loongarch/processor.c

190

struct handlers *handlers;

tools/testing/selftests/kvm/lib/loongarch/processor.c

192

handlers = (struct handlers *)exception_handlers;

tools/testing/selftests/kvm/lib/loongarch/processor.c

194

if (handlers && handlers->exception_handlers[vector])

tools/testing/selftests/kvm/lib/loongarch/processor.c

195

return handlers->exception_handlers[vector](regs);

tools/testing/selftests/kvm/lib/loongarch/processor.c

208

vm->handlers = __vm_vaddr_alloc(vm, sizeof(struct handlers),

tools/testing/selftests/kvm/lib/loongarch/processor.c

211

addr = addr_gva2hva(vm, vm->handlers);

tools/testing/selftests/kvm/lib/loongarch/processor.c

213

exception_handlers = vm->handlers;

tools/testing/selftests/kvm/lib/loongarch/processor.c

219

struct handlers *handlers = addr_gva2hva(vm, vm->handlers);

tools/testing/selftests/kvm/lib/loongarch/processor.c

222

handlers->exception_handlers[vector] = handler;

tools/testing/selftests/kvm/lib/riscv/processor.c

423

struct handlers *handlers = (struct handlers *)exception_handlers;

tools/testing/selftests/kvm/lib/riscv/processor.c

436

if (handlers && handlers->exception_handlers[vector][ec])

tools/testing/selftests/kvm/lib/riscv/processor.c

437

return handlers->exception_handlers[vector][ec](regs);

tools/testing/selftests/kvm/lib/riscv/processor.c

452

vm->handlers = __vm_vaddr_alloc(vm, sizeof(struct handlers),

tools/testing/selftests/kvm/lib/riscv/processor.c

455

*(vm_vaddr_t *)addr_gva2hva(vm, (vm_vaddr_t)(&exception_handlers)) = vm->handlers;

tools/testing/selftests/kvm/lib/riscv/processor.c

460

struct handlers *handlers = addr_gva2hva(vm, vm->handlers);

tools/testing/selftests/kvm/lib/riscv/processor.c

463

handlers->exception_handlers[0][vector] = handler;

tools/testing/selftests/kvm/lib/riscv/processor.c

468

struct handlers *handlers = addr_gva2hva(vm, vm->handlers);

tools/testing/selftests/kvm/lib/riscv/processor.c

470

handlers->exception_handlers[1][0] = handler;

tools/testing/selftests/kvm/lib/x86/processor.c

727

handler *handlers = (handler *)exception_handlers;

tools/testing/selftests/kvm/lib/x86/processor.c

729

if (handlers && handlers[regs->vector]) {

tools/testing/selftests/kvm/lib/x86/processor.c

730

handlers[regs->vector](regs);

tools/testing/selftests/kvm/lib/x86/processor.c

749

vm->handlers = __vm_vaddr_alloc_page(vm, MEM_REGION_DATA);

tools/testing/selftests/kvm/lib/x86/processor.c

756

*(vm_vaddr_t *)addr_gva2hva(vm, (vm_vaddr_t)(&exception_handlers)) = vm->handlers;

tools/testing/selftests/kvm/lib/x86/processor.c

771

vm_vaddr_t *handlers = (vm_vaddr_t *)addr_gva2hva(vm, vm->handlers);

tools/testing/selftests/kvm/lib/x86/processor.c

773

handlers[vector] = (vm_vaddr_t)handler;