[PATCH] xen/x86: don't lose event interrupts

[PATCH] xen/x86: don't lose event interrupts

[Stefano Stabellini]

On slow platforms with unreliable TSC, such as QEMU emulated machines,
it is possible for the kernel to request the next event in the past. In
that case, in the current implementation of xen_vcpuop_clockevent, we
simply return -ETIME. To be precise the Xen returns -ETIME and we pass
it on. However the result of this is a missed event, which simply causes
the kernel to hang.

Instead it is better to always ask the hypervisor for a timer event,
even if the timeout is in the past. That way there are no lost
interrupts and the kernel survives. To do that, remove the
VCPU_SSHOTTMR_future flag.

Signed-off-by: Stefano Stabellini <sstabellini@kernel.org>

diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
index a0a4e55..6deba5b 100644
--- a/arch/x86/xen/time.c
+++ b/arch/x86/xen/time.c
@@ -290,11 +290,11 @@ static int xen_vcpuop_set_next_event(unsigned long delta,
 	WARN_ON(!clockevent_state_oneshot(evt));
 
 	single.timeout_abs_ns = get_abs_timeout(delta);
-	single.flags = VCPU_SSHOTTMR_future;
+	/* Get an event anyway, even if the timeout is already expired */
+	single.flags = 0;
 
 	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single);
-
-	BUG_ON(ret != 0 && ret != -ETIME);
+	BUG_ON(ret != 0);
 
 	return ret;
 }

Re: [PATCH] xen/x86: don't lose event interrupts

[Juergen Gross]

On 16/04/16 03:23, Stefano Stabellini wrote:
> On slow platforms with unreliable TSC, such as QEMU emulated machines,
> it is possible for the kernel to request the next event in the past. In
> that case, in the current implementation of xen_vcpuop_clockevent, we
> simply return -ETIME. To be precise the Xen returns -ETIME and we pass
> it on. However the result of this is a missed event, which simply causes
> the kernel to hang.
> 
> Instead it is better to always ask the hypervisor for a timer event,
> even if the timeout is in the past. That way there are no lost
> interrupts and the kernel survives. To do that, remove the
> VCPU_SSHOTTMR_future flag.
> 
> Signed-off-by: Stefano Stabellini <sstabellini@kernel.org>

Acked-by: Juergen Gross <jgross@suse.com>

> 
> diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
> index a0a4e55..6deba5b 100644
> --- a/arch/x86/xen/time.c
> +++ b/arch/x86/xen/time.c
> @@ -290,11 +290,11 @@ static int xen_vcpuop_set_next_event(unsigned long delta,
>  	WARN_ON(!clockevent_state_oneshot(evt));
>  
>  	single.timeout_abs_ns = get_abs_timeout(delta);
> -	single.flags = VCPU_SSHOTTMR_future;
> +	/* Get an event anyway, even if the timeout is already expired */
> +	single.flags = 0;
>  
>  	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single);
> -
> -	BUG_ON(ret != 0 && ret != -ETIME);
> +	BUG_ON(ret != 0);
>  
>  	return ret;
>  }
> 


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

Re: [PATCH] xen/x86: don't lose event interrupts

[Juergen Gross]

On 16/04/16 03:23, Stefano Stabellini wrote:
> On slow platforms with unreliable TSC, such as QEMU emulated machines,
> it is possible for the kernel to request the next event in the past. In
> that case, in the current implementation of xen_vcpuop_clockevent, we
> simply return -ETIME. To be precise the Xen returns -ETIME and we pass
> it on. However the result of this is a missed event, which simply causes
> the kernel to hang.
> 
> Instead it is better to always ask the hypervisor for a timer event,
> even if the timeout is in the past. That way there are no lost
> interrupts and the kernel survives. To do that, remove the
> VCPU_SSHOTTMR_future flag.
> 
> Signed-off-by: Stefano Stabellini <sstabellini@kernel.org>

Acked-by: Juergen Gross <jgross@suse.com>

> 
> diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
> index a0a4e55..6deba5b 100644
> --- a/arch/x86/xen/time.c
> +++ b/arch/x86/xen/time.c
> @@ -290,11 +290,11 @@ static int xen_vcpuop_set_next_event(unsigned long delta,
>  	WARN_ON(!clockevent_state_oneshot(evt));
>  
>  	single.timeout_abs_ns = get_abs_timeout(delta);
> -	single.flags = VCPU_SSHOTTMR_future;
> +	/* Get an event anyway, even if the timeout is already expired */
> +	single.flags = 0;
>  
>  	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single);
> -
> -	BUG_ON(ret != 0 && ret != -ETIME);
> +	BUG_ON(ret != 0);
>  
>  	return ret;
>  }
> 

Re: [PATCH] xen/x86: don't lose event interrupts

[Stefano Stabellini]

On Thu, 21 Apr 2016, Juergen Gross wrote:
> On 16/04/16 03:23, Stefano Stabellini wrote:
> > On slow platforms with unreliable TSC, such as QEMU emulated machines,
> > it is possible for the kernel to request the next event in the past. In
> > that case, in the current implementation of xen_vcpuop_clockevent, we
> > simply return -ETIME. To be precise the Xen returns -ETIME and we pass
> > it on. However the result of this is a missed event, which simply causes
> > the kernel to hang.
> > 
> > Instead it is better to always ask the hypervisor for a timer event,
> > even if the timeout is in the past. That way there are no lost
> > interrupts and the kernel survives. To do that, remove the
> > VCPU_SSHOTTMR_future flag.
> > 
> > Signed-off-by: Stefano Stabellini <sstabellini@kernel.org>
> 
> Acked-by: Juergen Gross <jgross@suse.com>

I committed it to xentip/for-linus-4.7


> > diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
> > index a0a4e55..6deba5b 100644
> > --- a/arch/x86/xen/time.c
> > +++ b/arch/x86/xen/time.c
> > @@ -290,11 +290,11 @@ static int xen_vcpuop_set_next_event(unsigned long delta,
> >  	WARN_ON(!clockevent_state_oneshot(evt));
> >  
> >  	single.timeout_abs_ns = get_abs_timeout(delta);
> > -	single.flags = VCPU_SSHOTTMR_future;
> > +	/* Get an event anyway, even if the timeout is already expired */
> > +	single.flags = 0;
> >  
> >  	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single);
> > -
> > -	BUG_ON(ret != 0 && ret != -ETIME);
> > +	BUG_ON(ret != 0);
> >  
> >  	return ret;
> >  }
> > 
> 

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

Re: [PATCH] xen/x86: don't lose event interrupts

[Stefano Stabellini]

On Thu, 21 Apr 2016, Juergen Gross wrote:
> On 16/04/16 03:23, Stefano Stabellini wrote:
> > On slow platforms with unreliable TSC, such as QEMU emulated machines,
> > it is possible for the kernel to request the next event in the past. In
> > that case, in the current implementation of xen_vcpuop_clockevent, we
> > simply return -ETIME. To be precise the Xen returns -ETIME and we pass
> > it on. However the result of this is a missed event, which simply causes
> > the kernel to hang.
> > 
> > Instead it is better to always ask the hypervisor for a timer event,
> > even if the timeout is in the past. That way there are no lost
> > interrupts and the kernel survives. To do that, remove the
> > VCPU_SSHOTTMR_future flag.
> > 
> > Signed-off-by: Stefano Stabellini <sstabellini@kernel.org>
> 
> Acked-by: Juergen Gross <jgross@suse.com>

I committed it to xentip/for-linus-4.7


> > diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
> > index a0a4e55..6deba5b 100644
> > --- a/arch/x86/xen/time.c
> > +++ b/arch/x86/xen/time.c
> > @@ -290,11 +290,11 @@ static int xen_vcpuop_set_next_event(unsigned long delta,
> >  	WARN_ON(!clockevent_state_oneshot(evt));
> >  
> >  	single.timeout_abs_ns = get_abs_timeout(delta);
> > -	single.flags = VCPU_SSHOTTMR_future;
> > +	/* Get an event anyway, even if the timeout is already expired */
> > +	single.flags = 0;
> >  
> >  	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single);
> > -
> > -	BUG_ON(ret != 0 && ret != -ETIME);
> > +	BUG_ON(ret != 0);
> >  
> >  	return ret;
> >  }
> > 
> 

[PATCH] xen/x86: don't lose event interrupts

[Stefano Stabellini]

On slow platforms with unreliable TSC, such as QEMU emulated machines,
it is possible for the kernel to request the next event in the past. In
that case, in the current implementation of xen_vcpuop_clockevent, we
simply return -ETIME. To be precise the Xen returns -ETIME and we pass
it on. However the result of this is a missed event, which simply causes
the kernel to hang.

Instead it is better to always ask the hypervisor for a timer event,
even if the timeout is in the past. That way there are no lost
interrupts and the kernel survives. To do that, remove the
VCPU_SSHOTTMR_future flag.

Signed-off-by: Stefano Stabellini <sstabellini@kernel.org>

diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
index a0a4e55..6deba5b 100644
--- a/arch/x86/xen/time.c
+++ b/arch/x86/xen/time.c
@@ -290,11 +290,11 @@ static int xen_vcpuop_set_next_event(unsigned long delta,
 	WARN_ON(!clockevent_state_oneshot(evt));
 
 	single.timeout_abs_ns = get_abs_timeout(delta);
-	single.flags = VCPU_SSHOTTMR_future;
+	/* Get an event anyway, even if the timeout is already expired */
+	single.flags = 0;
 
 	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single);
-
-	BUG_ON(ret != 0 && ret != -ETIME);
+	BUG_ON(ret != 0);
 
 	return ret;
 }

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

[PATCH] xen/x86: don't lose event interrupts

[Stefano Stabellini]

xen/x86: don't lose event interrupts

On slow platforms with unreliable TSC, such as QEMU emulated machines,
it is possible for the FreeBSD kernel to request the next event in the
past. In that case, in the current implementation of
xentimer_vcpu_start_timer, we simply return -ETIME. To be precise Xen
returns -ETIME and we pass it on. As a consequence we need to loop
around to function to make sure that the timer is properly set.

Instead it is better to always ask the hypervisor for a timer event,
even if the timeout is past. To do that, remove the VCPU_SSHOTTMR_future
flag.

Signed-off-by: Stefano Stabellini <sstabellini@kernel.org>

diff --git a/sys/dev/xen/timer/timer.c b/sys/dev/xen/timer/timer.c
index 53aff0a..db9b19b 100644
--- a/sys/dev/xen/timer/timer.c
+++ b/sys/dev/xen/timer/timer.c
@@ -267,7 +267,8 @@ xentimer_vcpu_start_timer(int vcpu, uint64_t next_time)
 	struct vcpu_set_singleshot_timer single;
 
 	single.timeout_abs_ns = next_time;
-	single.flags          = VCPU_SSHOTTMR_future;
+	/* Get an event anyway, even if the timeout is already expired */
+	single.flags          = 0;
 	return (HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, vcpu, &single));
 }
 

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

Re: [PATCH] xen/x86: don't lose event interrupts

[Roger Pau Monné]

On Thu, Apr 21, 2016 at 02:34:25PM +0100, Stefano Stabellini wrote:
> xen/x86: don't lose event interrupts
> 
> On slow platforms with unreliable TSC, such as QEMU emulated machines,
> it is possible for the FreeBSD kernel to request the next event in the
> past. In that case, in the current implementation of
> xentimer_vcpu_start_timer, we simply return -ETIME. To be precise Xen
> returns -ETIME and we pass it on. As a consequence we need to loop
> around to function to make sure that the timer is properly set.
> 
> Instead it is better to always ask the hypervisor for a timer event,
> even if the timeout is past. To do that, remove the VCPU_SSHOTTMR_future
> flag.
> 
> Signed-off-by: Stefano Stabellini <sstabellini@kernel.org>

Thanks, it's now committed:

https://svnweb.freebsd.org/base?view=revision&revision=298926

Roger.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel