History

[PATCH] clockevents: Fix suspend/resume to disk hangs

I finally found a dual core box, which survives suspend/resume without crashing in the middle of nowhere. Sigh, I never figured out from the code and the bug reports what's going on. The observed hangs are caused by a stale state transition of the clock event devices, which keeps the RCU synchronization away from completion, when the non boot CPU is brought back up. The suspend/resume in oneshot mode needs the similar care as the periodic mode during suspend to RAM. My assumption that the state transitions during the different shutdown/bringups of s2disk would go through the periodic boot phase and then switch over to highres resp. nohz mode were simply wrong. Add the appropriate suspend / resume handling for the non periodic modes.

Thomas Gleixner committed 19 years ago

Commit cd05a1f1 parent 24c4ac04 files · +51 −12Browse files

Unified · Split

4 files
  1. kernel/time/tick-broadcast.c +22 −5
  2. kernel/time/tick-common.c +7 −6
  3. kernel/time/tick-internal.h +10 −1
  4. kernel/time/tick-oneshot.c +12 −0
kernel/time/tick-broadcast.c+22−5
@@ -307,12 +307,19 @@ int tick_resume_broadcast(void) · 306 unmodified lines
307 spin_lock_irqsave(&tick_broadcast_lock, flags);307 spin_lock_irqsave(&tick_broadcast_lock, flags);
308 308
309 bc = tick_broadcast_device.evtdev;309 bc = tick_broadcast_device.evtdev;
310 if (bc) {
311 if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC &&
312 !cpus_empty(tick_broadcast_mask))
313 tick_broadcast_start_periodic(bc);
314 310
315 broadcast = cpu_isset(smp_processor_id(), tick_broadcast_mask);311 if (bc) {
312 switch (tick_broadcast_device.mode) {
313 case TICKDEV_MODE_PERIODIC:
314 if(!cpus_empty(tick_broadcast_mask))
315 tick_broadcast_start_periodic(bc);
316 broadcast = cpu_isset(smp_processor_id(),
317 tick_broadcast_mask);
318 break;
319 case TICKDEV_MODE_ONESHOT:
320 broadcast = tick_resume_broadcast_oneshot(bc);
321 break;
322 }
316 }323 }
317 spin_unlock_irqrestore(&tick_broadcast_lock, flags);324 spin_unlock_irqrestore(&tick_broadcast_lock, flags);
318 325
@@ -347,6 +354,16 @@ static int tick_broadcast_set_event(ktime_t expires, int force) · 28 unmodified lines
347 }354 }
348}355}
349 356
357int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
358{
359 clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
360
361 if(!cpus_empty(tick_broadcast_oneshot_mask))
362 tick_broadcast_set_event(ktime_get(), 1);
363
364 return cpu_isset(smp_processor_id(), tick_broadcast_oneshot_mask);
365}
366
350/*367/*
351 * Reprogram the broadcast device:368 * Reprogram the broadcast device:
352 *369 *
kernel/time/tick-common.c+7−6
@@ -298,18 +298,17 @@ static void tick_shutdown(unsigned int *cpup) · 297 unmodified lines
298 spin_unlock_irqrestore(&tick_device_lock, flags);298 spin_unlock_irqrestore(&tick_device_lock, flags);
299}299}
300 300
301static void tick_suspend_periodic(void)301static void tick_suspend(void)
302{302{
303 struct tick_device *td = &__get_cpu_var(tick_cpu_device);303 struct tick_device *td = &__get_cpu_var(tick_cpu_device);
304 unsigned long flags;304 unsigned long flags;
305 305
306 spin_lock_irqsave(&tick_device_lock, flags);306 spin_lock_irqsave(&tick_device_lock, flags);
307 if (td->mode == TICKDEV_MODE_PERIODIC)307 clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_SHUTDOWN);
308 clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_SHUTDOWN);
309 spin_unlock_irqrestore(&tick_device_lock, flags);308 spin_unlock_irqrestore(&tick_device_lock, flags);
310}309}
311 310
312static void tick_resume_periodic(void)311static void tick_resume(void)
313{312{
314 struct tick_device *td = &__get_cpu_var(tick_cpu_device);313 struct tick_device *td = &__get_cpu_var(tick_cpu_device);
315 unsigned long flags;314 unsigned long flags;
@@ -317,6 +316,8 @@ static void tick_resume_periodic(void) · 1 unmodified line
317 spin_lock_irqsave(&tick_device_lock, flags);316 spin_lock_irqsave(&tick_device_lock, flags);
318 if (td->mode == TICKDEV_MODE_PERIODIC)317 if (td->mode == TICKDEV_MODE_PERIODIC)
319 tick_setup_periodic(td->evtdev, 0);318 tick_setup_periodic(td->evtdev, 0);
319 else
320 tick_resume_oneshot();
320 spin_unlock_irqrestore(&tick_device_lock, flags);321 spin_unlock_irqrestore(&tick_device_lock, flags);
321}322}
322 323
@@ -348,13 +349,13 @@ static int tick_notify(struct notifier_block *nb, unsigned long reason, · 25 unmodified lines
348 break;349 break;
349 350
350 case CLOCK_EVT_NOTIFY_SUSPEND:351 case CLOCK_EVT_NOTIFY_SUSPEND:
351 tick_suspend_periodic();352 tick_suspend();
352 tick_suspend_broadcast();353 tick_suspend_broadcast();
353 break;354 break;
354 355
355 case CLOCK_EVT_NOTIFY_RESUME:356 case CLOCK_EVT_NOTIFY_RESUME:
356 if (!tick_resume_broadcast())357 if (!tick_resume_broadcast())
357 tick_resume_periodic();358 tick_resume();
358 break;359 break;
359 360
360 default:361 default:
kernel/time/tick-internal.h+10−1
@@ -19,12 +19,13 @@ extern void tick_setup_oneshot(struct clock_event_device *newdev, · 18 unmodified lines
19extern int tick_program_event(ktime_t expires, int force);19extern int tick_program_event(ktime_t expires, int force);
20extern void tick_oneshot_notify(void);20extern void tick_oneshot_notify(void);
21extern int tick_switch_to_oneshot(void (*handler)(struct clock_event_device *));21extern int tick_switch_to_oneshot(void (*handler)(struct clock_event_device *));
22 22extern void tick_resume_oneshot(void);
23# ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST23# ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
24extern void tick_broadcast_setup_oneshot(struct clock_event_device *bc);24extern void tick_broadcast_setup_oneshot(struct clock_event_device *bc);
25extern void tick_broadcast_oneshot_control(unsigned long reason);25extern void tick_broadcast_oneshot_control(unsigned long reason);
26extern void tick_broadcast_switch_to_oneshot(void);26extern void tick_broadcast_switch_to_oneshot(void);
27extern void tick_shutdown_broadcast_oneshot(unsigned int *cpup);27extern void tick_shutdown_broadcast_oneshot(unsigned int *cpup);
28extern int tick_resume_broadcast_oneshot(struct clock_event_device *bc);
28# else /* BROADCAST */29# else /* BROADCAST */
29static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc)30static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
30{31{
@@ -43,6 +44,10 @@ void tick_setup_oneshot(struct clock_event_device *newdev, · 12 unmodified lines
43{44{
44 BUG();45 BUG();
45}46}
47static inline void tick_resume_oneshot(void)
48{
49 BUG();
50}
46static inline int tick_program_event(ktime_t expires, int force)51static inline int tick_program_event(ktime_t expires, int force)
47{52{
48 return 0;53 return 0;
@@ -54,6 +59,10 @@ static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc) · 5 unmodified lines
54}59}
55static inline void tick_broadcast_oneshot_control(unsigned long reason) { }60static inline void tick_broadcast_oneshot_control(unsigned long reason) { }
56static inline void tick_shutdown_broadcast_oneshot(unsigned int *cpup) { }61static inline void tick_shutdown_broadcast_oneshot(unsigned int *cpup) { }
62static inline int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
63{
64 return 0;
65}
57#endif /* !TICK_ONESHOT */66#endif /* !TICK_ONESHOT */
58 67
59/*68/*
kernel/time/tick-oneshot.c+12−0
@@ -40,6 +40,18 @@ int tick_program_event(ktime_t expires, int force) · 39 unmodified lines
40 }40 }
41}41}
42 42
43/**
44 * tick_resume_onshot - resume oneshot mode
45 */
46void tick_resume_oneshot(void)
47{
48 struct tick_device *td = &__get_cpu_var(tick_cpu_device);
49 struct clock_event_device *dev = td->evtdev;
50
51 clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT);
52 tick_program_event(ktime_get(), 1);
53}
54
43/**55/**
44 * tick_setup_oneshot - setup the event device for oneshot mode (hres or nohz)56 * tick_setup_oneshot - setup the event device for oneshot mode (hres or nohz)
45 */57 */