Commit d1748302 authored by Martin Schwidefsky's avatar Martin Schwidefsky Committed by Thomas Gleixner
Browse files

clockevents: Make minimum delay adjustments configurable 



The automatic increase of the min_delta_ns of a clockevents device
should be done in the clockevents code as the minimum delay is an
attribute of the clockevents device.

In addition not all architectures want the automatic adjustment, on a
massively virtualized system it can happen that the programming of a
clock event fails several times in a row because the virtual cpu has
been rescheduled quickly enough. In that case the minimum delay will
erroneously be increased with no way back. The new config symbol
GENERIC_CLOCKEVENTS_MIN_ADJUST is used to enable the automatic
adjustment. The config option is selected only for x86.

Signed-off-by: default avatarMartin Schwidefsky <schwidefsky@de.ibm.com>
Cc: john stultz <johnstul@us.ibm.com>
Link: http://lkml.kernel.org/r/20110823133142.494157493@de.ibm.com


Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
parent 29c158e8

arch/x86/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -68,6 +68,7 @@ config X86 
	select GENERIC_IRQ_PROBE

	select GENERIC_PENDING_IRQ if SMP

	select GENERIC_IRQ_SHOW

	select GENERIC_CLOCKEVENTS_MIN_ADJUST

	select IRQ_FORCED_THREADING

	select USE_GENERIC_SMP_HELPERS if SMP

	select HAVE_BPF_JIT if (X86_64 && NET)

include/linux/clockchips.h

+1 −1
Original line number Diff line number Diff line
@@ -140,7 +140,7 @@ extern void clockevents_set_mode(struct clock_event_device *dev, 
				 enum clock_event_mode mode);

extern int clockevents_register_notifier(struct notifier_block *nb);

extern int clockevents_program_event(struct clock_event_device *dev,

				     ktime_t expires, ktime_t now);

				     ktime_t expires, bool force);



extern void clockevents_handle_noop(struct clock_event_device *dev);

kernel/time/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -27,3 +27,5 @@ config GENERIC_CLOCKEVENTS_BUILD 
	default y

	depends on GENERIC_CLOCKEVENTS || GENERIC_CLOCKEVENTS_MIGR



config GENERIC_CLOCKEVENTS_MIN_ADJUST

	bool

kernel/time/clockevents.c

+111 −14
Original line number Diff line number Diff line
@@ -94,42 +94,139 @@ void clockevents_shutdown(struct clock_event_device *dev) 
	dev->next_event.tv64 = KTIME_MAX;

}



#ifdef CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST



/* Limit min_delta to a jiffie */

#define MIN_DELTA_LIMIT		(NSEC_PER_SEC / HZ)



/**

 * clockevents_increase_min_delta - raise minimum delta of a clock event device

 * @dev:       device to increase the minimum delta

 *

 * Returns 0 on success, -ETIME when the minimum delta reached the limit.

 */

static int clockevents_increase_min_delta(struct clock_event_device *dev)

{

	/* Nothing to do if we already reached the limit */

	if (dev->min_delta_ns >= MIN_DELTA_LIMIT) {

		printk(KERN_WARNING "CE: Reprogramming failure. Giving up\n");

		dev->next_event.tv64 = KTIME_MAX;

		return -ETIME;

	}



	if (dev->min_delta_ns < 5000)

		dev->min_delta_ns = 5000;

	else

		dev->min_delta_ns += dev->min_delta_ns >> 1;



	if (dev->min_delta_ns > MIN_DELTA_LIMIT)

		dev->min_delta_ns = MIN_DELTA_LIMIT;



	printk(KERN_WARNING "CE: %s increased min_delta_ns to %llu nsec\n",

	       dev->name ? dev->name : "?",

	       (unsigned long long) dev->min_delta_ns);

	return 0;

}



/**

 * clockevents_program_min_delta - Set clock event device to the minimum delay.

 * @dev:	device to program

 *

 * Returns 0 on success, -ETIME when the retry loop failed.

 */

static int clockevents_program_min_delta(struct clock_event_device *dev)

{

	unsigned long long clc;

	int64_t delta;

	int i;



	for (i = 0;;) {

		delta = dev->min_delta_ns;

		dev->next_event = ktime_add_ns(ktime_get(), delta);



		if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)

			return 0;



		dev->retries++;

		clc = ((unsigned long long) delta * dev->mult) >> dev->shift;

		if (dev->set_next_event((unsigned long) clc, dev) == 0)

			return 0;



		if (++i > 2) {

			/*

			 * We tried 3 times to program the device with the

			 * given min_delta_ns. Try to increase the minimum

			 * delta, if that fails as well get out of here.

			 */

			if (clockevents_increase_min_delta(dev))

				return -ETIME;

			i = 0;

		}

	}

}



#else  /* CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST */



/**

 * clockevents_program_min_delta - Set clock event device to the minimum delay.

 * @dev:	device to program

 *

 * Returns 0 on success, -ETIME when the retry loop failed.

 */

static int clockevents_program_min_delta(struct clock_event_device *dev)

{

	unsigned long long clc;

	int64_t delta;



	delta = dev->min_delta_ns;

	dev->next_event = ktime_add_ns(ktime_get(), delta);



	if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)

		return 0;



	dev->retries++;

	clc = ((unsigned long long) delta * dev->mult) >> dev->shift;

	return dev->set_next_event((unsigned long) clc, dev);

}



#endif /* CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST */



/**

 * clockevents_program_event - Reprogram the clock event device.

 * @dev:	device to program

 * @expires:	absolute expiry time (monotonic clock)

 * @force:	program minimum delay if expires can not be set

 *

 * Returns 0 on success, -ETIME when the event is in the past.

 */

int clockevents_program_event(struct clock_event_device *dev, ktime_t expires,

			      ktime_t now)

			      bool force)

{

	unsigned long long clc;

	int64_t delta;

	int rc;



	if (unlikely(expires.tv64 < 0)) {

		WARN_ON_ONCE(1);

		return -ETIME;

	}



	delta = ktime_to_ns(ktime_sub(expires, now));



	if (delta <= 0)

		return -ETIME;



	dev->next_event = expires;



	if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)

		return 0;



	if (delta > dev->max_delta_ns)

		delta = dev->max_delta_ns;

	if (delta < dev->min_delta_ns)

		delta = dev->min_delta_ns;

	delta = ktime_to_ns(ktime_sub(expires, ktime_get()));

	if (delta <= 0)

		return force ? clockevents_program_min_delta(dev) : -ETIME;



	clc = delta * dev->mult;

	clc >>= dev->shift;

	delta = min(delta, (int64_t) dev->max_delta_ns);

	delta = max(delta, (int64_t) dev->min_delta_ns);



	return dev->set_next_event((unsigned long) clc, dev);

	clc = ((unsigned long long) delta * dev->mult) >> dev->shift;

	rc = dev->set_next_event((unsigned long) clc, dev);



	return (rc && force) ? clockevents_program_min_delta(dev) : rc;

}



/**
@@ -258,7 +355,7 @@ int clockevents_update_freq(struct clock_event_device *dev, u32 freq) 
	if (dev->mode != CLOCK_EVT_MODE_ONESHOT)

		return 0;



	return clockevents_program_event(dev, dev->next_event, ktime_get());

	return clockevents_program_event(dev, dev->next_event, false);

}



/*

kernel/time/tick-broadcast.c

+2 −2
Original line number Diff line number Diff line
@@ -194,7 +194,7 @@ static void tick_handle_periodic_broadcast(struct clock_event_device *dev) 
	for (next = dev->next_event; ;) {

		next = ktime_add(next, tick_period);



		if (!clockevents_program_event(dev, next, ktime_get()))

		if (!clockevents_program_event(dev, next, false))

			return;

		tick_do_periodic_broadcast();

	}
@@ -373,7 +373,7 @@ static int tick_broadcast_set_event(ktime_t expires, int force) 
{

	struct clock_event_device *bc = tick_broadcast_device.evtdev;



	return tick_dev_program_event(bc, expires, force);

	return clockevents_program_event(bc, expires, force);

}



int tick_resume_broadcast_oneshot(struct clock_event_device *bc)

CRA Git | Maintained and supported by SUSTech CRA and CCSE