Commit ab93eb82 authored by Linus Torvalds's avatar Linus Torvalds

Merge branches 'core-urgent-for-linus', 'perf-urgent-for-linus' and...

Merge branches 'core-urgent-for-linus', 'perf-urgent-for-linus' and 'sched-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull RCU, perf, and scheduler fixes from Ingo Molnar.

The RCU fix is a revert for an optimization that could cause deadlocks.

One of the scheduler commits (164c33c6 "sched: Fix fork() error path
to not crash") is correct but not complete (some architectures like Tile
are not covered yet) - the resulting additional fixes are still WIP and
Ingo did not want to delay these pending fixes.  See this thread on
lkml:

  [PATCH] fork: fix error handling in dup_task()

The perf fixes are just trivial oneliners.

* 'core-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  Revert "rcu: Move PREEMPT_RCU preemption to switch_to() invocation"

* 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  perf kvm: Fix segfault with report and mixed guestmount use
  perf kvm: Fix regression with guest machine creation
  perf script: Fix format regression due to libtraceevent merge
  ring-buffer: Fix accounting of entries when removing pages
  ring-buffer: Fix crash due to uninitialized new_pages list head

* 'sched-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  MAINTAINERS/sched: Update scheduler file pattern
  sched/nohz: Rewrite and fix load-avg computation -- again
  sched: Fix fork() error path to not crash
...@@ -5910,7 +5910,7 @@ M: Ingo Molnar <mingo@redhat.com> ...@@ -5910,7 +5910,7 @@ M: Ingo Molnar <mingo@redhat.com>
M: Peter Zijlstra <peterz@infradead.org> M: Peter Zijlstra <peterz@infradead.org>
T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git sched/core T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git sched/core
S: Maintained S: Maintained
F: kernel/sched* F: kernel/sched/
F: include/linux/sched.h F: include/linux/sched.h
SCORE ARCHITECTURE SCORE ARCHITECTURE
......
...@@ -705,7 +705,6 @@ static void stack_proc(void *arg) ...@@ -705,7 +705,6 @@ static void stack_proc(void *arg)
struct task_struct *from = current, *to = arg; struct task_struct *from = current, *to = arg;
to->thread.saved_task = from; to->thread.saved_task = from;
rcu_switch_from(from);
switch_to(from, to, from); switch_to(from, to, from);
} }
......
...@@ -184,7 +184,6 @@ static inline int rcu_preempt_depth(void) ...@@ -184,7 +184,6 @@ static inline int rcu_preempt_depth(void)
/* Internal to kernel */ /* Internal to kernel */
extern void rcu_sched_qs(int cpu); extern void rcu_sched_qs(int cpu);
extern void rcu_bh_qs(int cpu); extern void rcu_bh_qs(int cpu);
extern void rcu_preempt_note_context_switch(void);
extern void rcu_check_callbacks(int cpu, int user); extern void rcu_check_callbacks(int cpu, int user);
struct notifier_block; struct notifier_block;
extern void rcu_idle_enter(void); extern void rcu_idle_enter(void);
......
...@@ -87,6 +87,10 @@ static inline void kfree_call_rcu(struct rcu_head *head, ...@@ -87,6 +87,10 @@ static inline void kfree_call_rcu(struct rcu_head *head,
#ifdef CONFIG_TINY_RCU #ifdef CONFIG_TINY_RCU
static inline void rcu_preempt_note_context_switch(void)
{
}
static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies) static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
{ {
*delta_jiffies = ULONG_MAX; *delta_jiffies = ULONG_MAX;
...@@ -95,6 +99,7 @@ static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies) ...@@ -95,6 +99,7 @@ static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
#else /* #ifdef CONFIG_TINY_RCU */ #else /* #ifdef CONFIG_TINY_RCU */
void rcu_preempt_note_context_switch(void);
int rcu_preempt_needs_cpu(void); int rcu_preempt_needs_cpu(void);
static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies) static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
...@@ -108,6 +113,7 @@ static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies) ...@@ -108,6 +113,7 @@ static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
static inline void rcu_note_context_switch(int cpu) static inline void rcu_note_context_switch(int cpu)
{ {
rcu_sched_qs(cpu); rcu_sched_qs(cpu);
rcu_preempt_note_context_switch();
} }
/* /*
......
...@@ -1871,22 +1871,12 @@ static inline void rcu_copy_process(struct task_struct *p) ...@@ -1871,22 +1871,12 @@ static inline void rcu_copy_process(struct task_struct *p)
INIT_LIST_HEAD(&p->rcu_node_entry); INIT_LIST_HEAD(&p->rcu_node_entry);
} }
static inline void rcu_switch_from(struct task_struct *prev)
{
if (prev->rcu_read_lock_nesting != 0)
rcu_preempt_note_context_switch();
}
#else #else
static inline void rcu_copy_process(struct task_struct *p) static inline void rcu_copy_process(struct task_struct *p)
{ {
} }
static inline void rcu_switch_from(struct task_struct *prev)
{
}
#endif #endif
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
...@@ -1909,6 +1899,14 @@ static inline int set_cpus_allowed_ptr(struct task_struct *p, ...@@ -1909,6 +1899,14 @@ static inline int set_cpus_allowed_ptr(struct task_struct *p,
} }
#endif #endif
#ifdef CONFIG_NO_HZ
void calc_load_enter_idle(void);
void calc_load_exit_idle(void);
#else
static inline void calc_load_enter_idle(void) { }
static inline void calc_load_exit_idle(void) { }
#endif /* CONFIG_NO_HZ */
#ifndef CONFIG_CPUMASK_OFFSTACK #ifndef CONFIG_CPUMASK_OFFSTACK
static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask) static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
{ {
......
...@@ -304,12 +304,17 @@ static struct task_struct *dup_task_struct(struct task_struct *orig) ...@@ -304,12 +304,17 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)
} }
err = arch_dup_task_struct(tsk, orig); err = arch_dup_task_struct(tsk, orig);
if (err)
goto out;
/*
* We defer looking at err, because we will need this setup
* for the clean up path to work correctly.
*/
tsk->stack = ti; tsk->stack = ti;
setup_thread_stack(tsk, orig); setup_thread_stack(tsk, orig);
if (err)
goto out;
clear_user_return_notifier(tsk); clear_user_return_notifier(tsk);
clear_tsk_need_resched(tsk); clear_tsk_need_resched(tsk);
stackend = end_of_stack(tsk); stackend = end_of_stack(tsk);
......
...@@ -201,6 +201,7 @@ void rcu_note_context_switch(int cpu) ...@@ -201,6 +201,7 @@ void rcu_note_context_switch(int cpu)
{ {
trace_rcu_utilization("Start context switch"); trace_rcu_utilization("Start context switch");
rcu_sched_qs(cpu); rcu_sched_qs(cpu);
rcu_preempt_note_context_switch(cpu);
trace_rcu_utilization("End context switch"); trace_rcu_utilization("End context switch");
} }
EXPORT_SYMBOL_GPL(rcu_note_context_switch); EXPORT_SYMBOL_GPL(rcu_note_context_switch);
......
...@@ -444,6 +444,7 @@ DECLARE_PER_CPU(char, rcu_cpu_has_work); ...@@ -444,6 +444,7 @@ DECLARE_PER_CPU(char, rcu_cpu_has_work);
/* Forward declarations for rcutree_plugin.h */ /* Forward declarations for rcutree_plugin.h */
static void rcu_bootup_announce(void); static void rcu_bootup_announce(void);
long rcu_batches_completed(void); long rcu_batches_completed(void);
static void rcu_preempt_note_context_switch(int cpu);
static int rcu_preempt_blocked_readers_cgp(struct rcu_node *rnp); static int rcu_preempt_blocked_readers_cgp(struct rcu_node *rnp);
#ifdef CONFIG_HOTPLUG_CPU #ifdef CONFIG_HOTPLUG_CPU
static void rcu_report_unblock_qs_rnp(struct rcu_node *rnp, static void rcu_report_unblock_qs_rnp(struct rcu_node *rnp,
......
...@@ -153,7 +153,7 @@ static void rcu_preempt_qs(int cpu) ...@@ -153,7 +153,7 @@ static void rcu_preempt_qs(int cpu)
* *
* Caller must disable preemption. * Caller must disable preemption.
*/ */
void rcu_preempt_note_context_switch(void) static void rcu_preempt_note_context_switch(int cpu)
{ {
struct task_struct *t = current; struct task_struct *t = current;
unsigned long flags; unsigned long flags;
...@@ -164,7 +164,7 @@ void rcu_preempt_note_context_switch(void) ...@@ -164,7 +164,7 @@ void rcu_preempt_note_context_switch(void)
(t->rcu_read_unlock_special & RCU_READ_UNLOCK_BLOCKED) == 0) { (t->rcu_read_unlock_special & RCU_READ_UNLOCK_BLOCKED) == 0) {
/* Possibly blocking in an RCU read-side critical section. */ /* Possibly blocking in an RCU read-side critical section. */
rdp = __this_cpu_ptr(rcu_preempt_state.rda); rdp = per_cpu_ptr(rcu_preempt_state.rda, cpu);
rnp = rdp->mynode; rnp = rdp->mynode;
raw_spin_lock_irqsave(&rnp->lock, flags); raw_spin_lock_irqsave(&rnp->lock, flags);
t->rcu_read_unlock_special |= RCU_READ_UNLOCK_BLOCKED; t->rcu_read_unlock_special |= RCU_READ_UNLOCK_BLOCKED;
...@@ -228,7 +228,7 @@ void rcu_preempt_note_context_switch(void) ...@@ -228,7 +228,7 @@ void rcu_preempt_note_context_switch(void)
* means that we continue to block the current grace period. * means that we continue to block the current grace period.
*/ */
local_irq_save(flags); local_irq_save(flags);
rcu_preempt_qs(smp_processor_id()); rcu_preempt_qs(cpu);
local_irq_restore(flags); local_irq_restore(flags);
} }
...@@ -1001,6 +1001,14 @@ void rcu_force_quiescent_state(void) ...@@ -1001,6 +1001,14 @@ void rcu_force_quiescent_state(void)
} }
EXPORT_SYMBOL_GPL(rcu_force_quiescent_state); EXPORT_SYMBOL_GPL(rcu_force_quiescent_state);
/*
* Because preemptible RCU does not exist, we never have to check for
* CPUs being in quiescent states.
*/
static void rcu_preempt_note_context_switch(int cpu)
{
}
/* /*
* Because preemptible RCU does not exist, there are never any preempted * Because preemptible RCU does not exist, there are never any preempted
* RCU readers. * RCU readers.
......
...@@ -2081,7 +2081,6 @@ context_switch(struct rq *rq, struct task_struct *prev, ...@@ -2081,7 +2081,6 @@ context_switch(struct rq *rq, struct task_struct *prev,
#endif #endif
/* Here we just switch the register state and the stack. */ /* Here we just switch the register state and the stack. */
rcu_switch_from(prev);
switch_to(prev, next, prev); switch_to(prev, next, prev);
barrier(); barrier();
...@@ -2161,11 +2160,73 @@ unsigned long this_cpu_load(void) ...@@ -2161,11 +2160,73 @@ unsigned long this_cpu_load(void)
} }
/*
* Global load-average calculations
*
* We take a distributed and async approach to calculating the global load-avg
* in order to minimize overhead.
*
* The global load average is an exponentially decaying average of nr_running +
* nr_uninterruptible.
*
* Once every LOAD_FREQ:
*
* nr_active = 0;
* for_each_possible_cpu(cpu)
* nr_active += cpu_of(cpu)->nr_running + cpu_of(cpu)->nr_uninterruptible;
*
* avenrun[n] = avenrun[0] * exp_n + nr_active * (1 - exp_n)
*
* Due to a number of reasons the above turns in the mess below:
*
* - for_each_possible_cpu() is prohibitively expensive on machines with
* serious number of cpus, therefore we need to take a distributed approach
* to calculating nr_active.
*
* \Sum_i x_i(t) = \Sum_i x_i(t) - x_i(t_0) | x_i(t_0) := 0
* = \Sum_i { \Sum_j=1 x_i(t_j) - x_i(t_j-1) }
*
* So assuming nr_active := 0 when we start out -- true per definition, we
* can simply take per-cpu deltas and fold those into a global accumulate
* to obtain the same result. See calc_load_fold_active().
*
* Furthermore, in order to avoid synchronizing all per-cpu delta folding
* across the machine, we assume 10 ticks is sufficient time for every
* cpu to have completed this task.
*
* This places an upper-bound on the IRQ-off latency of the machine. Then
* again, being late doesn't loose the delta, just wrecks the sample.
*
* - cpu_rq()->nr_uninterruptible isn't accurately tracked per-cpu because
* this would add another cross-cpu cacheline miss and atomic operation
* to the wakeup path. Instead we increment on whatever cpu the task ran
* when it went into uninterruptible state and decrement on whatever cpu
* did the wakeup. This means that only the sum of nr_uninterruptible over
* all cpus yields the correct result.
*
* This covers the NO_HZ=n code, for extra head-aches, see the comment below.
*/
/* Variables and functions for calc_load */ /* Variables and functions for calc_load */
static atomic_long_t calc_load_tasks; static atomic_long_t calc_load_tasks;
static unsigned long calc_load_update; static unsigned long calc_load_update;
unsigned long avenrun[3]; unsigned long avenrun[3];
EXPORT_SYMBOL(avenrun); EXPORT_SYMBOL(avenrun); /* should be removed */
/**
* get_avenrun - get the load average array
* @loads: pointer to dest load array
* @offset: offset to add
* @shift: shift count to shift the result left
*
* These values are estimates at best, so no need for locking.
*/
void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
{
loads[0] = (avenrun[0] + offset) << shift;
loads[1] = (avenrun[1] + offset) << shift;
loads[2] = (avenrun[2] + offset) << shift;
}
static long calc_load_fold_active(struct rq *this_rq) static long calc_load_fold_active(struct rq *this_rq)
{ {
...@@ -2182,6 +2243,9 @@ static long calc_load_fold_active(struct rq *this_rq) ...@@ -2182,6 +2243,9 @@ static long calc_load_fold_active(struct rq *this_rq)
return delta; return delta;
} }
/*
* a1 = a0 * e + a * (1 - e)
*/
static unsigned long static unsigned long
calc_load(unsigned long load, unsigned long exp, unsigned long active) calc_load(unsigned long load, unsigned long exp, unsigned long active)
{ {
...@@ -2193,30 +2257,118 @@ calc_load(unsigned long load, unsigned long exp, unsigned long active) ...@@ -2193,30 +2257,118 @@ calc_load(unsigned long load, unsigned long exp, unsigned long active)
#ifdef CONFIG_NO_HZ #ifdef CONFIG_NO_HZ
/* /*
* For NO_HZ we delay the active fold to the next LOAD_FREQ update. * Handle NO_HZ for the global load-average.
*
* Since the above described distributed algorithm to compute the global
* load-average relies on per-cpu sampling from the tick, it is affected by
* NO_HZ.
*
* The basic idea is to fold the nr_active delta into a global idle-delta upon
* entering NO_HZ state such that we can include this as an 'extra' cpu delta
* when we read the global state.
*
* Obviously reality has to ruin such a delightfully simple scheme:
*
* - When we go NO_HZ idle during the window, we can negate our sample
* contribution, causing under-accounting.
*
* We avoid this by keeping two idle-delta counters and flipping them
* when the window starts, thus separating old and new NO_HZ load.
*
* The only trick is the slight shift in index flip for read vs write.
*
* 0s 5s 10s 15s
* +10 +10 +10 +10
* |-|-----------|-|-----------|-|-----------|-|
* r:0 0 1 1 0 0 1 1 0
* w:0 1 1 0 0 1 1 0 0
*
* This ensures we'll fold the old idle contribution in this window while
* accumlating the new one.
*
* - When we wake up from NO_HZ idle during the window, we push up our
* contribution, since we effectively move our sample point to a known
* busy state.
*
* This is solved by pushing the window forward, and thus skipping the
* sample, for this cpu (effectively using the idle-delta for this cpu which
* was in effect at the time the window opened). This also solves the issue
* of having to deal with a cpu having been in NOHZ idle for multiple
* LOAD_FREQ intervals.
* *
* When making the ILB scale, we should try to pull this in as well. * When making the ILB scale, we should try to pull this in as well.
*/ */
static atomic_long_t calc_load_tasks_idle; static atomic_long_t calc_load_idle[2];
static int calc_load_idx;
static inline int calc_load_write_idx(void)
{
int idx = calc_load_idx;
/*
* See calc_global_nohz(), if we observe the new index, we also
* need to observe the new update time.
*/
smp_rmb();
/*
* If the folding window started, make sure we start writing in the
* next idle-delta.
*/
if (!time_before(jiffies, calc_load_update))
idx++;
return idx & 1;
}
static inline int calc_load_read_idx(void)
{
return calc_load_idx & 1;
}
void calc_load_account_idle(struct rq *this_rq) void calc_load_enter_idle(void)
{ {
struct rq *this_rq = this_rq();
long delta; long delta;
/*
* We're going into NOHZ mode, if there's any pending delta, fold it
* into the pending idle delta.
*/
delta = calc_load_fold_active(this_rq); delta = calc_load_fold_active(this_rq);
if (delta) if (delta) {
atomic_long_add(delta, &calc_load_tasks_idle); int idx = calc_load_write_idx();
atomic_long_add(delta, &calc_load_idle[idx]);
}
} }
static long calc_load_fold_idle(void) void calc_load_exit_idle(void)
{ {
long delta = 0; struct rq *this_rq = this_rq();
/*
* If we're still before the sample window, we're done.
*/
if (time_before(jiffies, this_rq->calc_load_update))
return;
/* /*
* Its got a race, we don't care... * We woke inside or after the sample window, this means we're already
* accounted through the nohz accounting, so skip the entire deal and
* sync up for the next window.
*/ */
if (atomic_long_read(&calc_load_tasks_idle)) this_rq->calc_load_update = calc_load_update;
delta = atomic_long_xchg(&calc_load_tasks_idle, 0); if (time_before(jiffies, this_rq->calc_load_update + 10))
this_rq->calc_load_update += LOAD_FREQ;
}
static long calc_load_fold_idle(void)
{
int idx = calc_load_read_idx();
long delta = 0;
if (atomic_long_read(&calc_load_idle[idx]))
delta = atomic_long_xchg(&calc_load_idle[idx], 0);
return delta; return delta;
} }
...@@ -2302,22 +2454,7 @@ static void calc_global_nohz(void) ...@@ -2302,22 +2454,7 @@ static void calc_global_nohz(void)
{ {
long delta, active, n; long delta, active, n;
/* if (!time_before(jiffies, calc_load_update + 10)) {
* If we crossed a calc_load_update boundary, make sure to fold
* any pending idle changes, the respective CPUs might have
* missed the tick driven calc_load_account_active() update
* due to NO_HZ.
*/
delta = calc_load_fold_idle();
if (delta)
atomic_long_add(delta, &calc_load_tasks);
/*
* It could be the one fold was all it took, we done!
*/
if (time_before(jiffies, calc_load_update + 10))
return;
/* /*
* Catch-up, fold however many we are behind still * Catch-up, fold however many we are behind still
*/ */
...@@ -2332,36 +2469,24 @@ static void calc_global_nohz(void) ...@@ -2332,36 +2469,24 @@ static void calc_global_nohz(void)
avenrun[2] = calc_load_n(avenrun[2], EXP_15, active, n); avenrun[2] = calc_load_n(avenrun[2], EXP_15, active, n);
calc_load_update += n * LOAD_FREQ; calc_load_update += n * LOAD_FREQ;
} }
#else
void calc_load_account_idle(struct rq *this_rq)
{
}
static inline long calc_load_fold_idle(void)
{
return 0;
}
static void calc_global_nohz(void)
{
}
#endif
/** /*
* get_avenrun - get the load average array * Flip the idle index...
* @loads: pointer to dest load array
* @offset: offset to add
* @shift: shift count to shift the result left
* *
* These values are estimates at best, so no need for locking. * Make sure we first write the new time then flip the index, so that
* calc_load_write_idx() will see the new time when it reads the new
* index, this avoids a double flip messing things up.
*/ */
void get_avenrun(unsigned long *loads, unsigned long offset, int shift) smp_wmb();
{ calc_load_idx++;
loads[0] = (avenrun[0] + offset) << shift;
loads[1] = (avenrun[1] + offset) << shift;
loads[2] = (avenrun[2] + offset) << shift;
} }
#else /* !CONFIG_NO_HZ */
static inline long calc_load_fold_idle(void) { return 0; }
static inline void calc_global_nohz(void) { }
#endif /* CONFIG_NO_HZ */
/* /*
* calc_load - update the avenrun load estimates 10 ticks after the * calc_load - update the avenrun load estimates 10 ticks after the
...@@ -2369,11 +2494,18 @@ void get_avenrun(unsigned long *loads, unsigned long offset, int shift) ...@@ -2369,11 +2494,18 @@ void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
*/ */
void calc_global_load(unsigned long ticks) void calc_global_load(unsigned long ticks)
{ {
long active; long active, delta;
if (time_before(jiffies, calc_load_update + 10)) if (time_before(jiffies, calc_load_update + 10))
return; return;
/*
* Fold the 'old' idle-delta to include all NO_HZ cpus.
*/
delta = calc_load_fold_idle();
if (delta)
atomic_long_add(delta, &calc_load_tasks);
active = atomic_long_read(&calc_load_tasks); active = atomic_long_read(&calc_load_tasks);
active = active > 0 ? active * FIXED_1 : 0; active = active > 0 ? active * FIXED_1 : 0;
...@@ -2384,12 +2516,7 @@ void calc_global_load(unsigned long ticks) ...@@ -2384,12 +2516,7 @@ void calc_global_load(unsigned long ticks)
calc_load_update += LOAD_FREQ; calc_load_update += LOAD_FREQ;
/* /*
* Account one period with whatever state we found before * In case we idled for multiple LOAD_FREQ intervals, catch up in bulk.
* folding in the nohz state and ageing the entire idle period.
*
* This avoids loosing a sample when we go idle between
* calc_load_account_active() (10 ticks ago) and now and thus
* under-accounting.
*/ */
calc_global_nohz(); calc_global_nohz();
} }
...@@ -2406,13 +2533,16 @@ static void calc_load_account_active(struct rq *this_rq) ...@@ -2406,13 +2533,16 @@ static void calc_load_account_active(struct rq *this_rq)
return; return;
delta = calc_load_fold_active(this_rq); delta = calc_load_fold_active(this_rq);
delta += calc_load_fold_idle();
if (delta) if (delta)
atomic_long_add(delta, &calc_load_tasks); atomic_long_add(delta, &calc_load_tasks);
this_rq->calc_load_update += LOAD_FREQ; this_rq->calc_load_update += LOAD_FREQ;
} }
/*
* End of global load-average stuff
*/
/* /*
* The exact cpuload at various idx values, calculated at every tick would be * The exact cpuload at various idx values, calculated at every tick would be
* load = (2^idx - 1) / 2^idx * load + 1 / 2^idx * cur_load * load = (2^idx - 1) / 2^idx * load + 1 / 2^idx * cur_load
......
...@@ -25,7 +25,6 @@ static void check_preempt_curr_idle(struct rq *rq, struct task_struct *p, int fl ...@@ -25,7 +25,6 @@ static void check_preempt_curr_idle(struct rq *rq, struct task_struct *p, int fl
static struct task_struct *pick_next_task_idle(struct rq *rq) static struct task_struct *pick_next_task_idle(struct rq *rq)
{ {
schedstat_inc(rq, sched_goidle); schedstat_inc(rq, sched_goidle);
calc_load_account_idle(rq);
return rq->idle; return rq->idle;
} }
......
...@@ -942,8 +942,6 @@ static inline u64 sched_avg_period(void) ...@@ -942,8 +942,6 @@ static inline u64 sched_avg_period(void)
return (u64)sysctl_sched_time_avg * NSEC_PER_MSEC / 2; return (u64)sysctl_sched_time_avg * NSEC_PER_MSEC / 2;
} }
void calc_load_account_idle(struct rq *this_rq);
#ifdef CONFIG_SCHED_HRTICK #ifdef CONFIG_SCHED_HRTICK
/* /*
......
...@@ -406,6 +406,7 @@ static void tick_nohz_stop_sched_tick(struct tick_sched *ts) ...@@ -406,6 +406,7 @@ static void tick_nohz_stop_sched_tick(struct tick_sched *ts)
*/ */
if (!ts->tick_stopped) { if (!ts->tick_stopped) {
select_nohz_load_balancer(1); select_nohz_load_balancer(1);
calc_load_enter_idle();
ts->idle_tick = hrtimer_get_expires(&ts->sched_timer); ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);
ts->tick_stopped = 1; ts->tick_stopped = 1;
...@@ -597,6 +598,7 @@ void tick_nohz_idle_exit(void) ...@@ -597,6 +598,7 @@ void tick_nohz_idle_exit(void)
account_idle_ticks(ticks); account_idle_ticks(ticks);
#endif #endif
calc_load_exit_idle();
touch_softlockup_watchdog(); touch_softlockup_watchdog();
/* /*
* Cancel the scheduled timer and restore the tick * Cancel the scheduled timer and restore the tick
......
...@@ -1075,6 +1075,7 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int nr_pages, int cpu) ...@@ -1075,6 +1075,7 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int nr_pages, int cpu)
rb_init_page(bpage->page); rb_init_page(bpage->page);
INIT_LIST_HEAD(&cpu_buffer->reader_page->list); INIT_LIST_HEAD(&cpu_buffer->reader_page->list);
INIT_LIST_HEAD(&cpu_buffer->new_pages);
ret = rb_allocate_pages(cpu_buffer, nr_pages); ret = rb_allocate_pages(cpu_buffer, nr_pages);
if (ret < 0) if (ret < 0)
...@@ -1346,10 +1347,9 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned int nr_pages) ...@@ -1346,10 +1347,9 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned int nr_pages)
* If something was added to this page, it was full * If something was added to this page, it was full
* since it is not the tail page. So we deduct the * since it is not the tail page. So we deduct the
* bytes consumed in ring buffer from here. * bytes consumed in ring buffer from here.
* No need to update overruns, since this page is * Increment overrun to account for the lost events.
* deleted from ring buffer and its entries are
* already accounted for.
*/ */
local_add(page_entries, &cpu_buffer->overrun);
local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes); local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
} }
......
...@@ -669,24 +669,25 @@ struct machine *machines__find(struct rb_root *self, pid_t pid) ...@@ -669,24 +669,25 @@ struct machine *machines__find(struct rb_root *self, pid_t pid)
struct machine *machines__findnew(struct rb_root *self, pid_t pid) struct machine *machines__findnew(struct rb_root *self, pid_t pid)
{ {
char path[PATH_MAX]; char path[PATH_MAX];
const char *root_dir; const char *root_dir = "";
struct machine *machine = machines__find(self, pid); struct machine *machine = machines__find(self, pid);
if (!machine || machine->pid != pid) { if (machine && (machine->pid == pid))
if (pid == HOST_KERNEL_ID || pid == DEFAULT_GUEST_KERNEL_ID)
root_dir = "";
else {
if (!symbol_conf.guestmount)
goto out; goto out;
if ((pid != HOST_KERNEL_ID) &&
(pid != DEFAULT_GUEST_KERNEL_ID) &&
(symbol_conf.guestmount)) {
sprintf(path, "%s/%d", symbol_conf.guestmount, pid); sprintf(path, "%s/%d", symbol_conf.guestmount, pid);
if (access(path, R_OK)) { if (access(path, R_OK)) {
pr_err("Can't access file %s\n", path); pr_err("Can't access file %s\n", path);
machine = NULL;
goto out; goto out;
} }
root_dir = path; root_dir = path;
} }
machine = machines__add(self, pid, root_dir); machine = machines__add(self, pid, root_dir);
}
out: out:
return machine; return machine;
......
...@@ -926,7 +926,7 @@ static struct machine * ...@@ -926,7 +926,7 @@ static struct machine *
else else
pid = event->ip.pid; pid = event->ip.pid;
return perf_session__find_machine(session, pid); return perf_session__findnew_machine(session, pid);
} }
return perf_session__find_host_machine(session); return perf_session__find_host_machine(session);
......
...@@ -198,9 +198,8 @@ void print_trace_event(int cpu, void *data, int size) ...@@ -198,9 +198,8 @@ void print_trace_event(int cpu, void *data, int size)
record.data = data; record.data = data;
trace_seq_init(&s); trace_seq_init(&s);
pevent_print_event(pevent, &s, &record); pevent_event_info(&s, event, &record);
trace_seq_do_printf(&s); trace_seq_do_printf(&s);
printf("\n");
} }
void print_event(int cpu, void *data, int size, unsigned long long nsecs, void print_event(int cpu, void *data, int size, unsigned long long nsecs,
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment