Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6fb2489d authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'sched-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip 

Pull scheduler fixes from Thomas Gleixner:

 - The hopefully final fix for the reported race problems in
   kthread_parkme(). The previous attempt still left a hole and was
   partially wrong.

 - Plug a race in the remote tick mechanism which triggers a warning
   about updates not being done correctly. That's a false positive if
   the race condition is hit as the remote CPU is idle. Plug it by
   checking the condition again when holding run queue lock.

 - Fix a bug in the utilization estimation of a run queue which causes
   the estimation to be 0 when a run queue is throttled.

 - Advance the global expiration of the period timer when the timer is
   restarted after a idle period. Otherwise the expiry time is stale and
   the timer fires prematurely.

 - Cure the drift between the bandwidth timer and the runqueue
   accounting, which leads to bogus throttling of runqueues

 - Place the call to cpufreq_update_util() correctly so the function
   will observe the correct number of running RT tasks and not a stale
   one.

* 'sched-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  kthread, sched/core: Fix kthread_parkme() (again...)
  sched/util_est: Fix util_est_dequeue() for throttled cfs_rq
  sched/fair: Advance global expiration when period timer is restarted
  sched/fair: Fix bandwidth timer clock drift condition
  sched/rt: Fix call to cpufreq_update_util()
  sched/nohz: Skip remote tick on idle task entirely
parents f5c926b9 1cef1150

include/linux/kthread.h

+0 −1
Original line number Diff line number Diff line
@@ -62,7 +62,6 @@ void *kthread_probe_data(struct task_struct *k); 
int kthread_park(struct task_struct *k);

void kthread_unpark(struct task_struct *k);

void kthread_parkme(void);

void kthread_park_complete(struct task_struct *k);



int kthreadd(void *unused);

extern struct task_struct *kthreadd_task;

include/linux/sched.h

+1 −1
Original line number Diff line number Diff line
@@ -118,7 +118,7 @@ struct task_group; 
 * the comment with set_special_state().

 */

#define is_special_task_state(state)				\

	((state) & (__TASK_STOPPED | __TASK_TRACED | TASK_DEAD))

	((state) & (__TASK_STOPPED | __TASK_TRACED | TASK_PARKED | TASK_DEAD))



#define __set_current_state(state_value)			\

	do {							\

kernel/kthread.c

+24 −6
Original line number Diff line number Diff line
@@ -177,9 +177,20 @@ void *kthread_probe_data(struct task_struct *task) 
static void __kthread_parkme(struct kthread *self)

{

	for (;;) {

		set_current_state(TASK_PARKED);

		/*

		 * TASK_PARKED is a special state; we must serialize against

		 * possible pending wakeups to avoid store-store collisions on

		 * task->state.

		 *

		 * Such a collision might possibly result in the task state

		 * changin from TASK_PARKED and us failing the

		 * wait_task_inactive() in kthread_park().

		 */

		set_special_state(TASK_PARKED);

		if (!test_bit(KTHREAD_SHOULD_PARK, &self->flags))

			break;



		complete_all(&self->parked);

		schedule();

	}

	__set_current_state(TASK_RUNNING);
@@ -191,11 +202,6 @@ void kthread_parkme(void) 
}

EXPORT_SYMBOL_GPL(kthread_parkme);



void kthread_park_complete(struct task_struct *k)

{

	complete_all(&to_kthread(k)->parked);

}



static int kthread(void *_create)

{

	/* Copy data: it's on kthread's stack */
@@ -461,6 +467,9 @@ void kthread_unpark(struct task_struct *k) 


	reinit_completion(&kthread->parked);

	clear_bit(KTHREAD_SHOULD_PARK, &kthread->flags);

	/*

	 * __kthread_parkme() will either see !SHOULD_PARK or get the wakeup.

	 */

	wake_up_state(k, TASK_PARKED);

}

EXPORT_SYMBOL_GPL(kthread_unpark);
@@ -487,7 +496,16 @@ int kthread_park(struct task_struct *k) 
	set_bit(KTHREAD_SHOULD_PARK, &kthread->flags);

	if (k != current) {

		wake_up_process(k);

		/*

		 * Wait for __kthread_parkme() to complete(), this means we

		 * _will_ have TASK_PARKED and are about to call schedule().

		 */

		wait_for_completion(&kthread->parked);

		/*

		 * Now wait for that schedule() to complete and the task to

		 * get scheduled out.

		 */

		WARN_ON_ONCE(!wait_task_inactive(k, TASK_PARKED));

	}



	return 0;

kernel/sched/core.c

+32 −35
Original line number Diff line number Diff line
@@ -7,7 +7,6 @@ 
 */

#include "sched.h"



#include <linux/kthread.h>

#include <linux/nospec.h>



#include <linux/kcov.h>
@@ -2724,9 +2723,7 @@ static struct rq *finish_task_switch(struct task_struct *prev) 
		membarrier_mm_sync_core_before_usermode(mm);

		mmdrop(mm);

	}

	if (unlikely(prev_state & (TASK_DEAD|TASK_PARKED))) {

		switch (prev_state) {

		case TASK_DEAD:

	if (unlikely(prev_state == TASK_DEAD)) {

		if (prev->sched_class->task_dead)

			prev->sched_class->task_dead(prev);
@@ -2740,12 +2737,6 @@ static struct rq *finish_task_switch(struct task_struct *prev) 
		put_task_stack(prev);



		put_task_struct(prev);

			break;



		case TASK_PARKED:

			kthread_park_complete(prev);

			break;

		}

	}



	tick_nohz_task_switch();
@@ -3113,7 +3104,9 @@ static void sched_tick_remote(struct work_struct *work) 
	struct tick_work *twork = container_of(dwork, struct tick_work, work);

	int cpu = twork->cpu;

	struct rq *rq = cpu_rq(cpu);

	struct task_struct *curr;

	struct rq_flags rf;

	u64 delta;



	/*

	 * Handle the tick only if it appears the remote CPU is running in full
@@ -3122,13 +3115,15 @@ static void sched_tick_remote(struct work_struct *work) 
	 * statistics and checks timeslices in a time-independent way, regardless

	 * of when exactly it is running.

	 */

	if (!idle_cpu(cpu) && tick_nohz_tick_stopped_cpu(cpu)) {

		struct task_struct *curr;

		u64 delta;

	if (idle_cpu(cpu) || !tick_nohz_tick_stopped_cpu(cpu))

		goto out_requeue;



	rq_lock_irq(rq, &rf);

		update_rq_clock(rq);

	curr = rq->curr;

	if (is_idle_task(curr))

		goto out_unlock;



	update_rq_clock(rq);

	delta = rq_clock_task(rq) - curr->se.exec_start;



	/*
@@ -3137,9 +3132,11 @@ static void sched_tick_remote(struct work_struct *work) 
	 */

	WARN_ON_ONCE(delta > (u64)NSEC_PER_SEC * 3);

	curr->sched_class->task_tick(rq, curr, 0);



out_unlock:

	rq_unlock_irq(rq, &rf);

	}



out_requeue:

	/*

	 * Run the remote tick once per second (1Hz). This arbitrary

	 * frequency is large enough to avoid overload but short enough

kernel/sched/cpufreq_schedutil.c

+1 −1
Original line number Diff line number Diff line
@@ -192,7 +192,7 @@ static unsigned long sugov_aggregate_util(struct sugov_cpu *sg_cpu) 
{

	struct rq *rq = cpu_rq(sg_cpu->cpu);



	if (rq->rt.rt_nr_running)

	if (rt_rq_is_runnable(&rq->rt))

		return sg_cpu->max;



	/*