[PATCH RT 0/2] [ANNOUNCE] 3.4.22-rt34-rc1 stable review

[PATCH RT 0/2] [ANNOUNCE] 3.4.22-rt34-rc1 stable review

[Steven Rostedt]

Dear RT Folks,

This is the RT stable review cycle of patch 3.4.22-rt34-rc1.

Please scream at me if I messed something up. Please test the patches too.

The -rc release will be uploaded to kernel.org and will be deleted when
the final release is out. This is just a review release (or release candidate).

The pre-releases will not be pushed to the git repository, only the
final release is.

If all goes well, this patch will be converted to the next main release
on 12/14/2012, let's hope it's not an unexpected journey!

Enjoy,

-- Steve


To build 3.4.22-rt34-rc1 directly, the following patches should be applied:

  http://www.kernel.org/pub/linux/kernel/v3.x/linux-3.4.tar.xz

  http://www.kernel.org/pub/linux/kernel/v3.x/patch-3.4.22.xz

  http://www.kernel.org/pub/linux/kernel/projects/rt/3.4/patch-3.4.22-rt34-rc1.patch.xz

You can also build from 3.4.22-rt33 by applying the incremental patch:

http://www.kernel.org/pub/linux/kernel/projects/rt/3.4/incr/patch-3.4.22-rt33-rt34-rc1.patch.xz


Changes from 3.4.22-rt33:

---


Steven Rostedt (1):
      Linux 3.4.22-rt34-rc1

Thomas Gleixner (1):
      sched: Queue RT tasks to head when prio drops

----
 kernel/sched/core.c |   16 ++++++++++++----
 localversion-rt     |    2 +-
 2 files changed, 13 insertions(+), 5 deletions(-)

[PATCH RT 1/2] sched: Queue RT tasks to head when prio drops

[Steven Rostedt]

[-- Attachment #1: 0001-sched-Queue-RT-tasks-to-head-when-prio-drops.patch --]
[-- Type: text/plain, Size: 2838 bytes --]

From: Thomas Gleixner <tglx@linutronix.de>

The following scenario does not work correctly:

Runqueue of CPU1 contains two runnable and pinned tasks:
	 T1: SCHED_FIFO, prio 80
	 T2: SCHED_FIFO, prio 80

T1 is on the cpu and executes the following syscalls (classic priority
ceiling scenario):

 sys_sched_setscheduler(pid(T1), SCHED_FIFO, .prio = 90);
 ...
 sys_sched_setscheduler(pid(T1), SCHED_FIFO, .prio = 80);
 ...

Now T1 gets preempted by T3 (SCHED_FIFO, prio 95). After T3 goes back
to sleep the scheduler picks T2. Surprise!

The same happens w/o actual preemption when T1 is forced into the
scheduler due to a sporadic NEED_RESCHED event. The scheduler invokes
pick_next_task() which returns T2. So T1 gets preempted and scheduled
out.

This happens because sched_setscheduler() dequeues T1 from the prio 90
list and then enqueues it on the tail of the prio 80 list behind T2.
This violates the POSIX spec and surprises user space which relies on
the guarantee that SCHED_FIFO tasks are not scheduled out unless they
give the CPU up voluntarily or are preempted by a higher priority
task. In the latter case the preempted task must get back on the CPU
after the preempting task schedules out again.

We fixed a similar issue already in commit 60db48c(sched: Queue a
deboosted task to the head of the RT prio queue). The same treatment
is necessary for sched_setscheduler().

While analyzing the problem I noticed that the fix in
rt_mutex_setprio() is one off. The head queueing depends on old
priority greater than new priority (user space view), but in fact it
needs to have the same treatment for equal priority. Instead of
blindly changing the condition to <= it's better to avoid the whole
dequeue/requeue business for the equal priority case completely.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: stable@vger.kernel.org
Cc: stable-rt@vger.kernel.org
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
---
 kernel/sched/core.c |   16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 1f9d6f5..054e669 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -4117,6 +4117,8 @@ void rt_mutex_setprio(struct task_struct *p, int prio)
 
 	trace_sched_pi_setprio(p, prio);
 	oldprio = p->prio;
+	if (oldprio == prio)
+		goto out_unlock;
 	prev_class = p->sched_class;
 	on_rq = p->on_rq;
 	running = task_current(rq, p);
@@ -4472,6 +4474,13 @@ recheck:
 		task_rq_unlock(rq, p, &flags);
 		goto recheck;
 	}
+
+	p->sched_reset_on_fork = reset_on_fork;
+
+	oldprio = p->prio;
+	if (oldprio == param->sched_priority)
+		goto out;
+
 	on_rq = p->on_rq;
 	running = task_current(rq, p);
 	if (on_rq)
@@ -4479,18 +4488,17 @@ recheck:
 	if (running)
 		p->sched_class->put_prev_task(rq, p);
 
-	p->sched_reset_on_fork = reset_on_fork;

[PATCH RT 1/2] sched: Queue RT tasks to head when prio drops

[Steven Rostedt]

[-- Attachment #1: 0001-sched-Queue-RT-tasks-to-head-when-prio-drops.patch --]
[-- Type: text/plain, Size: 3262 bytes --]

From: Thomas Gleixner <tglx@linutronix.de>

The following scenario does not work correctly:

Runqueue of CPU1 contains two runnable and pinned tasks:
	 T1: SCHED_FIFO, prio 80
	 T2: SCHED_FIFO, prio 80

T1 is on the cpu and executes the following syscalls (classic priority
ceiling scenario):

 sys_sched_setscheduler(pid(T1), SCHED_FIFO, .prio = 90);
 ...
 sys_sched_setscheduler(pid(T1), SCHED_FIFO, .prio = 80);
 ...

Now T1 gets preempted by T3 (SCHED_FIFO, prio 95). After T3 goes back
to sleep the scheduler picks T2. Surprise!

The same happens w/o actual preemption when T1 is forced into the
scheduler due to a sporadic NEED_RESCHED event. The scheduler invokes
pick_next_task() which returns T2. So T1 gets preempted and scheduled
out.

This happens because sched_setscheduler() dequeues T1 from the prio 90
list and then enqueues it on the tail of the prio 80 list behind T2.
This violates the POSIX spec and surprises user space which relies on
the guarantee that SCHED_FIFO tasks are not scheduled out unless they
give the CPU up voluntarily or are preempted by a higher priority
task. In the latter case the preempted task must get back on the CPU
after the preempting task schedules out again.

We fixed a similar issue already in commit 60db48c(sched: Queue a
deboosted task to the head of the RT prio queue). The same treatment
is necessary for sched_setscheduler().

While analyzing the problem I noticed that the fix in
rt_mutex_setprio() is one off. The head queueing depends on old
priority greater than new priority (user space view), but in fact it
needs to have the same treatment for equal priority. Instead of
blindly changing the condition to <= it's better to avoid the whole
dequeue/requeue business for the equal priority case completely.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: stable@vger.kernel.org
Cc: stable-rt@vger.kernel.org
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
---
 kernel/sched/core.c |   16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 1f9d6f5..054e669 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -4117,6 +4117,8 @@ void rt_mutex_setprio(struct task_struct *p, int prio)
 
 	trace_sched_pi_setprio(p, prio);
 	oldprio = p->prio;
+	if (oldprio == prio)
+		goto out_unlock;
 	prev_class = p->sched_class;
 	on_rq = p->on_rq;
 	running = task_current(rq, p);
@@ -4472,6 +4474,13 @@ recheck:
 		task_rq_unlock(rq, p, &flags);
 		goto recheck;
 	}
+
+	p->sched_reset_on_fork = reset_on_fork;
+
+	oldprio = p->prio;
+	if (oldprio == param->sched_priority)
+		goto out;
+
 	on_rq = p->on_rq;
 	running = task_current(rq, p);
 	if (on_rq)
@@ -4479,18 +4488,17 @@ recheck:
 	if (running)
 		p->sched_class->put_prev_task(rq, p);
 
-	p->sched_reset_on_fork = reset_on_fork;
-
-	oldprio = p->prio;
 	prev_class = p->sched_class;
 	__setscheduler(rq, p, policy, param->sched_priority);
 
 	if (running)
 		p->sched_class->set_curr_task(rq);
 	if (on_rq)
-		enqueue_task(rq, p, 0);
+		enqueue_task(rq, p, oldprio < param->sched_priority ?
+			     ENQUEUE_HEAD : 0);
 
 	check_class_changed(rq, p, prev_class, oldprio);
+out:
 	task_rq_unlock(rq, p, &flags);
 
 	rt_mutex_adjust_pi(p);
-- 
1.7.10.4

AW: [PATCH RT 1/2] sched: Queue RT tasks to head when prio drops

[eg Engleder Gerhard]

Hello,

we tested this patch successfully with 3.2.35-rt53-rc1. The failure
could not be reproduced in a 16 hours test run, so we are pretty
sure that the failure is gone.

Thanks for the quick inclusion of this pacth in stable-rt series!

Best Regards, Gerhard Engleder

-----Ursprüngliche Nachricht-----
Von: linux-rt-users-owner@vger.kernel.org [mailto:linux-rt-users-owner@vger.kernel.org] Im Auftrag von Steven Rostedt
Gesendet: Mittwoch, 12. Dezember 2012 01:46
An: linux-kernel@vger.kernel.org; linux-rt-users
Cc: Thomas Gleixner; Carsten Emde; John Kacur; stable@vger.kernel.org; stable-rt@vger.kernel.org
Betreff: [PATCH RT 1/2] sched: Queue RT tasks to head when prio drops

From: Thomas Gleixner <tglx@linutronix.de>

The following scenario does not work correctly:

Runqueue of CPU1 contains two runnable and pinned tasks:
	 T1: SCHED_FIFO, prio 80
	 T2: SCHED_FIFO, prio 80

T1 is on the cpu and executes the following syscalls (classic priority ceiling scenario):

 sys_sched_setscheduler(pid(T1), SCHED_FIFO, .prio = 90);  ...
 sys_sched_setscheduler(pid(T1), SCHED_FIFO, .prio = 80);  ...

Now T1 gets preempted by T3 (SCHED_FIFO, prio 95). After T3 goes back to sleep the scheduler picks T2. Surprise!

The same happens w/o actual preemption when T1 is forced into the scheduler due to a sporadic NEED_RESCHED event. The scheduler invokes
pick_next_task() which returns T2. So T1 gets preempted and scheduled out.

This happens because sched_setscheduler() dequeues T1 from the prio 90 list and then enqueues it on the tail of the prio 80 list behind T2.
This violates the POSIX spec and surprises user space which relies on the guarantee that SCHED_FIFO tasks are not scheduled out unless they give the CPU up voluntarily or are preempted by a higher priority task. In the latter case the preempted task must get back on the CPU after the preempting task schedules out again.

We fixed a similar issue already in commit 60db48c(sched: Queue a deboosted task to the head of the RT prio queue). The same treatment is necessary for sched_setscheduler().

While analyzing the problem I noticed that the fix in
rt_mutex_setprio() is one off. The head queueing depends on old priority greater than new priority (user space view), but in fact it needs to have the same treatment for equal priority. Instead of blindly changing the condition to <= it's better to avoid the whole dequeue/requeue business for the equal priority case completely.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: stable@vger.kernel.org
Cc: stable-rt@vger.kernel.org
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
---
 kernel/sched/core.c |   16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/kernel/sched/core.c b/kernel/sched/core.c index 1f9d6f5..054e669 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -4117,6 +4117,8 @@ void rt_mutex_setprio(struct task_struct *p, int prio)
 
 	trace_sched_pi_setprio(p, prio);
 	oldprio = p->prio;
+	if (oldprio == prio)
+		goto out_unlock;
 	prev_class = p->sched_class;
 	on_rq = p->on_rq;
 	running = task_current(rq, p);
@@ -4472,6 +4474,13 @@ recheck:
 		task_rq_unlock(rq, p, &flags);
 		goto recheck;
 	}
+
+	p->sched_reset_on_fork = reset_on_fork;
+
+	oldprio = p->prio;
+	if (oldprio == param->sched_priority)
+		goto out;
+
 	on_rq = p->on_rq;
 	running = task_current(rq, p);
 	if (on_rq)
@@ -4479,18 +4488,17 @@ recheck:
 	if (running)
 		p->sched_class->put_prev_task(rq, p);
 
-	p->sched_reset_on_fork = reset_on_fork;
-
-	oldprio = p->prio;
 	prev_class = p->sched_class;
 	__setscheduler(rq, p, policy, param->sched_priority);
 
 	if (running)
 		p->sched_class->set_curr_task(rq);
 	if (on_rq)
-		enqueue_task(rq, p, 0);
+		enqueue_task(rq, p, oldprio < param->sched_priority ?
+			     ENQUEUE_HEAD : 0);
 
 	check_class_changed(rq, p, prev_class, oldprio);
+out:
 	task_rq_unlock(rq, p, &flags);
 
 	rt_mutex_adjust_pi(p);
--
1.7.10.4


--
To unsubscribe from this list: send the line "unsubscribe linux-rt-users" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
--
To unsubscribe from this list: send the line "unsubscribe linux-rt-users" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: AW: [PATCH RT 1/2] sched: Queue RT tasks to head when prio drops

[Steven Rostedt]

On Fri, 2012-12-14 at 09:13 +0100, eg Engleder Gerhard wrote:
> Hello,
> 
> we tested this patch successfully with 3.2.35-rt53-rc1. The failure
> could not be reproduced in a 16 hours test run, so we are pretty
> sure that the failure is gone.
> 
> Thanks for the quick inclusion of this pacth in stable-rt series!

Unfortunately there seems to be a bug in the patch, and it needs to be
fixed in Thomas's tree before I take it.


> diff --git a/kernel/sched/core.c b/kernel/sched/core.c index 1f9d6f5..054e669 100644
> --- a/kernel/sched/core.c
> +++ b/kernel/sched/core.c
> @@ -4117,6 +4117,8 @@ void rt_mutex_setprio(struct task_struct *p, int prio)
>  
>  	trace_sched_pi_setprio(p, prio);
>  	oldprio = p->prio;
> +	if (oldprio == prio)
> +		goto out_unlock;
>  	prev_class = p->sched_class;
>  	on_rq = p->on_rq;
>  	running = task_current(rq, p);
> @@ -4472,6 +4474,13 @@ recheck:
>  		task_rq_unlock(rq, p, &flags);
>  		goto recheck;
>  	}
> +
> +	p->sched_reset_on_fork = reset_on_fork;
> +
> +	oldprio = p->prio;
> +	if (oldprio == param->sched_priority)

Needs to be:

	if (oldprio == (MAX_RT_PRIO - 1) - param->sched_priority)


-- Steve

> +		goto out;
> +
>  	on_rq = p->on_rq;
>  	running = task_current(rq, p);
>  	if (on_rq)
> @@ -4479,18 +4488,17 @@ recheck:
>  	if (running)
>  		p->sched_class->put_prev_task(rq, p);
>  
> -	p->sched_reset_on_fork = reset_on_fork;
> -
> -	oldprio = p->prio;
>  	prev_class = p->sched_class;
>  	__setscheduler(rq, p, policy, param->sched_priority);
>  
>  	if (running)
>  		p->sched_class->set_curr_task(rq);
>  	if (on_rq)
> -		enqueue_task(rq, p, 0);
> +		enqueue_task(rq, p, oldprio < param->sched_priority ?
> +			     ENQUEUE_HEAD : 0);
>  
>  	check_class_changed(rq, p, prev_class, oldprio);
> +out:
>  	task_rq_unlock(rq, p, &flags);
>  
>  	rt_mutex_adjust_pi(p);
> --
> 1.7.10.4
> 
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-rt-users" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH RT 2/2] Linux 3.4.22-rt34-rc1

[Steven Rostedt]

[-- Attachment #1: 0002-Linux-3.4.22-rt34-rc1.patch --]
[-- Type: text/plain, Size: 287 bytes --]

From: Steven Rostedt <srostedt@redhat.com>

---
 localversion-rt |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/localversion-rt b/localversion-rt
index e1d8362..c2c1097 100644
--- a/localversion-rt
+++ b/localversion-rt
@@ -1 +1 @@
--rt33
+-rt34-rc1
-- 
1.7.10.4

Re: [PATCH RT 0/2] [ANNOUNCE] 3.4.22-rt34-rc1 stable review

[Steven Rostedt]

On Tue, 2012-12-11 at 19:45 -0500, Steven Rostedt wrote:
> Dear RT Folks,
> 
> This is the RT stable review cycle of patch 3.4.22-rt34-rc1.
> 
> Please scream at me if I messed something up. Please test the patches too.
> 
> The -rc release will be uploaded to kernel.org and will be deleted when
> the final release is out. This is just a review release (or release candidate).
> 
> The pre-releases will not be pushed to the git repository, only the
> final release is.
> 
> If all goes well, this patch will be converted to the next main release
> on 12/14/2012, let's hope it's not an unexpected journey!
> 

Sure enough I was taken on an unexpected journey today. Unfortunately it
wasn't in the theaters.

I guess there's a small bug with one of the patches, with a fix sent to
me by Mike. This needs to be in Thomas's latest before it goes into
stable.

        oldprio = p->prio;
-       if (oldprio == param->sched_priority)
+       if (oldprio == (MAX_RT_PRIO - 1) - param->sched_priority)
                goto out;


-- Steve