Merge "kthread, sched: Fix kthread_parkme() (again...)" (0b29bfbc) · Commits · e / devices / android_kernel_xiaomi_nabu

include/linux/sched.h

+45 −5

Original line number	Diff line number	Diff line
		@@ -113,17 +113,36 @@ struct task_group;

		#ifdef CONFIG_DEBUG_ATOMIC_SLEEP

		/*
		* Special states are those that do not use the normal wait-loop pattern. See
		* the comment with set_special_state().
		*/
		#define is_special_task_state(state) \
		((state) & (__TASK_STOPPED \| __TASK_TRACED \| TASK_PARKED \| TASK_DEAD))

		#define __set_current_state(state_value) \
		do { \
		WARN_ON_ONCE(is_special_task_state(state_value));\
		current->task_state_change = _THIS_IP_; \
		current->state = (state_value); \
		} while (0)

		#define set_current_state(state_value) \
		do { \
		WARN_ON_ONCE(is_special_task_state(state_value));\
		current->task_state_change = _THIS_IP_; \
		smp_store_mb(current->state, (state_value)); \
		} while (0)

		#define set_special_state(state_value) \
		do { \
		unsigned long flags; /* may shadow */ \
		WARN_ON_ONCE(!is_special_task_state(state_value)); \
		raw_spin_lock_irqsave(&current->pi_lock, flags); \
		current->task_state_change = _THIS_IP_; \
		current->state = (state_value); \
		raw_spin_unlock_irqrestore(&current->pi_lock, flags); \
		} while (0)
		#else
		/*
		* set_current_state() includes a barrier so that the write of current->state
		@@ -155,12 +174,33 @@ struct task_group;
		* once it observes the TASK_UNINTERRUPTIBLE store the waking CPU can issue a
		* TASK_RUNNING store which can collide with __set_current_state(TASK_RUNNING).
		*
		* This is obviously fine, since they both store the exact same value.
		* However, with slightly different timing the wakeup TASK_RUNNING store can
		* also collide with the TASK_UNINTERRUPTIBLE store. Loosing that store is not
		* a problem either because that will result in one extra go around the loop
		* and our @cond test will save the day.
		*
		* Also see the comments of try_to_wake_up().
		*/
		#define __set_current_state(state_value) do { current->state = (state_value); } while (0)
		#define set_current_state(state_value) smp_store_mb(current->state, (state_value))
		#define __set_current_state(state_value) \
		current->state = (state_value)

		#define set_current_state(state_value) \
		smp_store_mb(current->state, (state_value))

		/*
		* set_special_state() should be used for those states when the blocking task
		* can not use the regular condition based wait-loop. In that case we must
		* serialize against wakeups such that any possible in-flight TASK_RUNNING stores
		* will not collide with our state change.
		*/
		#define set_special_state(state_value) \
		do { \
		unsigned long flags; /* may shadow */ \
		raw_spin_lock_irqsave(&current->pi_lock, flags); \
		current->state = (state_value); \
		raw_spin_unlock_irqrestore(&current->pi_lock, flags); \
		} while (0)

		#endif

		/* Task command name length: */

include/linux/sched/signal.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -280,7 +280,7 @@ static inline void kernel_signal_stop(void)
		{
		spin_lock_irq(&current->sighand->siglock);
		if (current->jobctl & JOBCTL_STOP_DEQUEUED)
		__set_current_state(TASK_STOPPED);
		set_special_state(TASK_STOPPED);
		spin_unlock_irq(&current->sighand->siglock);

		schedule();

kernel/kthread.c

+38 −26

Original line number	Diff line number	Diff line
		@@ -53,7 +53,6 @@ enum KTHREAD_BITS {
		KTHREAD_IS_PER_CPU = 0,
		KTHREAD_SHOULD_STOP,
		KTHREAD_SHOULD_PARK,
		KTHREAD_IS_PARKED,
		};

		static inline void set_kthread_struct(void *kthread)
		@@ -169,14 +168,23 @@ void kthread_probe_data(struct task_struct task)

		static void __kthread_parkme(struct kthread *self)
		{
		__set_current_state(TASK_PARKED);
		while (test_bit(KTHREAD_SHOULD_PARK, &self->flags)) {
		if (!test_and_set_bit(KTHREAD_IS_PARKED, &self->flags))
		complete(&self->parked);
		for (;;) {
		/*
		* 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_PARKED);
		}
		clear_bit(KTHREAD_IS_PARKED, &self->flags);
		__set_current_state(TASK_RUNNING);
		}

		@@ -443,23 +451,20 @@ void kthread_unpark(struct task_struct *k)
		{
		struct kthread *kthread = to_kthread(k);

		clear_bit(KTHREAD_SHOULD_PARK, &kthread->flags);
		/*
		* We clear the IS_PARKED bit here as we don't wait
		* until the task has left the park code. So if we'd
		* park before that happens we'd see the IS_PARKED bit
		* which might be about to be cleared.
		*/
		if (test_and_clear_bit(KTHREAD_IS_PARKED, &kthread->flags)) {
		/*
		* Newly created kthread was parked when the CPU was offline.
		* The binding was lost and we need to set it again.
		*/
		if (test_bit(KTHREAD_IS_PER_CPU, &kthread->flags))
		__kthread_bind(k, kthread->cpu, TASK_PARKED);

		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);

		/**
		@@ -481,12 +486,19 @@ int kthread_park(struct task_struct *k)
		if (WARN_ON(k->flags & PF_EXITING))
		return -ENOSYS;

		if (!test_bit(KTHREAD_IS_PARKED, &kthread->flags)) {
		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

+15 −27

Original line number	Diff line number	Diff line
		@@ -29,6 +29,8 @@
		#include <linux/syscalls.h>
		#include <linux/irq.h>

		#include <linux/kthread.h>

		#include <asm/switch_to.h>
		#include <asm/tlb.h>
		#ifdef CONFIG_PARAVIRT
		@@ -2800,6 +2802,7 @@ static struct rq finish_task_switch(struct task_struct prev)
		put_task_stack(prev);

		put_task_struct(prev);

		}

		tick_nohz_task_switch();
		@@ -3571,23 +3574,8 @@ static void __sched notrace __schedule(bool preempt)

		void __noreturn do_task_dead(void)
		{
		/*
		* The setting of TASK_RUNNING by try_to_wake_up() may be delayed
		* when the following two conditions become true.
		* - There is race condition of mmap_sem (It is acquired by
		* exit_mm()), and
		* - SMI occurs before setting TASK_RUNINNG.
		* (or hypervisor of virtual machine switches to other guest)
		* As a result, we may become TASK_RUNNING after becoming TASK_DEAD
		*
		* To avoid it, we have to wait for releasing tsk->pi_lock which
		* is held by try_to_wake_up()
		*/
		raw_spin_lock_irq(&current->pi_lock);
		raw_spin_unlock_irq(&current->pi_lock);

		/* Causes final put_task_struct in finish_task_switch(): */
		__set_current_state(TASK_DEAD);
		set_special_state(TASK_DEAD);

		/* Tell freezer to ignore us: */
		current->flags \|= PF_NOFREEZE;

kernel/signal.c

+15 −2

Original line number	Diff line number	Diff line
		@@ -1833,14 +1833,27 @@ static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
		return;
		}

		set_special_state(TASK_TRACED);

		/*
		* We're committing to trapping. TRACED should be visible before
		* TRAPPING is cleared; otherwise, the tracer might fail do_wait().
		* Also, transition to TRACED and updates to ->jobctl should be
		* atomic with respect to siglock and should be done after the arch
		* hook as siglock is released and regrabbed across it.
		*
		* TRACER TRACEE
		*
		* ptrace_attach()
		* [L] wait_on_bit(JOBCTL_TRAPPING) [S] set_special_state(TRACED)
		* do_wait()
		* set_current_state() smp_wmb();
		* ptrace_do_wait()
		* wait_task_stopped()
		* task_stopped_code()
		* [L] task_is_traced() [S] task_clear_jobctl_trapping();
		*/
		set_current_state(TASK_TRACED);
		smp_wmb();

		current->last_siginfo = info;
		current->exit_code = exit_code;
		@@ -2048,7 +2061,7 @@ static bool do_signal_stop(int signr)
		if (task_participate_group_stop(current))
		notify = CLD_STOPPED;

		__set_current_state(TASK_STOPPED);
		set_special_state(TASK_STOPPED);
		spin_unlock_irq(&current->sighand->siglock);

		/*