perf_counter: Rename list_entry -> group_entry, counter_list -> group_list

This is in preparation of the big rename, but also makes sense
in a standalone way: 'list_entry' is a bad name as we already
have a list_entry() in list.h.

Also, the 'counter list' is too vague, it doesnt tell us the
purpose of that list.

Clarify these names to show that it's all about the group
hiearchy.

Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

2 files changed, 37 insertions, 38 deletions

diff --git a/include/linux/perf_counter.h b/include/linux/perf_counter.h
index 740caad09a44..f64862732673 100644
--- a/include/linux/perf_counter.h
+++ b/include/linux/perf_counter.h
@@ -543,7 +543,7 @@ struct perf_pending_entry {
  */
 struct perf_counter {
 #ifdef CONFIG_PERF_COUNTERS
-        struct list_head                list_entry;
+        struct list_head                group_entry;
         struct list_head                event_entry;
         struct list_head                sibling_list;
         int                             nr_siblings;
@@ -649,7 +649,7 @@ struct perf_counter_context {
          */
         struct mutex                    mutex;
 
-        struct list_head                counter_list;
+        struct list_head                group_list;
         struct list_head                event_list;
         int                             nr_counters;
         int                             nr_active;
diff --git a/kernel/perf_counter.c b/kernel/perf_counter.c
index cc768ab81ac8..13ad73aed4ca 100644
--- a/kernel/perf_counter.c
+++ b/kernel/perf_counter.c
@@ -258,9 +258,9 @@ list_add_counter(struct perf_counter *counter, struct perf_counter_context *ctx)
          * leader's sibling list:
          */
         if (group_leader == counter)
-                list_add_tail(&counter->list_entry, &ctx->counter_list);
+                list_add_tail(&counter->group_entry, &ctx->group_list);
         else {
-                list_add_tail(&counter->list_entry, &group_leader->sibling_list);
+                list_add_tail(&counter->group_entry, &group_leader->sibling_list);
                 group_leader->nr_siblings++;
         }
 
@@ -279,13 +279,13 @@ list_del_counter(struct perf_counter *counter, struct perf_counter_context *ctx)
 {
         struct perf_counter *sibling, *tmp;
 
-        if (list_empty(&counter->list_entry))
+        if (list_empty(&counter->group_entry))
                 return;
         ctx->nr_counters--;
         if (counter->attr.inherit_stat)
                 ctx->nr_stat--;
 
-        list_del_init(&counter->list_entry);
+        list_del_init(&counter->group_entry);
         list_del_rcu(&counter->event_entry);
 
         if (counter->group_leader != counter)
@@ -296,10 +296,9 @@ list_del_counter(struct perf_counter *counter, struct perf_counter_context *ctx)
          * upgrade the siblings to singleton counters by adding them
          * to the context list directly:
          */
-        list_for_each_entry_safe(sibling, tmp,
-                                 &counter->sibling_list, list_entry) {
+        list_for_each_entry_safe(sibling, tmp, &counter->sibling_list, group_entry) {
 
-                list_move_tail(&sibling->list_entry, &ctx->counter_list);
+                list_move_tail(&sibling->group_entry, &ctx->group_list);
                 sibling->group_leader = sibling;
         }
 }
@@ -343,7 +342,7 @@ group_sched_out(struct perf_counter *group_counter,
         /*
          * Schedule out siblings (if any):
          */
-        list_for_each_entry(counter, &group_counter->sibling_list, list_entry)
+        list_for_each_entry(counter, &group_counter->sibling_list, group_entry)
                 counter_sched_out(counter, cpuctx, ctx);
 
         if (group_counter->attr.exclusive)
@@ -435,7 +434,7 @@ retry:
         /*
          * If the context is active we need to retry the smp call.
          */
-        if (ctx->nr_active && !list_empty(&counter->list_entry)) {
+        if (ctx->nr_active && !list_empty(&counter->group_entry)) {
                 spin_unlock_irq(&ctx->lock);
                 goto retry;
         }
@@ -445,7 +444,7 @@ retry:
          * can remove the counter safely, if the call above did not
          * succeed.
          */
-        if (!list_empty(&counter->list_entry)) {
+        if (!list_empty(&counter->group_entry)) {
                 list_del_counter(counter, ctx);
         }
         spin_unlock_irq(&ctx->lock);
@@ -497,7 +496,7 @@ static void update_group_times(struct perf_counter *leader)
         struct perf_counter *counter;
 
         update_counter_times(leader);
-        list_for_each_entry(counter, &leader->sibling_list, list_entry)
+        list_for_each_entry(counter, &leader->sibling_list, group_entry)
                 update_counter_times(counter);
 }
 
@@ -643,7 +642,7 @@ group_sched_in(struct perf_counter *group_counter,
         /*
          * Schedule in siblings as one group (if any):
          */
-        list_for_each_entry(counter, &group_counter->sibling_list, list_entry) {
+        list_for_each_entry(counter, &group_counter->sibling_list, group_entry) {
                 if (counter_sched_in(counter, cpuctx, ctx, cpu)) {
                         partial_group = counter;
                         goto group_error;
@@ -657,7 +656,7 @@ group_error:
          * Groups can be scheduled in as one unit only, so undo any
          * partial group before returning:
          */
-        list_for_each_entry(counter, &group_counter->sibling_list, list_entry) {
+        list_for_each_entry(counter, &group_counter->sibling_list, group_entry) {
                 if (counter == partial_group)
                         break;
                 counter_sched_out(counter, cpuctx, ctx);
@@ -678,7 +677,7 @@ static int is_software_only_group(struct perf_counter *leader)
         if (!is_software_counter(leader))
                 return 0;
 
-        list_for_each_entry(counter, &leader->sibling_list, list_entry)
+        list_for_each_entry(counter, &leader->sibling_list, group_entry)
                 if (!is_software_counter(counter))
                         return 0;
 
@@ -842,7 +841,7 @@ retry:
         /*
          * we need to retry the smp call.
          */
-        if (ctx->is_active && list_empty(&counter->list_entry)) {
+        if (ctx->is_active && list_empty(&counter->group_entry)) {
                 spin_unlock_irq(&ctx->lock);
                 goto retry;
         }
@@ -852,7 +851,7 @@ retry:
          * can add the counter safely, if it the call above did not
          * succeed.
          */
-        if (list_empty(&counter->list_entry))
+        if (list_empty(&counter->group_entry))
                 add_counter_to_ctx(counter, ctx);
         spin_unlock_irq(&ctx->lock);
 }
@@ -872,7 +871,7 @@ static void __perf_counter_mark_enabled(struct perf_counter *counter,
 
         counter->state = PERF_COUNTER_STATE_INACTIVE;
         counter->tstamp_enabled = ctx->time - counter->total_time_enabled;
-        list_for_each_entry(sub, &counter->sibling_list, list_entry)
+        list_for_each_entry(sub, &counter->sibling_list, group_entry)
                 if (sub->state >= PERF_COUNTER_STATE_INACTIVE)
                         sub->tstamp_enabled =