Merge tag 'uninit-macro-v5.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git...

[linux-2.6-microblaze.git] / kernel / events / core.c

diff --git a/kernel/events/core.c b/kernel/events/core.c
index 851fc5e..78e69e1 100644 (file)
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -394,6 +394,7 @@ static atomic_t nr_switch_events __read_mostly;
 static atomic_t nr_ksymbol_events __read_mostly;
 static atomic_t nr_bpf_events __read_mostly;
 static atomic_t nr_cgroup_events __read_mostly;
+static atomic_t nr_text_poke_events __read_mostly;
 
 static LIST_HEAD(pmus);
 static DEFINE_MUTEX(pmus_lock);
@@ -1237,12 +1238,26 @@ static void get_ctx(struct perf_event_context *ctx)
        refcount_inc(&ctx->refcount);
 }
 
+static void *alloc_task_ctx_data(struct pmu *pmu)
+{
+       if (pmu->task_ctx_cache)
+               return kmem_cache_zalloc(pmu->task_ctx_cache, GFP_KERNEL);
+
+       return NULL;
+}
+
+static void free_task_ctx_data(struct pmu *pmu, void *task_ctx_data)
+{
+       if (pmu->task_ctx_cache && task_ctx_data)
+               kmem_cache_free(pmu->task_ctx_cache, task_ctx_data);
+}
+
 static void free_ctx(struct rcu_head *head)
 {
        struct perf_event_context *ctx;
 
        ctx = container_of(head, struct perf_event_context, rcu_head);
-       kfree(ctx->task_ctx_data);
+       free_task_ctx_data(ctx->pmu, ctx->task_ctx_data);
        kfree(ctx);
 }
 
@@ -4470,7 +4485,7 @@ find_get_context(struct pmu *pmu, struct task_struct *task,
                goto errout;
 
        if (event->attach_state & PERF_ATTACH_TASK_DATA) {
-               task_ctx_data = kzalloc(pmu->task_ctx_size, GFP_KERNEL);
+               task_ctx_data = alloc_task_ctx_data(pmu);
                if (!task_ctx_data) {
                        err = -ENOMEM;
                        goto errout;
@@ -4528,11 +4543,11 @@ retry:
                }
        }
 
-       kfree(task_ctx_data);
+       free_task_ctx_data(pmu, task_ctx_data);
        return ctx;
 
 errout:
-       kfree(task_ctx_data);
+       free_task_ctx_data(pmu, task_ctx_data);
        return ERR_PTR(err);
 }
 
@@ -4575,7 +4590,7 @@ static bool is_sb_event(struct perf_event *event)
        if (attr->mmap || attr->mmap_data || attr->mmap2 ||
            attr->comm || attr->comm_exec ||
            attr->task || attr->ksymbol ||
-           attr->context_switch ||
+           attr->context_switch || attr->text_poke ||
            attr->bpf_event)
                return true;
        return false;
@@ -4651,6 +4666,8 @@ static void unaccount_event(struct perf_event *event)
                atomic_dec(&nr_ksymbol_events);
        if (event->attr.bpf_event)
                atomic_dec(&nr_bpf_events);
+       if (event->attr.text_poke)
+               atomic_dec(&nr_text_poke_events);
 
        if (dec) {
                if (!atomic_add_unless(&perf_sched_count, -1, 1))
@@ -8628,6 +8645,89 @@ void perf_event_bpf_event(struct bpf_prog *prog,
        perf_iterate_sb(perf_event_bpf_output, &bpf_event, NULL);
 }
 
+struct perf_text_poke_event {
+       const void              *old_bytes;
+       const void              *new_bytes;
+       size_t                  pad;
+       u16                     old_len;
+       u16                     new_len;
+
+       struct {
+               struct perf_event_header        header;
+
+               u64                             addr;
+       } event_id;
+};
+
+static int perf_event_text_poke_match(struct perf_event *event)
+{
+       return event->attr.text_poke;
+}
+
+static void perf_event_text_poke_output(struct perf_event *event, void *data)
+{
+       struct perf_text_poke_event *text_poke_event = data;
+       struct perf_output_handle handle;
+       struct perf_sample_data sample;
+       u64 padding = 0;
+       int ret;
+
+       if (!perf_event_text_poke_match(event))
+               return;
+
+       perf_event_header__init_id(&text_poke_event->event_id.header, &sample, event);
+
+       ret = perf_output_begin(&handle, event, text_poke_event->event_id.header.size);
+       if (ret)
+               return;
+
+       perf_output_put(&handle, text_poke_event->event_id);
+       perf_output_put(&handle, text_poke_event->old_len);
+       perf_output_put(&handle, text_poke_event->new_len);
+
+       __output_copy(&handle, text_poke_event->old_bytes, text_poke_event->old_len);
+       __output_copy(&handle, text_poke_event->new_bytes, text_poke_event->new_len);
+
+       if (text_poke_event->pad)
+               __output_copy(&handle, &padding, text_poke_event->pad);
+
+       perf_event__output_id_sample(event, &handle, &sample);
+
+       perf_output_end(&handle);
+}
+
+void perf_event_text_poke(const void *addr, const void *old_bytes,
+                         size_t old_len, const void *new_bytes, size_t new_len)
+{
+       struct perf_text_poke_event text_poke_event;
+       size_t tot, pad;
+
+       if (!atomic_read(&nr_text_poke_events))
+               return;
+
+       tot  = sizeof(text_poke_event.old_len) + old_len;
+       tot += sizeof(text_poke_event.new_len) + new_len;
+       pad  = ALIGN(tot, sizeof(u64)) - tot;
+
+       text_poke_event = (struct perf_text_poke_event){
+               .old_bytes    = old_bytes,
+               .new_bytes    = new_bytes,
+               .pad          = pad,
+               .old_len      = old_len,
+               .new_len      = new_len,
+               .event_id  = {
+                       .header = {
+                               .type = PERF_RECORD_TEXT_POKE,
+                               .misc = PERF_RECORD_MISC_KERNEL,
+                               .size = sizeof(text_poke_event.event_id) + tot + pad,
+                       },
+                       .addr = (unsigned long)addr,
+               },
+       };
+
+       perf_iterate_sb(perf_event_text_poke_output, &text_poke_event, NULL);
+}
+
 void perf_event_itrace_started(struct perf_event *event)
 {
        event->attach_state |= PERF_ATTACH_ITRACE;
@@ -10945,6 +11045,8 @@ static void account_event(struct perf_event *event)
                atomic_inc(&nr_ksymbol_events);
        if (event->attr.bpf_event)
                atomic_inc(&nr_bpf_events);
+       if (event->attr.text_poke)
+               atomic_inc(&nr_text_poke_events);
 
        if (inc) {
                /*
@@ -12409,8 +12511,7 @@ inherit_event(struct perf_event *parent_event,
            !child_ctx->task_ctx_data) {
                struct pmu *pmu = child_event->pmu;
 
-               child_ctx->task_ctx_data = kzalloc(pmu->task_ctx_size,
-                                                  GFP_KERNEL);
+               child_ctx->task_ctx_data = alloc_task_ctx_data(pmu);
                if (!child_ctx->task_ctx_data) {
                        free_event(child_event);
                        return ERR_PTR(-ENOMEM);