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

Commit 7e103ace 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 scheduler pull request comes with the following updates:

   - Prevent a divide by zero issue by validating the input value of
     sysctl_sched_time_avg

   - Make task state printing consistent all over the place and have
     explicit state characters for IDLE and PARKED so they wont be
     displayed as 'D' state which confuses tools"

* 'sched-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  sched/sysctl: Check user input value of sysctl_sched_time_avg
  sched/debug: Add explicit TASK_PARKED printing
  sched/debug: Ignore TASK_IDLE for SysRq-W
  sched/debug: Add explicit TASK_IDLE printing
  sched/tracing: Use common task-state helpers
  sched/tracing: Fix trace_sched_switch task-state printing
  sched/debug: Remove unused variable
  sched/debug: Convert TASK_state to hex
  sched/debug: Implement consistent task-state printing
parents 1c6f705b 5ccba44b

fs/proc/array.c

+15 −20
Original line number Diff line number Diff line
@@ -119,30 +119,25 @@ static inline void task_name(struct seq_file *m, struct task_struct *p) 
 * simple bit tests.

 */

static const char * const task_state_array[] = {

	"R (running)",		/*   0 */

	"S (sleeping)",		/*   1 */

	"D (disk sleep)",	/*   2 */

	"T (stopped)",		/*   4 */

	"t (tracing stop)",	/*   8 */

	"X (dead)",		/*  16 */

	"Z (zombie)",		/*  32 */



	/* states in TASK_REPORT: */

	"R (running)",		/* 0x00 */

	"S (sleeping)",		/* 0x01 */

	"D (disk sleep)",	/* 0x02 */

	"T (stopped)",		/* 0x04 */

	"t (tracing stop)",	/* 0x08 */

	"X (dead)",		/* 0x10 */

	"Z (zombie)",		/* 0x20 */

	"P (parked)",		/* 0x40 */



	/* states beyond TASK_REPORT: */

	"I (idle)",		/* 0x80 */

};



static inline const char *get_task_state(struct task_struct *tsk)

{

	unsigned int state = (tsk->state | tsk->exit_state) & TASK_REPORT;



	/*

	 * Parked tasks do not run; they sit in __kthread_parkme().

	 * Without this check, we would report them as running, which is

	 * clearly wrong, so we report them as sleeping instead.

	 */

	if (tsk->state == TASK_PARKED)

		state = TASK_INTERRUPTIBLE;



	BUILD_BUG_ON(1 + ilog2(TASK_REPORT) != ARRAY_SIZE(task_state_array)-1);



	return task_state_array[fls(state)];

	BUILD_BUG_ON(1 + ilog2(TASK_REPORT_MAX) != ARRAY_SIZE(task_state_array));

	return task_state_array[__get_task_state(tsk)];

}



static inline int get_task_umask(struct task_struct *tsk)

include/linux/sched.h

+40 −24
Original line number Diff line number Diff line
@@ -65,25 +65,23 @@ struct task_group; 
 */



/* Used in tsk->state: */

#define TASK_RUNNING			0

#define TASK_INTERRUPTIBLE		1

#define TASK_UNINTERRUPTIBLE		2

#define __TASK_STOPPED			4

#define __TASK_TRACED			8

#define TASK_RUNNING			0x0000

#define TASK_INTERRUPTIBLE		0x0001

#define TASK_UNINTERRUPTIBLE		0x0002

#define __TASK_STOPPED			0x0004

#define __TASK_TRACED			0x0008

/* Used in tsk->exit_state: */

#define EXIT_DEAD			16

#define EXIT_ZOMBIE			32

#define EXIT_DEAD			0x0010

#define EXIT_ZOMBIE			0x0020

#define EXIT_TRACE			(EXIT_ZOMBIE | EXIT_DEAD)

/* Used in tsk->state again: */

#define TASK_DEAD			64

#define TASK_WAKEKILL			128

#define TASK_WAKING			256

#define TASK_PARKED			512

#define TASK_NOLOAD			1024

#define TASK_NEW			2048

#define TASK_STATE_MAX			4096



#define TASK_STATE_TO_CHAR_STR		"RSDTtXZxKWPNn"

#define TASK_PARKED			0x0040

#define TASK_DEAD			0x0080

#define TASK_WAKEKILL			0x0100

#define TASK_WAKING			0x0200

#define TASK_NOLOAD			0x0400

#define TASK_NEW			0x0800

#define TASK_STATE_MAX			0x1000



/* Convenience macros for the sake of set_current_state: */

#define TASK_KILLABLE			(TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
@@ -99,7 +97,8 @@ struct task_group; 
/* get_task_state(): */

#define TASK_REPORT			(TASK_RUNNING | TASK_INTERRUPTIBLE | \

					 TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \

					 __TASK_TRACED | EXIT_ZOMBIE | EXIT_DEAD)

					 __TASK_TRACED | EXIT_DEAD | EXIT_ZOMBIE | \

					 TASK_PARKED)



#define task_is_traced(task)		((task->state & __TASK_TRACED) != 0)
@@ -1243,17 +1242,34 @@ static inline pid_t task_pgrp_nr(struct task_struct *tsk) 
	return task_pgrp_nr_ns(tsk, &init_pid_ns);

}



static inline char task_state_to_char(struct task_struct *task)

#define TASK_REPORT_IDLE	(TASK_REPORT + 1)

#define TASK_REPORT_MAX		(TASK_REPORT_IDLE << 1)



static inline unsigned int __get_task_state(struct task_struct *tsk)

{

	unsigned int tsk_state = READ_ONCE(tsk->state);

	unsigned int state = (tsk_state | tsk->exit_state) & TASK_REPORT;



	BUILD_BUG_ON_NOT_POWER_OF_2(TASK_REPORT_MAX);



	if (tsk_state == TASK_IDLE)

		state = TASK_REPORT_IDLE;



	return fls(state);

}



static inline char __task_state_to_char(unsigned int state)

{

	const char stat_nam[] = TASK_STATE_TO_CHAR_STR;

	unsigned long state = task->state;

	static const char state_char[] = "RSDTtXZPI";



	state = state ? __ffs(state) + 1 : 0;

	BUILD_BUG_ON(1 + ilog2(TASK_REPORT_MAX) != sizeof(state_char) - 1);



	/* Make sure the string lines up properly with the number of task states: */

	BUILD_BUG_ON(sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1);

	return state_char[state];

}



	return state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?';

static inline char task_state_to_char(struct task_struct *tsk)

{

	return __task_state_to_char(__get_task_state(tsk));

}



/**

include/trace/events/sched.h

+12 −7
Original line number Diff line number Diff line
@@ -114,7 +114,10 @@ static inline long __trace_sched_switch_state(bool preempt, struct task_struct * 
	 * Preemption ignores task state, therefore preempted tasks are always

	 * RUNNING (we will not have dequeued if state != RUNNING).

	 */

	return preempt ? TASK_RUNNING | TASK_STATE_MAX : p->state;

	if (preempt)

		return TASK_STATE_MAX;



	return __get_task_state(p);

}

#endif /* CREATE_TRACE_POINTS */
@@ -152,12 +155,14 @@ TRACE_EVENT(sched_switch, 


	TP_printk("prev_comm=%s prev_pid=%d prev_prio=%d prev_state=%s%s ==> next_comm=%s next_pid=%d next_prio=%d",

		__entry->prev_comm, __entry->prev_pid, __entry->prev_prio,

		__entry->prev_state & (TASK_STATE_MAX-1) ?

		  __print_flags(__entry->prev_state & (TASK_STATE_MAX-1), "|",

				{ 1, "S"} , { 2, "D" }, { 4, "T" }, { 8, "t" },

				{ 16, "Z" }, { 32, "X" }, { 64, "x" },

				{ 128, "K" }, { 256, "W" }, { 512, "P" },

				{ 1024, "N" }) : "R",



		(__entry->prev_state & (TASK_REPORT_MAX - 1)) ?

		  __print_flags(__entry->prev_state & (TASK_REPORT_MAX - 1), "|",

				{ 0x01, "S" }, { 0x02, "D" }, { 0x04, "T" },

				{ 0x08, "t" }, { 0x10, "X" }, { 0x20, "Z" },

				{ 0x40, "P" }, { 0x80, "I" }) :

		  "R",



		__entry->prev_state & TASK_STATE_MAX ? "+" : "",

		__entry->next_comm, __entry->next_pid, __entry->next_prio)

);

kernel/sched/core.c

+23 −1
Original line number Diff line number Diff line
@@ -5166,6 +5166,28 @@ void sched_show_task(struct task_struct *p) 
	put_task_stack(p);

}



static inline bool

state_filter_match(unsigned long state_filter, struct task_struct *p)

{

	/* no filter, everything matches */

	if (!state_filter)

		return true;



	/* filter, but doesn't match */

	if (!(p->state & state_filter))

		return false;



	/*

	 * When looking for TASK_UNINTERRUPTIBLE skip TASK_IDLE (allows

	 * TASK_KILLABLE).

	 */

	if (state_filter == TASK_UNINTERRUPTIBLE && p->state == TASK_IDLE)

		return false;



	return true;

}





void show_state_filter(unsigned long state_filter)

{

	struct task_struct *g, *p;
@@ -5188,7 +5210,7 @@ void show_state_filter(unsigned long state_filter) 
		 */

		touch_nmi_watchdog();

		touch_all_softlockup_watchdogs();

		if (!state_filter || (p->state & state_filter))

		if (state_filter_match(state_filter, p))

			sched_show_task(p);

	}

kernel/sched/debug.c

+0 −2
Original line number Diff line number Diff line
@@ -466,8 +466,6 @@ static char *task_group_path(struct task_group *tg) 
}

#endif



static const char stat_nam[] = TASK_STATE_TO_CHAR_STR;



static void

print_task(struct seq_file *m, struct rq *rq, struct task_struct *p)

{