Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

clockevents: fix reprogramming decision in oneshot broadcast

Browse source 
Resolve the following regression of a choppy, almost unusable laptop:

 http://lkml.org/lkml/2007/12/7/299
 http://bugzilla.kernel.org/show_bug.cgi?id=9525

A previous version of the code did the reprogramming of the broadcast
device in the return from idle code. This was removed, but the logic in
tick_handle_oneshot_broadcast() was kept the same.

When a broadcast interrupt happens we signal the expiry to all CPUs
which have an expired event. If none of the CPUs has an expired event,
which can happen in dyntick mode, then we reprogram the broadcast
device. We do not reprogram otherwise, but this is only correct if all
CPUs, which are in the idle broadcast state have been woken up.

The code ignores, that there might be pending not yet expired events on
other CPUs, which are in the idle broadcast state. So the delivery of
those events can be delayed for quite a time.

Change the tick_handle_oneshot_broadcast() function to check for CPUs,
which are in broadcast state and are not woken up by the current event,
and enforce the rearming of the broadcast device for those CPUs.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Thomas Gleixner 2007-12-18 18:05:58 +01:00 committed by Ingo Molnar
parent bd87f1f028
commit cdc6f27d9e
1 changed files with 21 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
kernel/time/tick-broadcast.c
View file

@ -383,33 +383,6 @@ int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
return 0; return 0;
} }
/*
* Reprogram the broadcast device:
*
* Called with tick_broadcast_lock held and interrupts disabled.
*/
static int tick_broadcast_reprogram(void)
{
ktime_t expires = { .tv64 = KTIME_MAX };
struct tick_device *td;
int cpu;
/*
* Find the event which expires next:
*/
for (cpu = first_cpu(tick_broadcast_oneshot_mask); cpu != NR_CPUS;
cpu = next_cpu(cpu, tick_broadcast_oneshot_mask)) {
td = &per_cpu(tick_cpu_device, cpu);
if (td->evtdev->next_event.tv64 < expires.tv64)
expires = td->evtdev->next_event;
}
if (expires.tv64 == KTIME_MAX)
return 0;
return tick_broadcast_set_event(expires, 0);
}
/* /*
* Handle oneshot mode broadcasting * Handle oneshot mode broadcasting
*/ */
@ -417,12 +390,13 @@ static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
{ {
struct tick_device *td; struct tick_device *td;
cpumask_t mask; cpumask_t mask;
ktime_t now; ktime_t now, next_event;
int cpu; int cpu;
spin_lock(&tick_broadcast_lock); spin_lock(&tick_broadcast_lock);
again: again:
dev->next_event.tv64 = KTIME_MAX; dev->next_event.tv64 = KTIME_MAX;
next_event.tv64 = KTIME_MAX;
mask = CPU_MASK_NONE; mask = CPU_MASK_NONE;
now = ktime_get(); now = ktime_get();
/* Find all expired events */ /* Find all expired events */
@ -431,19 +405,31 @@ static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
td = &per_cpu(tick_cpu_device, cpu); td = &per_cpu(tick_cpu_device, cpu);
if (td->evtdev->next_event.tv64 <= now.tv64) if (td->evtdev->next_event.tv64 <= now.tv64)
cpu_set(cpu, mask); cpu_set(cpu, mask);
else if (td->evtdev->next_event.tv64 < next_event.tv64)
next_event.tv64 = td->evtdev->next_event.tv64;
} }
/* /*
* Wakeup the cpus which have an expired event. The broadcast * Wakeup the cpus which have an expired event.
* device is reprogrammed in the return from idle code.
*/ */
if (!tick_do_broadcast(mask)) { tick_do_broadcast(mask);
/*
* Two reasons for reprogram:
*
* - The global event did not expire any CPU local
* events. This happens in dyntick mode, as the maximum PIT
* delta is quite small.
*
* - There are pending events on sleeping CPUs which were not
* in the event mask
*/
if (next_event.tv64 != KTIME_MAX) {
/* /*
* The global event did not expire any CPU local * Rearm the broadcast device. If event expired,
* events. This happens in dyntick mode, as the * repeat the above
* maximum PIT delta is quite small.
*/ */
if (tick_broadcast_reprogram()) if (tick_broadcast_set_event(next_event, 0))
goto again; goto again;
} }
spin_unlock(&tick_broadcast_lock); spin_unlock(&tick_broadcast_lock);