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

/* SPDX-License-Identifier: GPL-2.0 */
#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 <linux/sched/autogroup.h>
#include <net/net_namespace.h>
#include <linux/sched/rt.h>
#include <linux/livepatch.h>
#include <linux/mm_types.h>

#include <asm/thread_info.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_CPUSETS
#define INIT_CPUSET_SEQ(tsk)							\
	.mems_allowed_seq = SEQCNT_ZERO(tsk.mems_allowed_seq),
#else
#define INIT_CPUSET_SEQ(tsk)
#endif

#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
#define INIT_PREV_CPUTIME(x)	.prev_cputime = {			\
	.lock = __RAW_SPIN_LOCK_UNLOCKED(x.prev_cputime.lock),		\
},
#else
#define INIT_PREV_CPUTIME(x)
#endif

#ifdef CONFIG_POSIX_TIMERS
#define INIT_POSIX_TIMERS(s)						\
	.posix_timers = LIST_HEAD_INIT(s.posix_timers),
#define INIT_CPU_TIMERS(s)						\
	.cpu_timers = {							\
		LIST_HEAD_INIT(s.cpu_timers[0]),			\
		LIST_HEAD_INIT(s.cpu_timers[1]),			\
		LIST_HEAD_INIT(s.cpu_timers[2]),								\
	},
#define INIT_CPUTIMER(s)						\
	.cputimer	= { 						\
		.cputime_atomic	= INIT_CPUTIME_ATOMIC,			\
		.running	= false,				\
		.checking_timer = false,				\
	},
#else
#define INIT_POSIX_TIMERS(s)
#define INIT_CPU_TIMERS(s)
#define INIT_CPUTIMER(s)
#endif

#define INIT_SIGNALS(sig) {						\
	.nr_threads	= 1,						\
	.thread_head	= LIST_HEAD_INIT(init_task.thread_node),	\
	.wait_chldexit	= __WAIT_QUEUE_HEAD_INITIALIZER(sig.wait_chldexit),\
	.shared_pending	= { 						\
		.list = LIST_HEAD_INIT(sig.shared_pending.list),	\
		.signal =  {{0}}},					\
	INIT_POSIX_TIMERS(sig)						\
	INIT_CPU_TIMERS(sig)						\
	.rlim		= INIT_RLIMITS,					\
	INIT_CPUTIMER(sig)						\
	INIT_PREV_CPUTIME(sig)						\
	.cred_guard_mutex =						\
		 __MUTEX_INITIALIZER(sig.cred_guard_mutex),		\
}

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,				\
	}, }								\
}

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

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

#ifdef CONFIG_PREEMPT_RCU
#define INIT_TASK_RCU_PREEMPT(tsk)					\
	.rcu_read_lock_nesting = 0,					\
	.rcu_read_unlock_special.s = 0,					\
	.rcu_node_entry = LIST_HEAD_INIT(tsk.rcu_node_entry),		\
	.rcu_blocked_node = NULL,
#else
#define INIT_TASK_RCU_PREEMPT(tsk)
#endif
#ifdef CONFIG_TASKS_RCU
#define INIT_TASK_RCU_TASKS(tsk)					\
	.rcu_tasks_holdout = false,					\
	.rcu_tasks_holdout_list =					\
		LIST_HEAD_INIT(tsk.rcu_tasks_holdout_list),		\
	.rcu_tasks_idle_cpu = -1,
#else
#define INIT_TASK_RCU_TASKS(tsk)
#endif

extern struct cred init_cred;

#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.seqcount = SEQCNT_ZERO(tsk.vtime.seqcount),		\
	.vtime.starttime = 0,						\
	.vtime.state = 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_CACHED,					\
	.pi_top_task = NULL,
#else
# define INIT_RT_MUTEXES(tsk)
#endif

#ifdef CONFIG_NUMA_BALANCING
# define INIT_NUMA_BALANCING(tsk)					\
	.numa_preferred_nid = -1,					\
	.numa_group = NULL,						\
	.numa_faults = NULL,
#else
# define INIT_NUMA_BALANCING(tsk)
#endif

#ifdef CONFIG_KASAN
# define INIT_KASAN(tsk)						\
	.kasan_depth = 1,
#else
# define INIT_KASAN(tsk)
#endif

#ifdef CONFIG_LIVEPATCH
# define INIT_LIVEPATCH(tsk)						\
	.patch_state = KLP_UNDEFINED,
#else
# define INIT_LIVEPATCH(tsk)
#endif

#ifdef CONFIG_THREAD_INFO_IN_TASK
# define INIT_TASK_TI(tsk)			\
	.thread_info = INIT_THREAD_INFO(tsk),	\
	.stack_refcount = ATOMIC_INIT(1),
#else
# define INIT_TASK_TI(tsk)
#endif

#ifdef CONFIG_SECURITY
#define INIT_TASK_SECURITY .security = NULL,
#else
#define INIT_TASK_SECURITY
#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)	\
{									\
	INIT_TASK_TI(tsk)						\
	.state		= 0,						\
	.stack		= init_stack,					\
	.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,					\
	.restart_block = {						\
		.fn = do_no_restart_syscall,				\
	},								\
	.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,						\
	INIT_CPU_TIMERS(tsk)						\
	.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),		\
	.thread_node	= LIST_HEAD_INIT(init_signals.thread_head),	\
	INIT_IDS							\
	INIT_PERF_EVENTS(tsk)						\
	INIT_TRACE_IRQFLAGS						\
	INIT_LOCKDEP							\
	INIT_FTRACE_GRAPH						\
	INIT_TRACE_RECURSION						\
	INIT_TASK_RCU_PREEMPT(tsk)					\
	INIT_TASK_RCU_TASKS(tsk)					\
	INIT_CPUSET_SEQ(tsk)						\
	INIT_RT_MUTEXES(tsk)						\
	INIT_PREV_CPUTIME(tsk)						\
	INIT_VTIME(tsk)							\
	INIT_NUMA_BALANCING(tsk)					\
	INIT_KASAN(tsk)							\
	INIT_LIVEPATCH(tsk)						\
	INIT_TASK_SECURITY						\
}


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


#endif
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
1da177e4 LT	2	#ifndef _LINUX__INIT_TASK_H
	3	#define _LINUX__INIT_TASK_H
	4
ab2af1f5	5	#include <linux/rcupdate.h>
de30a2b3	6	#include <linux/irqflags.h>
4865ecf1	7	#include <linux/utsname.h>
fbb9ce95	8	#include <linux/lockdep.h>
5ac9f622	9	#include <linux/ftrace.h>
73ea4130	10	#include <linux/ipc.h>
9a575a92	11	#include <linux/pid_namespace.h>
acce292c	12	#include <linux/user_namespace.h>
3898b1b4	13	#include <linux/securebits.h>
6a61671b	14	#include <linux/seqlock.h>
fb00aca4	15	#include <linux/rbtree.h>
dfc3401a	16	#include <linux/sched/autogroup.h>
772698f6	17	#include <net/net_namespace.h>
77852fea	18	#include <linux/sched/rt.h>
d83a7cb3	19	#include <linux/livepatch.h>
589ee628	20	#include <linux/mm_types.h>
1da177e4	21
c65eacbe AL	22	#include <asm/thread_info.h>
c65eacbe AL	23
806c09a7 DF	24	#ifdef CONFIG_SMP
	25	# define INIT_PUSHABLE_TASKS(tsk) \
	26	.pushable_tasks = PLIST_NODE_INIT(tsk.pushable_tasks, MAX_PRIO),
	27	#else
	28	# define INIT_PUSHABLE_TASKS(tsk)
	29	#endif
	30
f52111b1	31	extern struct files_struct init_files;
18d8fda7	32	extern struct fs_struct init_fs;
1da177e4	33
cc9a6c87	34	#ifdef CONFIG_CPUSETS
1ca7d67c JS	35	#define INIT_CPUSET_SEQ(tsk) \
1ca7d67c JS	36	.mems_allowed_seq = SEQCNT_ZERO(tsk.mems_allowed_seq),
cc9a6c87	37	#else
1ca7d67c	38	#define INIT_CPUSET_SEQ(tsk)
cc9a6c87 MG	39	#endif
cc9a6c87 MG	40
9d7fb042 PZ	41	#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
	42	#define INIT_PREV_CPUTIME(x) .prev_cputime = { \
	43	.lock = __RAW_SPIN_LOCK_UNLOCKED(x.prev_cputime.lock), \
	44	},
	45	#else
	46	#define INIT_PREV_CPUTIME(x)
	47	#endif
	48
b18b6a9c NP	49	#ifdef CONFIG_POSIX_TIMERS
	50	#define INIT_POSIX_TIMERS(s) \
	51	.posix_timers = LIST_HEAD_INIT(s.posix_timers),
	52	#define INIT_CPU_TIMERS(s) \
	53	.cpu_timers = { \
	54	LIST_HEAD_INIT(s.cpu_timers[0]), \
	55	LIST_HEAD_INIT(s.cpu_timers[1]), \
	56	LIST_HEAD_INIT(s.cpu_timers[2]), \
	57	},
	58	#define INIT_CPUTIMER(s) \
	59	.cputimer = { \
	60	.cputime_atomic = INIT_CPUTIME_ATOMIC, \
	61	.running = false, \
	62	.checking_timer = false, \
	63	},
	64	#else
	65	#define INIT_POSIX_TIMERS(s)
	66	#define INIT_CPU_TIMERS(s)
	67	#define INIT_CPUTIMER(s)
	68	#endif
	69
1ec320af	70	#define INIT_SIGNALS(sig) { \
b3ac022c	71	.nr_threads = 1, \
0c740d0a	72	.thread_head = LIST_HEAD_INIT(init_task.thread_node), \
1da177e4	73	.wait_chldexit = __WAIT_QUEUE_HEAD_INITIALIZER(sig.wait_chldexit),\
1ec320af	74	.shared_pending = { \
1da177e4	75	.list = LIST_HEAD_INIT(sig.shared_pending.list), \
1ec320af	76	.signal = {{0}}}, \
b18b6a9c NP	77	INIT_POSIX_TIMERS(sig) \
b18b6a9c NP	78	INIT_CPU_TIMERS(sig) \
1da177e4	79	.rlim = INIT_RLIMITS, \
b18b6a9c	80	INIT_CPUTIMER(sig) \
9d7fb042	81	INIT_PREV_CPUTIME(sig) \
9b1bf12d KM	82	.cred_guard_mutex = \
9b1bf12d KM	83	__MUTEX_INITIALIZER(sig.cred_guard_mutex), \
1da177e4 LT	84	}
1da177e4 LT	85
ab516013	86	extern struct nsproxy init_nsproxy;
ab516013	87
1da177e4 LT	88	#define INIT_SIGHAND(sighand) { \
1da177e4 LT	89	.count = ATOMIC_INIT(1), \
0a14a130	90	.action = { { { .sa_handler = SIG_DFL, } }, }, \
e4d91918	91	.siglock = __SPIN_LOCK_UNLOCKED(sighand.siglock), \
b8fceee1	92	.signalfd_wqh = __WAIT_QUEUE_HEAD_INITIALIZER(sighand.signalfd_wqh), \
1da177e4 LT	93	}
	94
	95	extern struct group_info init_groups;
	96
820e45db SB	97	#define INIT_STRUCT_PID { \
820e45db SB	98	.count = ATOMIC_INIT(1), \
820e45db	99	.tasks = { \
f2001145 ON	100	{ .first = NULL }, \
	101	{ .first = NULL }, \
	102	{ .first = NULL }, \
820e45db	103	}, \
4c3f2ead SB	104	.level = 0, \
	105	.numbers = { { \
	106	.nr = 0, \
	107	.ns = &init_pid_ns, \
4c3f2ead	108	}, } \
820e45db SB	109	}
	110
	111	#define INIT_PID_LINK(type) \
	112	{ \
	113	.node = { \
	114	.next = NULL, \
f2001145	115	.pprev = NULL, \
820e45db SB	116	}, \
	117	.pid = &init_struct_pid, \
	118	}
	119
bfef93a5 AV	120	#ifdef CONFIG_AUDITSYSCALL
bfef93a5 AV	121	#define INIT_IDS \
e1760bd5	122	.loginuid = INVALID_UID, \
4440e854	123	.sessionid = (unsigned int)-1,
bfef93a5 AV	124	#else
	125	#define INIT_IDS
	126	#endif
3b7391de	127
a57eb940	128	#ifdef CONFIG_PREEMPT_RCU
f41d911f PM	129	#define INIT_TASK_RCU_PREEMPT(tsk) \
f41d911f PM	130	.rcu_read_lock_nesting = 0, \
1d082fd0	131	.rcu_read_unlock_special.s = 0, \
a57eb940	132	.rcu_node_entry = LIST_HEAD_INIT(tsk.rcu_node_entry), \
4e327470	133	.rcu_blocked_node = NULL,
f41d911f PM	134	#else
	135	#define INIT_TASK_RCU_PREEMPT(tsk)
	136	#endif
8315f422 PM	137	#ifdef CONFIG_TASKS_RCU
	138	#define INIT_TASK_RCU_TASKS(tsk) \
	139	.rcu_tasks_holdout = false, \
	140	.rcu_tasks_holdout_list = \
176f8f7a PM	141	LIST_HEAD_INIT(tsk.rcu_tasks_holdout_list), \
176f8f7a PM	142	.rcu_tasks_idle_cpu = -1,
8315f422 PM	143	#else
	144	#define INIT_TASK_RCU_TASKS(tsk)
	145	#endif
f41d911f	146
b6dff3ec DH	147	extern struct cred init_cred;
b6dff3ec DH	148
8323f26c PZ	149	#ifdef CONFIG_CGROUP_SCHED
	150	# define INIT_CGROUP_SCHED(tsk) \
	151	.sched_task_group = &root_task_group,
	152	#else
	153	# define INIT_CGROUP_SCHED(tsk)
	154	#endif
	155
cdd6c482	156	#ifdef CONFIG_PERF_EVENTS
8323f26c	157	# define INIT_PERF_EVENTS(tsk) \
cdd6c482 IM	158	.perf_event_mutex = \
	159	__MUTEX_INITIALIZER(tsk.perf_event_mutex), \
	160	.perf_event_list = LIST_HEAD_INIT(tsk.perf_event_list),
082ff5a2	161	#else
cdd6c482	162	# define INIT_PERF_EVENTS(tsk)
082ff5a2 PZ	163	#endif
082ff5a2 PZ	164
6a61671b FW	165	#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
6a61671b FW	166	# define INIT_VTIME(tsk) \
bac5b6b6 FW	167	.vtime.seqcount = SEQCNT_ZERO(tsk.vtime.seqcount), \
	168	.vtime.starttime = 0, \
	169	.vtime.state = VTIME_SYS,
6a61671b FW	170	#else
	171	# define INIT_VTIME(tsk)
	172	#endif
	173
f1c6f1a7 CE	174	#define INIT_TASK_COMM "swapper"
f1c6f1a7 CE	175
fb00aca4 PZ	176	#ifdef CONFIG_RT_MUTEXES
fb00aca4 PZ	177	# define INIT_RT_MUTEXES(tsk) \
a23ba907 DB	178	.pi_waiters = RB_ROOT_CACHED, \
a23ba907 DB	179	.pi_top_task = NULL,
fb00aca4 PZ	180	#else
	181	# define INIT_RT_MUTEXES(tsk)
	182	#endif
	183
d8b163c4 KT	184	#ifdef CONFIG_NUMA_BALANCING
	185	# define INIT_NUMA_BALANCING(tsk) \
	186	.numa_preferred_nid = -1, \
	187	.numa_group = NULL, \
	188	.numa_faults = NULL,
	189	#else
	190	# define INIT_NUMA_BALANCING(tsk)
	191	#endif
	192
c420f167 AR	193	#ifdef CONFIG_KASAN
	194	# define INIT_KASAN(tsk) \
	195	.kasan_depth = 1,
	196	#else
	197	# define INIT_KASAN(tsk)
	198	#endif
	199
d83a7cb3 JP	200	#ifdef CONFIG_LIVEPATCH
	201	# define INIT_LIVEPATCH(tsk) \
	202	.patch_state = KLP_UNDEFINED,
	203	#else
	204	# define INIT_LIVEPATCH(tsk)
	205	#endif
	206
c65eacbe	207	#ifdef CONFIG_THREAD_INFO_IN_TASK
68f24b08 AL	208	# define INIT_TASK_TI(tsk) \
	209	.thread_info = INIT_THREAD_INFO(tsk), \
	210	.stack_refcount = ATOMIC_INIT(1),
c65eacbe AL	211	#else
	212	# define INIT_TASK_TI(tsk)
	213	#endif
	214
e4e55b47 TH	215	#ifdef CONFIG_SECURITY
	216	#define INIT_TASK_SECURITY .security = NULL,
	217	#else
	218	#define INIT_TASK_SECURITY
	219	#endif
	220
1da177e4 LT	221	/*
	222	* INIT_TASK is used to set up the first task table, touch at
	223	* your own risk!. Base=0, limit=0x1fffff (=2MB)
	224	*/
	225	#define INIT_TASK(tsk) \
	226	{ \
c65eacbe	227	INIT_TASK_TI(tsk) \
1da177e4	228	.state = 0, \
7f1a00b6	229	.stack = init_stack, \
1da177e4	230	.usage = ATOMIC_INIT(2), \
7b34e428	231	.flags = PF_KTHREAD, \
1da177e4 LT	232	.prio = MAX_PRIO-20, \
1da177e4 LT	233	.static_prio = MAX_PRIO-20, \
b29739f9	234	.normal_prio = MAX_PRIO-20, \
1da177e4 LT	235	.policy = SCHED_NORMAL, \
1da177e4 LT	236	.cpus_allowed = CPU_MASK_ALL, \
29baa747	237	.nr_cpus_allowed= NR_CPUS, \
1da177e4 LT	238	.mm = NULL, \
1da177e4 LT	239	.active_mm = &init_mm, \
f56141e3 AL	240	.restart_block = { \
	241	.fn = do_no_restart_syscall, \
	242	}, \
4a55bd5e PZ	243	.se = { \
	244	.group_node = LIST_HEAD_INIT(tsk.se.group_node), \
	245	}, \
fa717060 PZ	246	.rt = { \
fa717060 PZ	247	.run_list = LIST_HEAD_INIT(tsk.rt.run_list), \
de5bdff7	248	.time_slice = RR_TIMESLICE, \
6f505b16	249	}, \
1da177e4	250	.tasks = LIST_HEAD_INIT(tsk.tasks), \
806c09a7	251	INIT_PUSHABLE_TASKS(tsk) \
8323f26c	252	INIT_CGROUP_SCHED(tsk) \
f470021a RM	253	.ptraced = LIST_HEAD_INIT(tsk.ptraced), \
f470021a RM	254	.ptrace_entry = LIST_HEAD_INIT(tsk.ptrace_entry), \
1da177e4 LT	255	.real_parent = &tsk, \
	256	.parent = &tsk, \
	257	.children = LIST_HEAD_INIT(tsk.children), \
	258	.sibling = LIST_HEAD_INIT(tsk.sibling), \
	259	.group_leader = &tsk, \
d36cc701 PM	260	RCU_POINTER_INITIALIZER(real_cred, &init_cred), \
d36cc701 PM	261	RCU_POINTER_INITIALIZER(cred, &init_cred), \
f1c6f1a7	262	.comm = INIT_TASK_COMM, \
1da177e4 LT	263	.thread = INIT_THREAD, \
	264	.fs = &init_fs, \
	265	.files = &init_files, \
	266	.signal = &init_signals, \
	267	.sighand = &init_sighand, \
ab516013	268	.nsproxy = &init_nsproxy, \
1da177e4 LT	269	.pending = { \
	270	.list = LIST_HEAD_INIT(tsk.pending.list), \
	271	.signal = {{0}}}, \
	272	.blocked = {{0}}, \
e4d91918	273	.alloc_lock = __SPIN_LOCK_UNLOCKED(tsk.alloc_lock), \
b6e3224f	274	.journal_info = NULL, \
b18b6a9c	275	INIT_CPU_TIMERS(tsk) \
1d615482	276	.pi_lock = __RAW_SPIN_LOCK_UNLOCKED(tsk.pi_lock), \
6976675d	277	.timer_slack_ns = 50000, /* 50 usec default slack */ \
820e45db SB	278	.pids = { \
	279	[PIDTYPE_PID] = INIT_PID_LINK(PIDTYPE_PID), \
	280	[PIDTYPE_PGID] = INIT_PID_LINK(PIDTYPE_PGID), \
	281	[PIDTYPE_SID] = INIT_PID_LINK(PIDTYPE_SID), \
	282	}, \
fa2755e2	283	.thread_group = LIST_HEAD_INIT(tsk.thread_group), \
0c740d0a	284	.thread_node = LIST_HEAD_INIT(init_signals.thread_head), \
bfef93a5	285	INIT_IDS \
cdd6c482	286	INIT_PERF_EVENTS(tsk) \
de30a2b3	287	INIT_TRACE_IRQFLAGS \
fbb9ce95	288	INIT_LOCKDEP \
5ac9f622	289	INIT_FTRACE_GRAPH \
261842b7	290	INIT_TRACE_RECURSION \
f41d911f	291	INIT_TASK_RCU_PREEMPT(tsk) \
8315f422	292	INIT_TASK_RCU_TASKS(tsk) \
1ca7d67c	293	INIT_CPUSET_SEQ(tsk) \
fb00aca4	294	INIT_RT_MUTEXES(tsk) \
9d7fb042	295	INIT_PREV_CPUTIME(tsk) \
6a61671b	296	INIT_VTIME(tsk) \
d8b163c4	297	INIT_NUMA_BALANCING(tsk) \
c420f167	298	INIT_KASAN(tsk) \
d83a7cb3	299	INIT_LIVEPATCH(tsk) \
e4e55b47	300	INIT_TASK_SECURITY \
1da177e4 LT	301	}
	302
	303
857eceeb	304	/* Attach to the init_task data structure for proper alignment */
2af7687f	305	#define __init_task_data __attribute__((__section__(".data..init_task")))
857eceeb	306
1da177e4 LT	307
1da177e4 LT	308	#endif