cregit-Linux how code gets into the kernel

Release 4.7 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 <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_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


#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}}},                                      \
        .posix_timers    = LIST_HEAD_INIT(sig.posix_timers),            \
        .cpu_timers     = INIT_CPU_TIMERS(sig.cpu_timers),              \
        .rlim           = INIT_RLIMITS,                                 \
        .cputimer       = {                                             \
                .cputime_atomic = INIT_CPUTIME_ATOMIC,                  \
                .running        = false,                                \
                .checking_timer = false,                                \
        },                                                              \
        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;

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_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_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

/*
 *  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_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,                                         \
        .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),             \
        .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)                                                 \
}



#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

Overall Contributors

PersonTokensPropCommitsCommitProp
peter zijlstrapeter zijlstra8822.28%48.00%
paul e. mckenneypaul e. mckenney6015.19%510.00%
linus torvaldslinus torvalds297.34%48.00%
frederic weisbeckerfrederic weisbecker246.08%24.00%
al viroal viro246.08%36.00%
andrey ryabininandrey ryabinin215.32%12.00%
kirill tkhaikirill tkhai215.32%12.00%
dario faggiolidario faggioli215.32%12.00%
ingo molnaringo molnar164.05%510.00%
mel gormanmel gorman123.04%12.00%
sukadev bhattiprolusukadev bhattiprolu102.53%12.00%
roland mcgrathroland mcgrath82.03%12.00%
serge hallynserge hallyn82.03%24.00%
john stultzjohn stultz71.77%12.00%
cedric le goatercedric le goater61.52%24.00%
tim abbotttim abbott51.27%24.00%
andrew mortonandrew morton51.27%12.00%
david howellsdavid howells51.27%12.00%
carsten emdecarsten emde41.01%12.00%
kirill korotaevkirill korotaev30.76%12.00%
andrew g. morganandrew g. morgan30.76%12.00%
eric w. biedermaneric w. biederman30.76%12.00%
steven rostedtsteven rostedt30.76%12.00%
oleg nesterovoleg nesterov30.76%24.00%
ben blumben blum20.51%12.00%
eric pariseric paris10.25%12.00%
pranith kumarpranith kumar10.25%12.00%
dipankar sarmadipankar sarma10.25%12.00%
arjan van de venarjan van de ven10.25%12.00%
Total395100.00%50100.00%
Directory: include/linux
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}