cregit-Linux how code gets into the kernel

Release 4.12 include/linux/init_task.h

Directory: include/linux
#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,                         \
                .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 = (unsigned int)-1,
#else

#define INIT_IDS
#endif

#ifdef CONFIG_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.s = 0,                                 \
        .rcu_node_entry = LIST_HEAD_INIT(tsk.rcu_node_entry),           \
        INIT_TASK_RCU_TREE_PREEMPT()
#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_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_top_task = NULL,                                            \
        .pi_waiters_leftmost = 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

Overall Contributors

PersonTokensPropCommitsCommitProp
Peter Zijlstra8116.23%47.14%
Paul E. McKenney6012.02%58.93%
Nico Pitre5110.22%11.79%
Linus Torvalds285.61%35.36%
Josh Poimboeuf244.81%11.79%
Andrew Lutomirski244.81%23.57%
Al Viro244.81%35.36%
Frédéric Weisbecker244.81%23.57%
Ingo Molnar224.41%712.50%
Dario Faggioli214.21%11.79%
Kirill Tkhai214.21%11.79%
Andrey Ryabinin214.21%11.79%
Tetsuo Handa142.81%11.79%
Mel Gorman122.40%11.79%
Sukadev Bhattiprolu102.00%11.79%
Serge E. Hallyn81.60%23.57%
John Stultz71.40%11.79%
Cédric Le Goater61.20%23.57%
David Howells51.00%11.79%
Andrew Morton51.00%11.79%
Tim Abbott51.00%23.57%
Carsten Emde40.80%11.79%
Eric W. Biedermann30.60%11.79%
Andrew G. Morgan30.60%11.79%
Oleg Nesterov30.60%23.57%
Steven Rostedt30.60%11.79%
Kirill Korotaev30.60%11.79%
Ben Blum20.40%11.79%
Dipankar Sarma10.20%11.79%
Xunlei Pang10.20%11.79%
Pranith Kumar10.20%11.79%
Arjan van de Ven10.20%11.79%
Eric Paris10.20%11.79%
Total499100.00%56100.00%
Directory: include/linux
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.