1
2
3

pid_t              pid;                            // 进程id
pid_t               tgid;                           // 线程group id
struct task_struct      *group_leader;              // 线程group leader

1
2
3
4
5
6

DECLARE_PER_CPU(struct task_struct *, current_task);
static __always_inline struct task_struct *get_current(void)
{return this_cpu_read_stable(current_task);
}
#define current get_current()

1
2
3
4

SYSCALL_DEFINE0(getpid)
{return task_tgid_vnr(current);
}

1
2
3
4

SYSCALL_DEFINE0(gettid)
{return task_pid_vnr(current);
}

1
2
3
4
5
6
7
8

SYSCALL_DEFINE0(getppid)
{int pid;rcu_read_lock();pid = task_tgid_vnr(rcu_dereference(current->real_parent));rcu_read_unlock();return pid;
}

1
2
3
4
5
6
7

/* Real parent process: */
struct task_struct __rcu    *real_parent;
/* Recipient of SIGCHLD, wait4() reports: */
struct task_struct __rcu    *parent;
/* Children/sibling form the list of natural children: */
struct list_head        children;
struct list_head        sibling;

1
2
3
4
5
6
7
8

/* CLONE_PARENT re-uses the old parent */
if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {p->real_parent = current->real_parent;p->parent_exec_id = current->parent_exec_id;
} else {p->real_parent = current;p->parent_exec_id = current->self_exec_id;
}

1
2
3
4
5
6
7
8

void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,const struct cred *ptracer_cred)
{BUG_ON(!list_empty(&child->ptrace_entry));list_add(&child->ptrace_entry, &new_parent->ptraced);child->parent = new_parent;child->ptracer_cred = get_cred(ptracer_cred);
}

1
2
3
4
5

/* -1 unrunnable, 0 runnable, >0 stopped: */
volatile long           state;
/* Per task flags (PF_*), defined further below: */
unsigned int            flags;
int             exit_state;

 123456789
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/* Used in tsk->state: */
#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               0x0010
#define EXIT_ZOMBIE             0x0020
#define EXIT_TRACE              (EXIT_ZOMBIE | EXIT_DEAD)
/* Used in tsk->state again: */
#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)
#define TASK_STOPPED            (TASK_WAKEKILL | __TASK_STOPPED)
#define TASK_TRACED             (TASK_WAKEKILL | __TASK_TRACED)
#define TASK_IDLE               (TASK_UNINTERRUPTIBLE | TASK_NOLOAD)
/* Convenience macros for the sake of wake_up(): */
#define TASK_NORMAL             (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
/* get_task_state(): */
#define TASK_REPORT             (TASK_RUNNING | TASK_INTERRUPTIBLE | \TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \__TASK_TRACED | EXIT_DEAD | EXIT_ZOMBIE | \TASK_PARKED)

 123456789
10
11
12
13
14
15

/** Called when a process ceases being the active-running process involuntarily* due, typically, to expiring its time slice (this may also be called when* switching to the idle task).  Now we can calculate how long we ran.* Also, if the process is still in the TASK_RUNNING state, call* sched_info_queued() to mark that it has now again started waiting on* the runqueue.*/
static inline void sched_info_depart(struct rq *rq, struct task_struct *t)
{unsigned long long delta = rq_clock(rq) - t->sched_info.last_arrival;rq_sched_info_depart(rq, delta);if (t->state == TASK_RUNNING)sched_info_queued(rq, t);
}

 123456789
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/** Per process flags*/
#define PF_IDLE             0x00000002  /* I am an IDLE thread */
#define PF_EXITING          0x00000004  /* Getting shut down */
#define PF_EXITPIDONE       0x00000008  /* PI exit done on shut down */
#define PF_VCPU             0x00000010  /* I'm a virtual CPU */
#define PF_WQ_WORKER        0x00000020  /* I'm a workqueue worker */
#define PF_FORKNOEXEC       0x00000040  /* Forked but didn't exec */
#define PF_MCE_PROCESS      0x00000080  /* Process policy on mce errors */
#define PF_SUPERPRIV        0x00000100  /* Used super-user privileges */
#define PF_DUMPCORE         0x00000200  /* Dumped core */
#define PF_SIGNALED         0x00000400  /* Killed by a signal */
#define PF_MEMALLOC         0x00000800  /* Allocating memory */
#define PF_NPROC_EXCEEDED   0x00001000  /* set_user() noticed that RLIMIT_NPROC was exceeded */
#define PF_USED_MATH        0x00002000  /* If unset the fpu must be initialized before use */
#define PF_USED_ASYNC       0x00004000  /* Used async_schedule*(), used by module init */
#define PF_NOFREEZE         0x00008000  /* This thread should not be frozen */
#define PF_FROZEN           0x00010000  /* Frozen for system suspend */
#define PF_KSWAPD           0x00020000  /* I am kswapd */
#define PF_MEMALLOC_NOFS    0x00040000  /* All allocation requests will inherit GFP_NOFS */
#define PF_MEMALLOC_NOIO    0x00080000  /* All allocation requests will inherit GFP_NOIO */
#define PF_LESS_THROTTLE    0x00100000  /* Throttle me less: I clean memory */
#define PF_KTHREAD          0x00200000  /* I am a kernel thread */
#define PF_RANDOMIZE        0x00400000  /* Randomize virtual address space */
#define PF_SWAPWRITE        0x00800000  /* Allowed to write to swap */
#define PF_MEMSTALL         0x01000000  /* Stalled due to lack of memory */
#define PF_UMH              0x02000000  /* I'm an Usermodehelper process */
#define PF_NO_SETAFFINITY   0x04000000  /* Userland is not allowed to meddle with cpus_allowed */
#define PF_MCE_EARLY        0x08000000  /* Early kill for mce process policy */
#define PF_MEMALLOC_NOCMA   0x10000000  /* All allocation request will have _GFP_MOVABLE cleared */
#define PF_FREEZER_SKIP     0x40000000  /* Freezer should not count it as freezable */
#define PF_SUSPEND_TASK     0x80000000  /* This thread called freeze_processes() and should not be frozen */

 123456789
10
11

/** Only the _current_ task can read/write to tsk->flags, but other* tasks can access tsk->flags in readonly mode for example* with tsk_used_math (like during threaded core dumping).* There is however an exception to this rule during ptrace* or during fork: the ptracer task is allowed to write to the* child->flags of its traced child (same goes for fork, the parent* can write to the child->flags), because we're guaranteed the* child is not running and in turn not changing child->flags* at the same time the parent does it.*/

1
2
3
4
5
6
7

/* Process credentials: */
/* Tracer's credentials at attach: */
const struct cred __rcu     *ptracer_cred;
/* Objective and real subjective task credentials (COW): */
const struct cred __rcu     *real_cred;
/* Effective (overridable) subjective task credentials (COW): */
const struct cred __rcu     *cred;

 123456789
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

struct cred {atomic_t  usage;
#ifdef CONFIG_DEBUG_CREDENTIALSatomic_t subscribers;    /* number of processes subscribed */void        *put_addr;unsigned  magic;
#define CRED_MAGIC  0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endifkuid_t        uid;        /* real UID of the task */kgid_t        gid;        /* real GID of the task */kuid_t        suid;       /* saved UID of the task */kgid_t       sgid;       /* saved GID of the task */kuid_t       euid;       /* effective UID of the task */kgid_t       egid;       /* effective GID of the task */kuid_t       fsuid;      /* UID for VFS ops */kgid_t     fsgid;      /* GID for VFS ops */// .......kernel_cap_t cap_inheritable; /* caps our children can inherit */kernel_cap_t    cap_permitted;   /* caps we're permitted */kernel_cap_t    cap_effective;   /* caps we can actually use */kernel_cap_t cap_bset;        /* capability bounding set */kernel_cap_t  cap_ambient;     /* Ambient capability set */// .......
} __randomize_layout;

 123456789
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/** The security context of a task** The parts of the context break down into two categories:**  (1) The objective context of a task.  These parts are used when some other*   task is attempting to affect this one.**  (2) The subjective context.  These details are used when the task is acting*  upon another object, be that a file, a task, a key or whatever.** Note that some members of this structure belong to both categories - the* LSM security pointer for instance.** A task has two security pointers.  task->real_cred points to the objective* context that defines that task's actual details.  The objective part of this* context is used whenever that task is acted upon.** task->cred points to the subjective context that defines the details of how* that task is going to act upon another object.  This may be overridden* temporarily to point to another security context, but normally points to the* same context as task->real_cred.*/

1
2
3
4
5
6
7
8
9

u64                utime;              //用户态消耗的CPU时间
u64             stime;              //内核态消耗的CPU时间
/* Context switch counts: */
unsigned long           nvcsw;      //自愿的上下文切换计数
unsigned long           nivcsw;     //非自愿的上下文切换计数
/* Monotonic time in nsecs: */
u64             start_time;         //进程启动时间, 不包含睡眠时间
/* Boot based time in nsecs: */
u64             real_start_time;    //进程启动时间, 包含睡眠时间

1
2
3
4
5
6
7

int                            prio;
int                         static_prio;
int                         normal_prio;
unsigned int                rt_priority;
const struct sched_class    *sched_class;
struct sched_entity         se;
struct sched_rt_entity      rt;

1
2
3
4
5
6
7

#define MAX_NICE   19
#define MIN_NICE    -20

1
2

#define NICE_TO_PRIO(nice) ((nice) + DEFAULT_PRIO)
#define PRIO_TO_NICE(prio)  ((prio) - DEFAULT_PRIO)

1
2
3

$ ps -la
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
4 S  1000 16697  8335  0  80   0 - 537617 futex_ pts/4   00:01:19 hugo

1
2
3

$ renice -n 20 -p 16697 && ps -la | grep hugo
16697 (process ID) old priority 0, new priority 19
4 S  1000 16697  8335  0  99  19 - 537617 ep_pol pts/4   00:01:20 hugo

 123456789
10
11

/* Signal handlers: */
struct signal_struct        *signal;
struct sighand_struct       *sighand;
sigset_t                    blocked;
sigset_t                    real_blocked;
/* Restored if set_restore_sigmask() was used: */
sigset_t                    saved_sigmask;
struct sigpending           pending;
unsigned long               sas_ss_sp;
size_t                      sas_ss_size;
unsigned int                sas_ss_flags;

1
2
3

// bool get_signal(struct ksignal *ksig)
struct sighand_struct *sighand = current->sighand;
struct signal_struct *signal = current->signal;

 123456789
10
11
12
13
14

$ kill -l1) SIGHUP      2) SIGINT       3) SIGQUIT      4) SIGILL      5) SIGTRAP2) SIGABRT         7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
1)  SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
2)  SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
3)  SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
4)  SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
5)  SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3
6)  SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
7)  SIGRTMIN+9 44) SIGRTMIN+10    45) SIGRTMIN+11    46) SIGRTMIN+12    47) SIGRTMIN+13
8)  SIGRTMIN+14    49) SIGRTMIN+15    50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
9)  SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
10) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
11) SIGRTMAX-1  64) SIGRTMAX

1
2

struct mm_struct       *mm;
struct mm_struct        *active_mm;

1
2
3

unsigned long start_code, end_code, start_data, end_data;
unsigned long start_brk, brk, start_stack;
unsigned long arg_start, arg_end, env_start, env_end;

1
2
3
4

/* Filesystem information: */
struct fs_struct        *fs;
/* Open file information: */
struct files_struct     *files;

1
2
3
4
5
6
7
8

struct fs_struct {int users;spinlock_t lock;seqcount_t seq;int umask;int in_exec;struct path root, pwd;
} __randomize_layout;

 123456789
10
11
12
13
14
15
16
17
18

/** Open file table structure*/
struct files_struct {
/* read mostly part */atomic_t count;bool resize_in_progress;wait_queue_head_t resize_wait;struct fdtable __rcu *fdt;struct fdtable fdtab;
/* written part on a separate cache line in SMP */spinlock_t file_lock ____cacheline_aligned_in_smp;unsigned int next_fd;unsigned long close_on_exec_init[1];unsigned long open_fds_init[1];unsigned long full_fds_bits_init[1];struct file __rcu * fd_array[NR_OPEN_DEFAULT];
};

1

#define INR_OPEN_MAX 4096  /* Hard limit for nfile rlimits */

1
2
3
4
5
6
7
8

struct fdtable {unsigned int max_fds;struct file __rcu **fd;      /* current fd array */unsigned long *close_on_exec;unsigned long *open_fds;unsigned long *full_fds_bits;struct rcu_head rcu;
};

1
2

struct thread_info     thread_info;        // 必须是task_struct的第一个成员
void                    *stack;             // 内核栈

1

#define current_thread_info() ((struct thread_info *)current)

1
2
3
4
5
6
7
8

#ifdef CONFIG_THREAD_INFO_IN_TASK
static inline struct thread_info *task_thread_info(struct task_struct *task)
{return &task->thread_info;
}
#elif !defined(__HAVE_THREAD_FUNCTIONS)
# define task_thread_info(task) ((struct thread_info *)(task)->stack)
#endif

 123456789
10
11
12
13
14
15
16
17

#ifdef CONFIG_KASAN
#define KASAN_STACK_ORDER 1
#else
#define KASAN_STACK_ORDER 0
#endif
#define THREAD_SIZE_ORDER   (2 + KASAN_STACK_ORDER)
#define THREAD_SIZE  (PAGE_SIZE << THREAD_SIZE_ORDER)