Merge branch 'perf/urgent' into perf/core

[linux-2.6-microblaze.git] / tools / perf / util / metricgroup.c

diff --git a/tools/perf/util/metricgroup.c b/tools/perf/util/metricgroup.c
index d948a7f..060454a 100644 (file)
--- a/tools/perf/util/metricgroup.c
+++ b/tools/perf/util/metricgroup.c
@@ -15,7 +15,6 @@
 #include "rblist.h"
 #include <string.h>
 #include <errno.h>
-#include "pmu-events/pmu-events.h"
 #include "strlist.h"
 #include <assert.h>
 #include <linux/ctype.h>
@@ -25,6 +24,7 @@
 #include <api/fs/fs.h>
 #include "util.h"
 #include <asm/bug.h>
+#include "cgroup.h"
 
 struct metric_event *metricgroup__lookup(struct rblist *metric_events,
                                         struct evsel *evsel,
@@ -163,7 +163,7 @@ static bool contains_event(struct evsel **metric_events, int num_events,
 }
 
 /**
- * Find a group of events in perf_evlist that correpond to those from a parsed
+ * Find a group of events in perf_evlist that correspond to those from a parsed
  * metric expression. Note, as find_evsel_group is called in the same order as
  * perf_evlist was constructed, metric_no_merge doesn't need to test for
  * underfilling a group.
@@ -577,10 +577,12 @@ void metricgroup__print(bool metrics, bool metricgroups, char *filter,
                }
        }
 
-       if (metricgroups && !raw)
-               printf("\nMetric Groups:\n\n");
-       else if (metrics && !raw)
-               printf("\nMetrics:\n\n");
+       if (!filter || !rblist__empty(&groups)) {
+               if (metricgroups && !raw)
+                       printf("\nMetric Groups:\n\n");
+               else if (metrics && !raw)
+                       printf("\nMetrics:\n\n");
+       }
 
        for (node = rb_first_cached(&groups.entries); node; node = next) {
                struct mep *me = container_of(node, struct mep, nd);
@@ -676,7 +678,7 @@ static bool metricgroup__has_constraint(struct pmu_event *pe)
        return false;
 }
 
-int __weak arch_get_runtimeparam(void)
+int __weak arch_get_runtimeparam(struct pmu_event *pe __maybe_unused)
 {
        return 1;
 }
@@ -947,7 +949,7 @@ static int add_metric(struct list_head *metric_list,
        } else {
                int j, count;
 
-               count = arch_get_runtimeparam();
+               count = arch_get_runtimeparam(pe);
 
                /* This loop is added to create multiple
                 * events depend on count value and add
@@ -1156,3 +1158,87 @@ bool metricgroup__has_metric(const char *metric)
        }
        return false;
 }
+
+int metricgroup__copy_metric_events(struct evlist *evlist, struct cgroup *cgrp,
+                                   struct rblist *new_metric_events,
+                                   struct rblist *old_metric_events)
+{
+       unsigned i;
+
+       for (i = 0; i < rblist__nr_entries(old_metric_events); i++) {
+               struct rb_node *nd;
+               struct metric_event *old_me, *new_me;
+               struct metric_expr *old_expr, *new_expr;
+               struct evsel *evsel;
+               size_t alloc_size;
+               int idx, nr;
+
+               nd = rblist__entry(old_metric_events, i);
+               old_me = container_of(nd, struct metric_event, nd);
+
+               evsel = evlist__find_evsel(evlist, old_me->evsel->idx);
+               if (!evsel)
+                       return -EINVAL;
+               new_me = metricgroup__lookup(new_metric_events, evsel, true);
+               if (!new_me)
+                       return -ENOMEM;
+
+               pr_debug("copying metric event for cgroup '%s': %s (idx=%d)\n",
+                        cgrp ? cgrp->name : "root", evsel->name, evsel->idx);
+
+               list_for_each_entry(old_expr, &old_me->head, nd) {
+                       new_expr = malloc(sizeof(*new_expr));
+                       if (!new_expr)
+                               return -ENOMEM;
+
+                       new_expr->metric_expr = old_expr->metric_expr;
+                       new_expr->metric_name = old_expr->metric_name;
+                       new_expr->metric_unit = old_expr->metric_unit;
+                       new_expr->runtime = old_expr->runtime;
+
+                       if (old_expr->metric_refs) {
+                               /* calculate number of metric_events */
+                               for (nr = 0; old_expr->metric_refs[nr].metric_name; nr++)
+                                       continue;
+                               alloc_size = sizeof(*new_expr->metric_refs);
+                               new_expr->metric_refs = calloc(nr + 1, alloc_size);
+                               if (!new_expr->metric_refs) {
+                                       free(new_expr);
+                                       return -ENOMEM;
+                               }
+
+                               memcpy(new_expr->metric_refs, old_expr->metric_refs,
+                                      nr * alloc_size);
+                       } else {
+                               new_expr->metric_refs = NULL;
+                       }
+
+                       /* calculate number of metric_events */
+                       for (nr = 0; old_expr->metric_events[nr]; nr++)
+                               continue;
+                       alloc_size = sizeof(*new_expr->metric_events);
+                       new_expr->metric_events = calloc(nr + 1, alloc_size);
+                       if (!new_expr->metric_events) {
+                               free(new_expr->metric_refs);
+                               free(new_expr);
+                               return -ENOMEM;
+                       }
+
+                       /* copy evsel in the same position */
+                       for (idx = 0; idx < nr; idx++) {
+                               evsel = old_expr->metric_events[idx];
+                               evsel = evlist__find_evsel(evlist, evsel->idx);
+                               if (evsel == NULL) {
+                                       free(new_expr->metric_events);
+                                       free(new_expr->metric_refs);
+                                       free(new_expr);
+                                       return -EINVAL;
+                               }
+                               new_expr->metric_events[idx] = evsel;
+                       }
+
+                       list_add(&new_expr->nd, &new_me->head);
+               }
+       }
+       return 0;
+}