[mirror_ubuntu-bionic-kernel.git] / include / linux / init_task.h

#ifndef _LINUX__INIT_TASK_H
#define _LINUX__INIT_TASK_H

#include <linux/rcupdate.h>
#include <linux/irqflags.h>
#include <linux/utsname.h>
#include <linux/lockdep.h>
#include <linux/ftrace.h>
#include <linux/ipc.h>
#include <linux/pid_namespace.h>
#include <linux/user_namespace.h>
#include <linux/securebits.h>
#include <linux/seqlock.h>
#include <linux/rbtree.h>
#include <net/net_namespace.h>
#include <linux/sched/rt.h>

#ifdef CONFIG_SMP
# define INIT_PUSHABLE_TASKS(tsk)					\
	.pushable_tasks = PLIST_NODE_INIT(tsk.pushable_tasks, MAX_PRIO),
#else
# define INIT_PUSHABLE_TASKS(tsk)
#endif

extern struct files_struct init_files;
extern struct fs_struct init_fs;

#ifdef CONFIG_CGROUPS
#define INIT_GROUP_RWSEM(sig)						\
	.group_rwsem = __RWSEM_INITIALIZER(sig.group_rwsem),
#else
#define INIT_GROUP_RWSEM(sig)
#endif

#ifdef CONFIG_CPUSETS
#define INIT_CPUSET_SEQ(tsk)							\
	.mems_allowed_seq = SEQCNT_ZERO(tsk.mems_allowed_seq),
#else
#define INIT_CPUSET_SEQ(tsk)
#endif

#define INIT_SIGNALS(sig) {						\
	.nr_threads	= 1,						\
	.wait_chldexit	= __WAIT_QUEUE_HEAD_INITIALIZER(sig.wait_chldexit),\
	.shared_pending	= { 						\
		.list = LIST_HEAD_INIT(sig.shared_pending.list),	\
		.signal =  {{0}}},					\
	.posix_timers	 = LIST_HEAD_INIT(sig.posix_timers),		\
	.cpu_timers	= INIT_CPU_TIMERS(sig.cpu_timers),		\
	.rlim		= INIT_RLIMITS,					\
	.cputimer	= { 						\
		.cputime = INIT_CPUTIME,				\
		.running = 0,						\
		.lock = __RAW_SPIN_LOCK_UNLOCKED(sig.cputimer.lock),	\
	},								\
	.cred_guard_mutex =						\
		 __MUTEX_INITIALIZER(sig.cred_guard_mutex),		\
	INIT_GROUP_RWSEM(sig)						\
}

extern struct nsproxy init_nsproxy;

#define INIT_SIGHAND(sighand) {						\
	.count		= ATOMIC_INIT(1), 				\
	.action		= { { { .sa_handler = SIG_DFL, } }, },		\
	.siglock	= __SPIN_LOCK_UNLOCKED(sighand.siglock),	\
	.signalfd_wqh	= __WAIT_QUEUE_HEAD_INITIALIZER(sighand.signalfd_wqh),	\
}

extern struct group_info init_groups;

#define INIT_STRUCT_PID {						\
	.count 		= ATOMIC_INIT(1),				\
	.tasks		= {						\
		{ .first = NULL },					\
		{ .first = NULL },					\
		{ .first = NULL },					\
	},								\
	.level		= 0,						\
	.numbers	= { {						\
		.nr		= 0,					\
		.ns		= &init_pid_ns,				\
		.pid_chain	= { .next = NULL, .pprev = NULL },	\
	}, }								\
}

#define INIT_PID_LINK(type) 					\
{								\
	.node = {						\
		.next = NULL,					\
		.pprev = NULL,					\
	},							\
	.pid = &init_struct_pid,				\
}

#ifdef CONFIG_AUDITSYSCALL
#define INIT_IDS \
	.loginuid = INVALID_UID, \
	.sessionid = -1,
#else
#define INIT_IDS
#endif

#ifdef CONFIG_RCU_BOOST
#define INIT_TASK_RCU_BOOST()						\
	.rcu_boost_mutex = NULL,
#else
#define INIT_TASK_RCU_BOOST()
#endif
#ifdef CONFIG_TREE_PREEMPT_RCU
#define INIT_TASK_RCU_TREE_PREEMPT()					\
	.rcu_blocked_node = NULL,
#else
#define INIT_TASK_RCU_TREE_PREEMPT(tsk)
#endif
#ifdef CONFIG_PREEMPT_RCU
#define INIT_TASK_RCU_PREEMPT(tsk)					\
	.rcu_read_lock_nesting = 0,					\
	.rcu_read_unlock_special = 0,					\
	.rcu_node_entry = LIST_HEAD_INIT(tsk.rcu_node_entry),		\
	INIT_TASK_RCU_TREE_PREEMPT()					\
	INIT_TASK_RCU_BOOST()
#else
#define INIT_TASK_RCU_PREEMPT(tsk)
#endif

extern struct cred init_cred;

extern struct task_group root_task_group;

#ifdef CONFIG_CGROUP_SCHED
# define INIT_CGROUP_SCHED(tsk)						\
	.sched_task_group = &root_task_group,
#else
# define INIT_CGROUP_SCHED(tsk)
#endif

#ifdef CONFIG_PERF_EVENTS
# define INIT_PERF_EVENTS(tsk)						\
	.perf_event_mutex = 						\
		 __MUTEX_INITIALIZER(tsk.perf_event_mutex),		\
	.perf_event_list = LIST_HEAD_INIT(tsk.perf_event_list),
#else
# define INIT_PERF_EVENTS(tsk)
#endif

#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
# define INIT_VTIME(tsk)						\
	.vtime_seqlock = __SEQLOCK_UNLOCKED(tsk.vtime_seqlock),	\
	.vtime_snap = 0,				\
	.vtime_snap_whence = VTIME_SYS,
#else
# define INIT_VTIME(tsk)
#endif

#define INIT_TASK_COMM "swapper"

#ifdef CONFIG_RT_MUTEXES
# define INIT_RT_MUTEXES(tsk)						\
	.pi_waiters = RB_ROOT,						\
	.pi_waiters_leftmost = NULL,
#else
# define INIT_RT_MUTEXES(tsk)
#endif

/*
 *  INIT_TASK is used to set up the first task table, touch at
 * your own risk!. Base=0, limit=0x1fffff (=2MB)
 */
#define INIT_TASK(tsk)	\
{									\
	.state		= 0,						\
	.stack		= &init_thread_info,				\
	.usage		= ATOMIC_INIT(2),				\
	.flags		= PF_KTHREAD,					\
	.prio		= MAX_PRIO-20,					\
	.static_prio	= MAX_PRIO-20,					\
	.normal_prio	= MAX_PRIO-20,					\
	.policy		= SCHED_NORMAL,					\
	.cpus_allowed	= CPU_MASK_ALL,					\
	.nr_cpus_allowed= NR_CPUS,					\
	.mm		= NULL,						\
	.active_mm	= &init_mm,					\
	.se		= {						\
		.group_node 	= LIST_HEAD_INIT(tsk.se.group_node),	\
	},								\
	.rt		= {						\
		.run_list	= LIST_HEAD_INIT(tsk.rt.run_list),	\
		.time_slice	= RR_TIMESLICE,				\
	},								\
	.tasks		= LIST_HEAD_INIT(tsk.tasks),			\
	INIT_PUSHABLE_TASKS(tsk)					\
	INIT_CGROUP_SCHED(tsk)						\
	.ptraced	= LIST_HEAD_INIT(tsk.ptraced),			\
	.ptrace_entry	= LIST_HEAD_INIT(tsk.ptrace_entry),		\
	.real_parent	= &tsk,						\
	.parent		= &tsk,						\
	.children	= LIST_HEAD_INIT(tsk.children),			\
	.sibling	= LIST_HEAD_INIT(tsk.sibling),			\
	.group_leader	= &tsk,						\
	RCU_POINTER_INITIALIZER(real_cred, &init_cred),			\
	RCU_POINTER_INITIALIZER(cred, &init_cred),			\
	.comm		= INIT_TASK_COMM,				\
	.thread		= INIT_THREAD,					\
	.fs		= &init_fs,					\
	.files		= &init_files,					\
	.signal		= &init_signals,				\
	.sighand	= &init_sighand,				\
	.nsproxy	= &init_nsproxy,				\
	.pending	= {						\
		.list = LIST_HEAD_INIT(tsk.pending.list),		\
		.signal = {{0}}},					\
	.blocked	= {{0}},					\
	.alloc_lock	= __SPIN_LOCK_UNLOCKED(tsk.alloc_lock),		\
	.journal_info	= NULL,						\
	.cpu_timers	= INIT_CPU_TIMERS(tsk.cpu_timers),		\
	.pi_lock	= __RAW_SPIN_LOCK_UNLOCKED(tsk.pi_lock),	\
	.timer_slack_ns = 50000, /* 50 usec default slack */		\
	.pids = {							\
		[PIDTYPE_PID]  = INIT_PID_LINK(PIDTYPE_PID),		\
		[PIDTYPE_PGID] = INIT_PID_LINK(PIDTYPE_PGID),		\
		[PIDTYPE_SID]  = INIT_PID_LINK(PIDTYPE_SID),		\
	},								\
	.thread_group	= LIST_HEAD_INIT(tsk.thread_group),		\
	INIT_IDS							\
	INIT_PERF_EVENTS(tsk)						\
	INIT_TRACE_IRQFLAGS						\
	INIT_LOCKDEP							\
	INIT_FTRACE_GRAPH						\
	INIT_TRACE_RECURSION						\
	INIT_TASK_RCU_PREEMPT(tsk)					\
	INIT_CPUSET_SEQ(tsk)						\
	INIT_RT_MUTEXES(tsk)						\
	INIT_VTIME(tsk)							\
}


#define INIT_CPU_TIMERS(cpu_timers)					\
{									\
	LIST_HEAD_INIT(cpu_timers[0]),					\
	LIST_HEAD_INIT(cpu_timers[1]),					\
	LIST_HEAD_INIT(cpu_timers[2]),					\
}

/* Attach to the init_task data structure for proper alignment */
#define __init_task_data __attribute__((__section__(".data..init_task")))


#endif
Commit	Line	Data
1da177e4 LT	1	#ifndef _LINUX__INIT_TASK_H
	2	#define _LINUX__INIT_TASK_H
	3
ab2af1f5	4	#include <linux/rcupdate.h>
de30a2b3	5	#include <linux/irqflags.h>
4865ecf1	6	#include <linux/utsname.h>
fbb9ce95	7	#include <linux/lockdep.h>
5ac9f622	8	#include <linux/ftrace.h>
73ea4130	9	#include <linux/ipc.h>
9a575a92	10	#include <linux/pid_namespace.h>
acce292c	11	#include <linux/user_namespace.h>
3898b1b4	12	#include <linux/securebits.h>
6a61671b	13	#include <linux/seqlock.h>
fb00aca4	14	#include <linux/rbtree.h>
772698f6	15	#include <net/net_namespace.h>
77852fea	16	#include <linux/sched/rt.h>
1da177e4	17
806c09a7 DF	18	#ifdef CONFIG_SMP
	19	# define INIT_PUSHABLE_TASKS(tsk) \
	20	.pushable_tasks = PLIST_NODE_INIT(tsk.pushable_tasks, MAX_PRIO),
	21	#else
	22	# define INIT_PUSHABLE_TASKS(tsk)
	23	#endif
	24
f52111b1	25	extern struct files_struct init_files;
18d8fda7	26	extern struct fs_struct init_fs;
1da177e4	27
4714d1d3	28	#ifdef CONFIG_CGROUPS
257058ae TH	29	#define INIT_GROUP_RWSEM(sig) \
257058ae TH	30	.group_rwsem = __RWSEM_INITIALIZER(sig.group_rwsem),
4714d1d3	31	#else
257058ae	32	#define INIT_GROUP_RWSEM(sig)
4714d1d3 BB	33	#endif
4714d1d3 BB	34
cc9a6c87	35	#ifdef CONFIG_CPUSETS
1ca7d67c JS	36	#define INIT_CPUSET_SEQ(tsk) \
1ca7d67c JS	37	.mems_allowed_seq = SEQCNT_ZERO(tsk.mems_allowed_seq),
cc9a6c87	38	#else
1ca7d67c	39	#define INIT_CPUSET_SEQ(tsk)
cc9a6c87 MG	40	#endif
cc9a6c87 MG	41
1ec320af	42	#define INIT_SIGNALS(sig) { \
b3ac022c	43	.nr_threads = 1, \
1da177e4	44	.wait_chldexit = __WAIT_QUEUE_HEAD_INITIALIZER(sig.wait_chldexit),\
1ec320af	45	.shared_pending = { \
1da177e4	46	.list = LIST_HEAD_INIT(sig.shared_pending.list), \
1ec320af	47	.signal = {{0}}}, \
1da177e4 LT	48	.posix_timers = LIST_HEAD_INIT(sig.posix_timers), \
	49	.cpu_timers = INIT_CPU_TIMERS(sig.cpu_timers), \
	50	.rlim = INIT_RLIMITS, \
4cd4c1b4 PZ	51	.cputimer = { \
	52	.cputime = INIT_CPUTIME, \
	53	.running = 0, \
ee30a7b2	54	.lock = __RAW_SPIN_LOCK_UNLOCKED(sig.cputimer.lock), \
4cd4c1b4	55	}, \
9b1bf12d KM	56	.cred_guard_mutex = \
9b1bf12d KM	57	__MUTEX_INITIALIZER(sig.cred_guard_mutex), \
257058ae	58	INIT_GROUP_RWSEM(sig) \
1da177e4 LT	59	}
1da177e4 LT	60
ab516013	61	extern struct nsproxy init_nsproxy;
ab516013	62
1da177e4 LT	63	#define INIT_SIGHAND(sighand) { \
1da177e4 LT	64	.count = ATOMIC_INIT(1), \
0a14a130	65	.action = { { { .sa_handler = SIG_DFL, } }, }, \
e4d91918	66	.siglock = __SPIN_LOCK_UNLOCKED(sighand.siglock), \
b8fceee1	67	.signalfd_wqh = __WAIT_QUEUE_HEAD_INITIALIZER(sighand.signalfd_wqh), \
1da177e4 LT	68	}
	69
	70	extern struct group_info init_groups;
	71
820e45db SB	72	#define INIT_STRUCT_PID { \
820e45db SB	73	.count = ATOMIC_INIT(1), \
820e45db	74	.tasks = { \
f2001145 ON	75	{ .first = NULL }, \
	76	{ .first = NULL }, \
	77	{ .first = NULL }, \
820e45db	78	}, \
4c3f2ead SB	79	.level = 0, \
	80	.numbers = { { \
	81	.nr = 0, \
	82	.ns = &init_pid_ns, \
	83	.pid_chain = { .next = NULL, .pprev = NULL }, \
	84	}, } \
820e45db SB	85	}
	86
	87	#define INIT_PID_LINK(type) \
	88	{ \
	89	.node = { \
	90	.next = NULL, \
f2001145	91	.pprev = NULL, \
820e45db SB	92	}, \
	93	.pid = &init_struct_pid, \
	94	}
	95
bfef93a5 AV	96	#ifdef CONFIG_AUDITSYSCALL
bfef93a5 AV	97	#define INIT_IDS \
e1760bd5	98	.loginuid = INVALID_UID, \
4746ec5b	99	.sessionid = -1,
bfef93a5 AV	100	#else
	101	#define INIT_IDS
	102	#endif
3b7391de	103
24278d14 PM	104	#ifdef CONFIG_RCU_BOOST
	105	#define INIT_TASK_RCU_BOOST() \
	106	.rcu_boost_mutex = NULL,
	107	#else
	108	#define INIT_TASK_RCU_BOOST()
	109	#endif
6b3ef48a	110	#ifdef CONFIG_TREE_PREEMPT_RCU
a57eb940 PM	111	#define INIT_TASK_RCU_TREE_PREEMPT() \
	112	.rcu_blocked_node = NULL,
	113	#else
	114	#define INIT_TASK_RCU_TREE_PREEMPT(tsk)
	115	#endif
	116	#ifdef CONFIG_PREEMPT_RCU
f41d911f PM	117	#define INIT_TASK_RCU_PREEMPT(tsk) \
	118	.rcu_read_lock_nesting = 0, \
	119	.rcu_read_unlock_special = 0, \
a57eb940	120	.rcu_node_entry = LIST_HEAD_INIT(tsk.rcu_node_entry), \
24278d14 PM	121	INIT_TASK_RCU_TREE_PREEMPT() \
24278d14 PM	122	INIT_TASK_RCU_BOOST()
f41d911f PM	123	#else
	124	#define INIT_TASK_RCU_PREEMPT(tsk)
	125	#endif
	126
b6dff3ec DH	127	extern struct cred init_cred;
b6dff3ec DH	128
8323f26c PZ	129	extern struct task_group root_task_group;
	130
	131	#ifdef CONFIG_CGROUP_SCHED
	132	# define INIT_CGROUP_SCHED(tsk) \
	133	.sched_task_group = &root_task_group,
	134	#else
	135	# define INIT_CGROUP_SCHED(tsk)
	136	#endif
	137
cdd6c482	138	#ifdef CONFIG_PERF_EVENTS
8323f26c	139	# define INIT_PERF_EVENTS(tsk) \
cdd6c482 IM	140	.perf_event_mutex = \
	141	__MUTEX_INITIALIZER(tsk.perf_event_mutex), \
	142	.perf_event_list = LIST_HEAD_INIT(tsk.perf_event_list),
082ff5a2	143	#else
cdd6c482	144	# define INIT_PERF_EVENTS(tsk)
082ff5a2 PZ	145	#endif
082ff5a2 PZ	146
6a61671b FW	147	#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
	148	# define INIT_VTIME(tsk) \
	149	.vtime_seqlock = __SEQLOCK_UNLOCKED(tsk.vtime_seqlock), \
	150	.vtime_snap = 0, \
	151	.vtime_snap_whence = VTIME_SYS,
	152	#else
	153	# define INIT_VTIME(tsk)
	154	#endif
	155
f1c6f1a7 CE	156	#define INIT_TASK_COMM "swapper"
f1c6f1a7 CE	157
fb00aca4 PZ	158	#ifdef CONFIG_RT_MUTEXES
	159	# define INIT_RT_MUTEXES(tsk) \
	160	.pi_waiters = RB_ROOT, \
	161	.pi_waiters_leftmost = NULL,
	162	#else
	163	# define INIT_RT_MUTEXES(tsk)
	164	#endif
	165
1da177e4 LT	166	/*
	167	* INIT_TASK is used to set up the first task table, touch at
	168	* your own risk!. Base=0, limit=0x1fffff (=2MB)
	169	*/
	170	#define INIT_TASK(tsk) \
	171	{ \
	172	.state = 0, \
f7e4217b	173	.stack = &init_thread_info, \
1da177e4	174	.usage = ATOMIC_INIT(2), \
7b34e428	175	.flags = PF_KTHREAD, \
1da177e4 LT	176	.prio = MAX_PRIO-20, \
1da177e4 LT	177	.static_prio = MAX_PRIO-20, \
b29739f9	178	.normal_prio = MAX_PRIO-20, \
1da177e4 LT	179	.policy = SCHED_NORMAL, \
1da177e4 LT	180	.cpus_allowed = CPU_MASK_ALL, \
29baa747	181	.nr_cpus_allowed= NR_CPUS, \
1da177e4 LT	182	.mm = NULL, \
1da177e4 LT	183	.active_mm = &init_mm, \
4a55bd5e PZ	184	.se = { \
	185	.group_node = LIST_HEAD_INIT(tsk.se.group_node), \
	186	}, \
fa717060 PZ	187	.rt = { \
fa717060 PZ	188	.run_list = LIST_HEAD_INIT(tsk.rt.run_list), \
de5bdff7	189	.time_slice = RR_TIMESLICE, \
6f505b16	190	}, \
1da177e4	191	.tasks = LIST_HEAD_INIT(tsk.tasks), \
806c09a7	192	INIT_PUSHABLE_TASKS(tsk) \
8323f26c	193	INIT_CGROUP_SCHED(tsk) \
f470021a RM	194	.ptraced = LIST_HEAD_INIT(tsk.ptraced), \
f470021a RM	195	.ptrace_entry = LIST_HEAD_INIT(tsk.ptrace_entry), \
1da177e4 LT	196	.real_parent = &tsk, \
	197	.parent = &tsk, \
	198	.children = LIST_HEAD_INIT(tsk.children), \
	199	.sibling = LIST_HEAD_INIT(tsk.sibling), \
	200	.group_leader = &tsk, \
d36cc701 PM	201	RCU_POINTER_INITIALIZER(real_cred, &init_cred), \
d36cc701 PM	202	RCU_POINTER_INITIALIZER(cred, &init_cred), \
f1c6f1a7	203	.comm = INIT_TASK_COMM, \
1da177e4 LT	204	.thread = INIT_THREAD, \
	205	.fs = &init_fs, \
	206	.files = &init_files, \
	207	.signal = &init_signals, \
	208	.sighand = &init_sighand, \
ab516013	209	.nsproxy = &init_nsproxy, \
1da177e4 LT	210	.pending = { \
	211	.list = LIST_HEAD_INIT(tsk.pending.list), \
	212	.signal = {{0}}}, \
	213	.blocked = {{0}}, \
e4d91918	214	.alloc_lock = __SPIN_LOCK_UNLOCKED(tsk.alloc_lock), \
b6e3224f	215	.journal_info = NULL, \
1da177e4	216	.cpu_timers = INIT_CPU_TIMERS(tsk.cpu_timers), \
1d615482	217	.pi_lock = __RAW_SPIN_LOCK_UNLOCKED(tsk.pi_lock), \
6976675d	218	.timer_slack_ns = 50000, /* 50 usec default slack */ \
820e45db SB	219	.pids = { \
	220	[PIDTYPE_PID] = INIT_PID_LINK(PIDTYPE_PID), \
	221	[PIDTYPE_PGID] = INIT_PID_LINK(PIDTYPE_PGID), \
	222	[PIDTYPE_SID] = INIT_PID_LINK(PIDTYPE_SID), \
	223	}, \
fa2755e2	224	.thread_group = LIST_HEAD_INIT(tsk.thread_group), \
bfef93a5	225	INIT_IDS \
cdd6c482	226	INIT_PERF_EVENTS(tsk) \
de30a2b3	227	INIT_TRACE_IRQFLAGS \
fbb9ce95	228	INIT_LOCKDEP \
5ac9f622	229	INIT_FTRACE_GRAPH \
261842b7	230	INIT_TRACE_RECURSION \
f41d911f	231	INIT_TASK_RCU_PREEMPT(tsk) \
1ca7d67c	232	INIT_CPUSET_SEQ(tsk) \
fb00aca4	233	INIT_RT_MUTEXES(tsk) \
6a61671b	234	INIT_VTIME(tsk) \
1da177e4 LT	235	}
	236
	237
	238	#define INIT_CPU_TIMERS(cpu_timers) \
	239	{ \
	240	LIST_HEAD_INIT(cpu_timers[0]), \
	241	LIST_HEAD_INIT(cpu_timers[1]), \
	242	LIST_HEAD_INIT(cpu_timers[2]), \
	243	}
	244
857eceeb	245	/* Attach to the init_task data structure for proper alignment */
2af7687f	246	#define __init_task_data __attribute__((__section__(".data..init_task")))
857eceeb	247
1da177e4 LT	248
1da177e4 LT	249	#endif