Skip to contentSkip to conversation

Fix the possibility of insane return value of hpet_calibrate() against SMI.

PATCH In review Yasunori Goto 6 participants 17 messages Mar 13, 2009 – Mar 30, 2009

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 Fix the possibility of insane return value of hpet_calibrate() against SMI.

Hello.

I think there is a possibility that HPET driver will return insane value due to a SMI interruption (or switching guests by hypervisor). I found it by reviewing, and I would like to fix it.

Current HPET driver calibrates the adjustment value by calculation the elapse time in CPU busy loop. However this way is too dangerous against SMI interruption.

Here is the calibration code in hpet_calibrate()

701 static unsigned long hpet_calibrate(struct hpets *hpetp)

             :
             :

728 do {
729 m = read_counter(&hpet->hpet_mc);
730 write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare);
731 } while (i++, (m - start) < count);
732
733 local_irq_restore(flags);
734
735 return (m - start) / i;

If SMI interruption occurs between 728 to 731, then return value will be bigger value than correct one. (SMI is not able to be controlled by OS.)

This patch is a simple solution to fix it. hpet_calibrate() is called 5 times, and one of them is expected as correct value.

Thanks.

---

hpet_calibrate() has a possibility of miss-calibration due to SMI. If SMI interrupts in the while loop of calibration, then return value will be big. This changes it tries 5 times and get minimum value as correct value.

---

drivers/char/hpet.c +12 -1
Index: hpet_test/drivers/char/hpet.c
===================================================================
@@ -713,7 +713,7 @@
  */
 #define	TICK_CALIBRATE	(1000UL)
 
-static unsigned long hpet_calibrate(struct hpets *hpetp)
+static unsigned long __hpet_calibrate(struct hpets *hpetp)
 {
 	struct hpet_timer __iomem *timer = NULL;
 	unsigned long t, m, count, i, flags, start;
@@ -750,6 +750,17 @@
 	return (m - start) / i;
 }
 
+static unsigned long hpet_calibrate(struct hpets *hpetp)
+{
+	unsigned long ret = ~0UL, i;
+
+	/* Try 5 times to remove impact of SMI.*/
+	for (i = 0; i < 5; i++)
+		ret = min(ret, __hpet_calibrate(hpetp));
+
+	return ret;
+}
+
 int hpet_alloc(struct hpet_data *hdp)
 {
 	u64 cap, mcfg;
Signature · 1 line
Yasunori Goto 
Acked-by on v1 1/1
#1 lore raw
Quoted 6 lines · Yasunori Goto

hpet_calibrate() has a possibility of miss-calibration due to SMI. If SMI interrupts in the while loop of calibration, then return value will be big. This changes it tries 5 times and get minimum value as correct value.

Signature · 1 line
All rights reversed.
#2 lore raw
In reply to Yasunori Goto
Quoted 24 lines · Yasunori Goto

Hello.

I think there is a possibility that HPET driver will return insane value due to a SMI interruption (or switching guests by hypervisor). I found it by reviewing, and I would like to fix it.

Current HPET driver calibrates the adjustment value by calculation the elapse time in CPU busy loop. However this way is too dangerous against SMI interruption.

Here is the calibration code in hpet_calibrate()

 701 static unsigned long hpet_calibrate(struct hpets *hpetp)
            :
            :
 728         do {
 729                 m = read_counter(&hpet->hpet_mc);
 730                 write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare); 731         } while (i++, (m - start) < count);
 732
 733         local_irq_restore(flags);
 734
 735         return (m - start) / i;

Quoted 7 lines

If SMI interruption occurs between 728 to 731, then return value will be bigger value than correct one. (SMI is not able to be controlled by OS.)

This patch is a simple solution to fix it. hpet_calibrate() is called 5 times, and one of them is expected as correct value.

I've no sense of feel for how long each calibration run would take. Would doing it 5 times show up as a significant increase in the boot time for those that care about boot time being as quick as possible?

Paul.

Quoted 57 lines

Thanks.

---

hpet_calibrate() has a possibility of miss-calibration due to SMI. If SMI interrupts in the while loop of calibration, then return value will be big. This changes it tries 5 times and get minimum value as correct value.

---

Index: hpet_test/drivers/char/hpet.c
===================================================================

drivers/char/hpet.c       2008-12-04 16:34:59.000000000 +0900 renamed from drivers/char/hpet.c  2008-12-04 16:24:02.000000000 +0900 +12 -2
@@ -713,7 +713,7 @@
  */
  #define        TICK_CALIBRATE  (1000UL)
 
-static unsigned long hpet_calibrate(struct hpets *hpetp)
+static unsigned long __hpet_calibrate(struct hpets *hpetp)
  {
        struct hpet_timer __iomem *timer = NULL;
        unsigned long t, m, count, i, flags, start;
@@ -750,6 +750,17 @@
        return (m - start) / i;
  }
 
+static unsigned long hpet_calibrate(struct hpets *hpetp)
+{
+       unsigned long ret = ~0UL, i;
+
+       /* Try 5 times to remove impact of SMI.*/
+       for (i = 0; i < 5; i++)
+               ret = min(ret, __hpet_calibrate(hpetp));
+
+       return ret;
+}
+
  int hpet_alloc(struct hpet_data *hdp)
  {
        u64 cap, mcfg;
 
--

Yasunori Goto

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

#3 lore raw
Quoted 29 lines · Yasunori Goto
Quoted 28 lines

Hello.

I think there is a possibility that HPET driver will return insane value due to a SMI interruption (or switching guests by hypervisor). I found it by reviewing, and I would like to fix it.

Current HPET driver calibrates the adjustment value by calculation the elapse time in CPU busy loop. However this way is too dangerous against SMI interruption.

Here is the calibration code in hpet_calibrate()

?701 static unsigned long hpet_calibrate(struct hpets *hpetp)
? ? ? ? ? ? :
? ? ? ? ? ? :
?728 ? ? ? ? do {
?729 ? ? ? ? ? ? ? ? m = read_counter(&hpet->hpet_mc);
?730 ? ? ? ? ? ? ? ? write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare); ?731 ? ? ? ? } while (i++, (m - start) < count);
?732
?733 ? ? ? ? local_irq_restore(flags);
?734
?735 ? ? ? ? return (m - start) / i;

If SMI interruption occurs between 728 to 731, then return value will be bigger value than correct one. (SMI is not able to be controlled by OS.)

Quoted 7 lines
Quoted 3 lines

This patch is a simple solution to fix it. hpet_calibrate() is called 5 times, and one of them is expected as correct value.

I've no sense of feel for how long each calibration run would take. Would doing it 5 times show up as a significant increase in the boot time for those that care about boot time being as quick as possible?

Hmm. The loop times is trade off against reliable value.... Though SMI is rare interruption, I don't know how frequent hypervisor's switch is.

Each calibration of this has 1 milli second.
Do you think 5 msec is too long?
If yes, how is 3 msec? Is it still too long?

Thanks.

Signature · 1 line
Yasunori Goto 
maintainer
#4 lore raw
Quoted 7 lines · Yasunori Goto
Quoted 3 lines

I've no sense of feel for how long each calibration run would take. Would doing it 5 times show up as a significant increase in the boot time for those that care about boot time being as quick as possible?

Hmm. The loop times is trade off against reliable value.... Though SMI is rare interruption, I don't know how frequent hypervisor's switch is.

Could you, just for testing, run the calibration five thousand times or so instead of five times, and count how often you get insane values? (And how much delay does such an SMI add?)

Quoted 2 lines

Each calibration of this has 1 milli second.
Do you think 5 msec is too long?

This shouldn't matter when booting. Anyway, I think it's possible to increase TICK_CALIBRATE without losing too much accuracy.

Best regards,
Clemens

#5 lore raw

Sorry for late response.

Quoted 5 lines
Quoted 4 lines · Yasunori Goto
Quoted 3 lines

I've no sense of feel for how long each calibration run would take. Would doing it 5 times show up as a significant increase in the boot time for those that care about boot time being as quick as possible?

Quoted 7 lines
Quoted 3 lines

Hmm. The loop times is trade off against reliable value.... Though SMI is rare interruption, I don't know how frequent hypervisor's switch is.

Could you, just for testing, run the calibration five thousand times or so instead of five times, and count how often you get insane values? (And how much delay does such an SMI add?)

I tried 50000 times. But insane value was nothing. I think SMI is very rare.

Quoted 5 lines
Quoted 2 lines

Each calibration of this has 1 milli second.
Do you think 5 msec is too long?

This shouldn't matter when booting. Anyway, I think it's possible to increase TICK_CALIBRATE without losing too much accuracy.

Hmm. If the person who is trying to reduce boot time for fastboot dislikes this impact, then I'll try Vojtech-san's way.

Thanks.

Signature · 1 line
Yasunori Goto 
#6 lore raw
Quoted 25 lines · Yasunori Goto

Sorry for late response.

Quoted 6 lines
Quoted 4 lines · Yasunori Goto
Quoted 4 lines

I've no sense of feel for how long each calibration run would take. Would doing it 5 times show up as a significant increase in the boot time for those that care about boot time being as quick as possible?

Quoted 8 lines
Quoted 4 lines

Hmm. The loop times is trade off against reliable value.... Though SMI is rare interruption, I don't know how frequent hypervisor's switch is.

Could you, just for testing, run the calibration five thousand times or so instead of five times, and count how often you get insane values? (And how much delay does such an SMI add?)

I tried 50000 times. But insane value was nothing. I think SMI is very rare.

Quoted 3 lines
Quoted 3 lines

Each calibration of this has 1 milli second.
Do you think 5 msec is too long?

Quoted 7 lines
Quoted 3 lines

This shouldn't matter when booting. Anyway, I think it's possible to increase TICK_CALIBRATE without losing too much accuracy.

Hmm. If the person who is trying to reduce boot time for fastboot dislikes this impact, then I'll try Vojtech-san's way.

That probably makes sense -- if it is extremely rare, and if you get two values that are the same (within some small delta) then you probably are 99.99% confident that you have the right data.

Paul.

Quoted 3 lines

Thanks.

#7 lore raw
Quoted 8 lines
Quoted 8 lines
Quoted 7 lines
Quoted 4 lines

Each calibration of this has 1 milli second.
Do you think 5 msec is too long?

This shouldn't matter when booting. Anyway, I think it's possible to increase TICK_CALIBRATE without losing too much accuracy.

Quoted 7 lines
Quoted 3 lines

Hmm. If the person who is trying to reduce boot time for fastboot dislikes this impact, then I'll try Vojtech-san's way.

That probably makes sense -- if it is extremely rare, and if you get two values that are the same (within some small delta) then you probably are 99.99% confident that you have the right data.

Ok. I'll make it.

Thanks for your comment.

Signature · 1 line
Yasunori Goto 
#8 lore raw

PATCH 1/1 Fix the possibility of insane return value of hpet_calibrate() against SMI. (take 2)

Quoted 12 lines
Quoted 12 lines
Quoted 11 lines
Quoted 7 lines
Quoted 4 lines

Each calibration of this has 1 milli second.
Do you think 5 msec is too long?

This shouldn't matter when booting. Anyway, I think it's possible to increase TICK_CALIBRATE without losing too much accuracy.

Hmm. If the person who is trying to reduce boot time for fastboot dislikes this impact, then I'll try Vojtech-san's way.

Quoted 7 lines
Quoted 3 lines

That probably makes sense -- if it is extremely rare, and if you get two values that are the same (within some small delta) then you probably are 99.99% confident that you have the right data.

Ok. I'll make it.

Thanks for your comment.

Here is updated version.

--------

hpet_calibrate() has a possibility of miss-calibration due to SMI. If SMI interrupts in the while loop of calibration, then return value will be big. This change calibrates until stabilizing by the return value with a small value.

---
 drivers/char/hpet.c |   21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)
drivers/char/hpet.c +20 -1
Index: hpet_test/drivers/char/hpet.c
===================================================================
@@ -713,7 +713,7 @@
  */
 #define	TICK_CALIBRATE	(1000UL)
 
-static unsigned long hpet_calibrate(struct hpets *hpetp)
+static unsigned long __hpet_calibrate(struct hpets *hpetp)
 {
 	struct hpet_timer __iomem *timer = NULL;
 	unsigned long t, m, count, i, flags, start;
@@ -750,6 +750,25 @@
 	return (m - start) / i;
 }
 
+static unsigned long hpet_calibrate(struct hpets *hpetp)
+{
+	unsigned long ret = ~0UL, tmp;
+
+	/*
+	 * Try to calibrate until return value becomes stable small value.
+	 * If SMI interruption occurs in calibration loop, the return value
+	 * will be big. This avoids its impact.
+	 */
+	do {
+		tmp = __hpet_calibrate(hpetp);
+		if (ret <= tmp)
+			break;
+		ret = tmp;
+	} while (1);
+
+	return ret;
+}
+
 int hpet_alloc(struct hpet_data *hdp)
 {
 	u64 cap, mcfg;
Signature · 1 line
Yasunori Goto 
maintainer Acked-by on v1 1/1
#9 lore raw

Re: [Patch] Fix the possibility of insane return value of hpet_calibrate() against SMI. (take 2)

Quoted 6 lines · Yasunori Goto

hpet_calibrate() has a possibility of miss-calibration due to SMI. If SMI interrupts in the while loop of calibration, then return value will be big. This change calibrates until stabilizing by the return value with a small value.

#10 lore raw

Re: [Patch] Fix the possibility of insane return value of hpet_calibrate() against SMI. (take 2)

Quoted 9 lines · Clemens Ladisch
Quoted 6 lines · Yasunori Goto

hpet_calibrate() has a possibility of miss-calibration due to SMI. If SMI interrupts in the while loop of calibration, then return value will be big. This change calibrates until stabilizing by the return value with a small value.

Signature · 2 lines
Vojtech Pavlik
Director SuSE Labs
#11 lore raw

Re: [Patch] Fix the possibility of insane return value of hpet_calibrate() against SMI. (take 2)

In reply to Yasunori Goto
Quoted 61 lines · Yasunori Goto
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 8 lines
Quoted 4 lines

Each calibration of this has 1 milli second.
Do you think 5 msec is too long?

This shouldn't matter when booting. Anyway, I think it's possible to increase TICK_CALIBRATE without losing too much accuracy.

Hmm. If the person who is trying to reduce boot time for fastboot dislikes this impact, then I'll try Vojtech-san's way.

Quoted 8 lines
Quoted 4 lines

That probably makes sense -- if it is extremely rare, and if you get two values that are the same (within some small delta) then you probably are 99.99% confident that you have the right data.

Ok. I'll make it.

Thanks for your comment.

Here is updated version.

--------

hpet_calibrate() has a possibility of miss-calibration due to SMI. If SMI interrupts in the while loop of calibration, then return value will be big. This change calibrates until stabilizing by the return value with a small value.

---
 drivers/char/hpet.c |   21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

Index: hpet_test/drivers/char/hpet.c
===================================================================

drivers/char/hpet.c +7 -1
@@ -713,7 +713,7 @@
  */
 #define	TICK_CALIBRATE	(1000UL)
 
-static unsigned long hpet_calibrate(struct hpets *hpetp)
+static unsigned long __hpet_calibrate(struct hpets *hpetp)
 {
 	struct hpet_timer __iomem *timer = NULL;
 	unsigned long t, m, count, i, flags, start;
@@ -750,6 +750,25 @@
 	return (m - start) / i;
 }
 
+static unsigned long hpet_calibrate(struct hpets *hpetp)
+{
+	unsigned long ret = ~0UL, tmp;
+
+	/*
+	 * Try to calibrate until return value becomes stable small value.

drivers/char/hpet.c line 768

Quoted 10 lines
drivers/char/hpet.c +9 -0
+	 * If SMI interruption occurs in calibration loop, the return value
+	 * will be big. This avoids its impact.
+	 */
+	do {
+		tmp = __hpet_calibrate(hpetp);
+		if (ret <= tmp)
+			break;
+		ret = tmp;
+	} while (1);
 

For what it is worth, if a situation arose where continued calls to hpet_calibrate() represented a monotonically decreasing function, (perhaps some insane power management?) you could be stuck
in this function for an unbounded amount of time. I don't expect
that should ever happen, but I figured I'd mention it.

Paul.

Quoted 9 lines
drivers/char/hpet.c +4 -0
+
+	return ret;
+}
+
 int hpet_alloc(struct hpet_data *hdp)
 {

u64 cap, mcfg;

maintainer
#12 lore raw

Re: [Patch] Fix the possibility of insane return value of hpet_calibrate() against SMI. (take 2)

Quoted 17 lines · Paul Gortmaker

drivers/char/hpet.c line 767

Quoted 11 lines · Yasunori Goto
drivers/char/hpet.c +11 -0
+	/*
+	 * Try to calibrate until return value becomes stable small value.
+	 * If SMI interruption occurs in calibration loop, the return value
+	 * will be big. This avoids its impact.
+	 */
+	do {
+		tmp = __hpet_calibrate(hpetp);
+		if (ret <= tmp)
+			break;
+		ret = tmp;
+	} while (1);

For what it is worth, if a situation arose where continued calls to hpet_calibrate() represented a monotonically decreasing function, (perhaps some insane power management?) you could be stuck in this function for an unbounded amount of time.

On my machine, the number of iterations of the loop in __hpet_calibarate (the value of i) is about 400, and since HPET reads/writes go to the southbridge, it cannot get much higher than about 1000 even on faster machines.

The value of (m - start) is approximately constant, as long as the loop runs for about 1 ms, so there cannot be too many distinct return values.

Consequently, the only way for perverse SMIs to produce more monotonically decreasing calibration values is to introduce delays that make the loop run longer than 1 ms, i.e., to eat most of the CPU time for at least several seconds (or longer if you want unbounded time). Even in the real world ;-), no laptop manufacturer is that insane.

Best regards,
Clemens

#13 lore raw

Re: [Patch] Fix the possibility of insane return value of hpet_calibrate() against SMI. (take 2)

Quoted 27 lines · Clemens Ladisch
Quoted 19 lines · Paul Gortmaker

drivers/char/hpet.c line 767

Quoted 12 lines · Yasunori Goto
drivers/char/hpet.c +11 -0
+	/*
+	 * Try to calibrate until return value becomes stable small value.
+	 * If SMI interruption occurs in calibration loop, the return value
+	 * will be big. This avoids its impact.
+	 */
+	do {
+		tmp = __hpet_calibrate(hpetp);
+		if (ret <= tmp)
+			break;
+		ret = tmp;
+	} while (1);

For what it is worth, if a situation arose where continued calls to hpet_calibrate() represented a monotonically decreasing function, (perhaps some insane power management?) you could be stuck in this function for an unbounded amount of time.

On my machine, the number of iterations of the loop in __hpet_calibarate (the value of i) is about 400, and since HPET reads/writes go to the southbridge, it cannot get much higher than about 1000 even on faster machines.

Quoted 9 lines

The value of (m - start) is approximately constant, as long as the loop runs for about 1 ms, so there cannot be too many distinct return values.

Consequently, the only way for perverse SMIs to produce more monotonically decreasing calibration values is to introduce delays that make the loop run longer than 1 ms, i.e., to eat most of the CPU time for at least several seconds (or longer if you want unbounded time). Even in the real world ;-), no laptop manufacturer is that insane.

Right - as I said, I didn't expect that it could ever happen, and your analysis above seems to help reinforce that, so we probably should be OK.

Thanks,
Paul.

Quoted 4 lines

Best regards,
Clemens

#14 lore raw

Re: [Patch] Fix the possibility of insane return value of hpet_calibrate() against SMI. (take 2)

In reply to Yasunori Goto
Quoted 38 lines · On Wed, 18 Mar 2009 11:47:04 +0900 Yasunori Goto <[email protected]> wrote:

hpet_calibrate() has a possibility of miss-calibration due to SMI. If SMI interrupts in the while loop of calibration, then return value will be big. This change calibrates until stabilizing by the return value with a small value.

---
 drivers/char/hpet.c |   21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

Index: hpet_test/drivers/char/hpet.c
===================================================================

drivers/char/hpet.c +9 -1
@@ -713,7 +713,7 @@
  */
 #define	TICK_CALIBRATE	(1000UL)
 
-static unsigned long hpet_calibrate(struct hpets *hpetp)
+static unsigned long __hpet_calibrate(struct hpets *hpetp)
 {
 	struct hpet_timer __iomem *timer = NULL;
 	unsigned long t, m, count, i, flags, start;
@@ -750,6 +750,25 @@
 	return (m - start) / i;
 }
 
+static unsigned long hpet_calibrate(struct hpets *hpetp)
+{
+	unsigned long ret = ~0UL, tmp;
+
+	/*
+	 * Try to calibrate until return value becomes stable small value.
+	 * If SMI interruption occurs in calibration loop, the return value
+	 * will be big. This avoids its impact.

drivers/char/hpet.c line 770

Quoted 10 lines
drivers/char/hpet.c +10 -0
+	 */
+	do {
+		tmp = __hpet_calibrate(hpetp);
+		if (ret <= tmp)
+			break;
+		ret = tmp;
+	} while (1);
+
+	return ret;
+}

Call me paranoid, but I'd like to see a maximum retry count here and an error message-and-continue if it is exceeded. To prevent mysterious boot-time lockups from misbehaving hpets, perhaps?

Also, style nit - I find

	for ( ; ; ) {
		...
	}

to be more readable than

	do {
		...
	} while (1);

and I believe the former is more common.

And

	unsigned long ret = -1;

has the same effect as

	unsigned long ret = ~0UL;

but is more maintainable - it doesn't subtly break if someone changes the type of `ret'. (This is a bit of an ugly C trick).

#15 lore raw

Re: [Patch] Fix the possibility of insane return value of hpet_calibrate() against SMI. (take 2)

Quoted 47 lines · [Re: [Patch] Fix the possibility of insane return value of hpet_calibrate()…
Quoted 44 lines · On Wed, 18 Mar 2009 11:47:04 +0900 Yasunori Goto <[email protected]> wrote:

hpet_calibrate() has a possibility of miss-calibration due to SMI. If SMI interrupts in the while loop of calibration, then return value will be big. This change calibrates until stabilizing by the return value with a small value.

---
 drivers/char/hpet.c |   21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

Index: hpet_test/drivers/char/hpet.c
===================================================================

drivers/char/hpet.c +15 -1
@@ -713,7 +713,7 @@
  */
 #define	TICK_CALIBRATE	(1000UL)
 
-static unsigned long hpet_calibrate(struct hpets *hpetp)
+static unsigned long __hpet_calibrate(struct hpets *hpetp)
 {
 	struct hpet_timer __iomem *timer = NULL;
 	unsigned long t, m, count, i, flags, start;
@@ -750,6 +750,25 @@
 	return (m - start) / i;
 }
 
+static unsigned long hpet_calibrate(struct hpets *hpetp)
+{
+	unsigned long ret = ~0UL, tmp;
+
+	/*
+	 * Try to calibrate until return value becomes stable small value.
+	 * If SMI interruption occurs in calibration loop, the return value
+	 * will be big. This avoids its impact.
+	 */
+	do {
+		tmp = __hpet_calibrate(hpetp);
+		if (ret <= tmp)
+			break;
+		ret = tmp;
Quoted 8 lines

drivers/char/hpet.c line 770

Quoted 4 lines
drivers/char/hpet.c +4 -0
+	} while (1);
+
+	return ret;
+}

Call me paranoid, but I'd like to see a maximum retry count here and an error message-and-continue if it is exceeded. To prevent mysterious boot-time lockups from misbehaving hpets, perhaps?

I'd mentioned that here:

http://lkml.org/lkml/2009/3/18/180

but the general consensus was that it was impossible and I was just being paranoid. :-)

Paul.

Quoted 29 lines

Also, style nit - I find

	for ( ; ; ) {
		...
	}

to be more readable than

	do {
		...
	} while (1);

and I believe the former is more common.

And

	unsigned long ret = -1;

has the same effect as

	unsigned long ret = ~0UL;

but is more maintainable - it doesn't subtly break if someone changes the type of `ret'. (This is a bit of an ugly C trick).

#16 lore raw
In reply to Yasunori Goto
Quoted 11 lines · Yasunori Goto
Quoted 3 lines

I've no sense of feel for how long each calibration run would take. Would doing it 5 times show up as a significant increase in the boot time for those that care about boot time being as quick as possible?

Hmm. The loop times is trade off against reliable value.... Though SMI is rare interruption, I don't know how frequent hypervisor's switch is.

Each calibration of this has 1 milli second.
Do you think 5 msec is too long?
If yes, how is 3 msec? Is it still too long?

I would suggest to instead repeat until the total cycle count stops
decreasing: That way we can avoid a SMI and yet in the best case only run the calibration 2 times.

Signature · 2 lines
Vojtech Pavlik
Director SuSE Labs