enum perf_event_task_context {perf_invalid_context = -1,perf_hw_context = 0,perf_sw_context,perf_nr_task_contexts,};

    struct pmu {...struct perf_cpu_context __percpu *pmu_cpu_context;};

   int perf_pmu_register(struct pmu *pmu, const char *name, int type){int cpu, ret, max = PERF_TYPE_MAX;mutex_lock(&pmus_lock);...pmu->pmu_cpu_context = find_pmu_context(pmu->task_ctx_nr);if (pmu->pmu_cpu_context)goto got_cpu_context;ret = -ENOMEM;pmu->pmu_cpu_context = alloc_percpu(struct perf_cpu_context);if (!pmu->pmu_cpu_context)goto free_dev;for_each_possible_cpu(cpu) {struct perf_cpu_context *cpuctx;cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);__perf_event_init_context(&cpuctx->ctx);lockdep_set_class(&cpuctx->ctx.mutex, &cpuctx_mutex);lockdep_set_class(&cpuctx->ctx.lock, &cpuctx_lock);cpuctx->ctx.pmu = pmu;cpuctx->online = cpumask_test_cpu(cpu, perf_online_mask);__perf_mux_hrtimer_init(cpuctx, cpu);cpuctx->heap_size = ARRAY_SIZE(cpuctx->heap_default);cpuctx->heap = cpuctx->heap_default;}...}

    struct task_struct {struct perf_event_context    *perf_event_ctxp[perf_nr_task_contexts];};

    static struct pmu perf_tracepoint = {.task_ctx_nr   = perf_sw_context,.event_init  = perf_tp_event_init,.add      = perf_trace_add,.del      = perf_trace_del,.start        = perf_swevent_start,.stop     = perf_swevent_stop,.read      = perf_swevent_read,};

perf_tp_event_init->perf_trace_init->perf_trace_event_init->perf_trace_event_reg->tp_event->class->reg(TRACE_REG_PERF_REGISTER)

static int perf_trace_event_reg(struct trace_event_call *tp_event,struct perf_event *p_event)
{struct hlist_head __percpu *list;int ret = -ENOMEM;int cpu;p_event->tp_event = tp_event;if (tp_event->perf_refcount++ > 0)return 0;list = alloc_percpu(struct hlist_head);if (!list)goto fail;for_each_possible_cpu(cpu)INIT_HLIST_HEAD(per_cpu_ptr(list, cpu));tp_event->perf_events = list;...ret = tp_event->class->reg(tp_event, TRACE_REG_PERF_REGISTER, NULL);if (ret)goto fail;total_ref_count++;return 0;...
}

   int trace_event_reg(struct trace_event_call *call,enum trace_reg type, void *data){struct trace_event_file *file = data;WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT));switch (type) {...#ifdef CONFIG_PERF_EVENTScase TRACE_REG_PERF_REGISTER:return tracepoint_probe_register(call->tp,call->class->perf_probe,call);case TRACE_REG_PERF_UNREGISTER:tracepoint_probe_unregister(call->tp,call->class->perf_probe,call);return 0;case TRACE_REG_PERF_OPEN:case TRACE_REG_PERF_CLOSE:case TRACE_REG_PERF_ADD:case TRACE_REG_PERF_DEL:return 0;#endif}return 0;}

   static notrace void                           \perf_trace_##call(void *__data, proto)                 \{                                  \struct trace_event_call *event_call = __data;         \struct trace_event_data_offsets_##call __maybe_unused __data_offsets;\struct trace_event_raw_##call *entry;                \struct pt_regs *__regs;                        \u64 __count = 1;                      \struct task_struct *__task = NULL;                \struct hlist_head *head;                   \int __entry_size;                      \int __data_size;                       \int rctx;                          \\__data_size = trace_event_get_offsets_##call(&__data_offsets, args); \\head = this_cpu_ptr(event_call->perf_events);         \if (!bpf_prog_array_valid(event_call) &&           \__builtin_constant_p(!__task) && !__task &&            \hlist_empty(head))                     \return;                            \\__entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\sizeof(u64));             \__entry_size -= sizeof(u32);                  \\entry = perf_trace_buf_alloc(__entry_size, &__regs, &rctx);  \if (!entry)                            \return;                            \\perf_fetch_caller_regs(__regs);                   \\tstruct                               \\{ assign; }                           \\perf_trace_run_bpf_submit(entry, __entry_size, rctx,      \event_call, __count, __regs,       \head, __task);         \}

    void perf_tp_event(u16 event_type, u64 count, void *record, int entry_size,struct pt_regs *regs, struct hlist_head *head, int rctx,struct task_struct *task){struct perf_sample_data data;struct perf_event *event;struct perf_raw_record raw = {.frag = {.size = entry_size,.data = record,},};perf_sample_data_init(&data, 0, 0);data.raw = &raw;perf_trace_buf_update(record, event_type);hlist_for_each_entry_rcu(event, head, hlist_entry) {if (perf_tp_event_match(event, &data, regs))perf_swevent_event(event, count, &data, regs);}...perf_swevent_put_recursion_context(rctx);}

   static void perf_swevent_event(struct perf_event *event, u64 nr,struct perf_sample_data *data,struct pt_regs *regs){struct hw_perf_event *hwc = &event->hw;local64_add(nr, &event->count);if (!regs)return;if (!is_sampling_event(event))return;if ((event->attr.sample_type & PERF_SAMPLE_PERIOD) && !event->attr.freq) {data->period = nr;return perf_swevent_overflow(event, 1, data, regs);} elsedata->period = event->hw.last_period;if (nr == 1 && hwc->sample_period == 1 && !event->attr.freq)return perf_swevent_overflow(event, 1, data, regs);if (local64_add_negative(nr, &hwc->period_left))return;perf_swevent_overflow(event, 0, data, regs);}

perf_swevent_overflow->__perf_event_overflow->event->overflow_handler(perf_event_output).

    static struct pmu perf_swevent = {.task_ctx_nr  = perf_sw_context,.capabilities    = PERF_PMU_CAP_NO_NMI,.event_init  = perf_swevent_init,.add       = perf_swevent_add,.del        = perf_swevent_del,.start      = perf_swevent_start,.stop     = perf_swevent_stop,.read      = perf_swevent_read,};

    static int perf_swevent_init(struct perf_event *event){u64 event_id = event->attr.config;if (event->attr.type != PERF_TYPE_SOFTWARE)return -ENOENT;/** no branch sampling for software events*/if (has_branch_stack(event))return -EOPNOTSUPP;switch (event_id) {case PERF_COUNT_SW_CPU_CLOCK:case PERF_COUNT_SW_TASK_CLOCK:return -ENOENT;default:break;}if (event_id >= PERF_COUNT_SW_MAX)return -ENOENT;if (!event->parent) {int err;err = swevent_hlist_get();if (err)return err;static_key_slow_inc(&perf_swevent_enabled[event_id]);event->destroy = sw_perf_event_destroy;}return 0;}

    static int perf_swevent_add(struct perf_event *event, int flags){struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);struct hw_perf_event *hwc = &event->hw;struct hlist_head *head;if (is_sampling_event(event)) {hwc->last_period = hwc->sample_period;perf_swevent_set_period(event);}hwc->state = !(flags & PERF_EF_START);head = find_swevent_head(swhash, event);if (WARN_ON_ONCE(!head))return -EINVAL;hlist_add_head_rcu(&event->hlist_entry, head);perf_event_update_userpage(event);return 0;}

    static void perf_swevent_del(struct perf_event *event, int flags){hlist_del_rcu(&event->hlist_entry);}

    static inline void perf_event_task_sched_out(struct task_struct *prev,struct task_struct *next){perf_sw_event_sched(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 0);if (static_branch_unlikely(&perf_sched_events))__perf_event_task_sched_out(prev, next);}

    static void do_perf_sw_event(enum perf_type_id type, u32 event_id,u64 nr,struct perf_sample_data *data,struct pt_regs *regs){struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);struct perf_event *event;struct hlist_head *head;rcu_read_lock();head = find_swevent_head_rcu(swhash, type, event_id);if (!head)goto end;hlist_for_each_entry_rcu(event, head, hlist_entry) {if (perf_swevent_match(event, type, event_id, data, regs))perf_swevent_event(event, nr, data, regs);}end:rcu_read_unlock();}

    static struct pmu pmu = {.pmu_enable        = x86_pmu_enable,.pmu_disable      = x86_pmu_disable,.attr_groups     = x86_pmu_attr_groups,.event_init      = x86_pmu_event_init,.event_mapped     = x86_pmu_event_mapped,.event_unmapped     = x86_pmu_event_unmapped,.add          = x86_pmu_add,.del         = x86_pmu_del,.start           = x86_pmu_start,.stop          = x86_pmu_stop,.read           = x86_pmu_read,.start_txn      = x86_pmu_start_txn,.cancel_txn        = x86_pmu_cancel_txn,.commit_txn       = x86_pmu_commit_txn,.event_idx        = x86_pmu_event_idx,.sched_task        = x86_pmu_sched_task,.task_ctx_size          = sizeof(struct x86_perf_task_context),.swap_task_ctx        = x86_pmu_swap_task_ctx,.check_period      = x86_pmu_check_period,.aux_output_match   = x86_pmu_aux_output_match,};

    x86_pmu_event_init->__x86_pmu_event_init->x86_reserve_hardware->x86_pmu.hw_config()->validate_event

    cpuc->event_list[n] = leader;

   static intperf_event_nmi_handler(unsigned int cmd, struct pt_regs *regs){u64 start_clock;u64 finish_clock;int ret;/** All PMUs/events that share this PMI handler should make sure to* increment active_events for their events.*/if (!atomic_read(&active_events))return NMI_DONE;start_clock = sched_clock();ret = x86_pmu.handle_irq(regs);finish_clock = sched_clock();perf_sample_event_took(finish_clock - start_clock);return ret;}

    for (idx = 0; idx < x86_pmu.num_counters; idx++) {if (!test_bit(idx, cpuc->active_mask))continue;event = cpuc->events[idx];val = x86_perf_event_update(event);if (val & (1ULL << (x86_pmu.cntval_bits - 1)))continue;/** event overflow*/handled++;perf_sample_data_init(&data, 0, event->hw.last_period);if (!x86_perf_event_set_period(event))continue;if (perf_event_overflow(event, &data, regs))x86_pmu_stop(event, 0);}