linux修改进程代码段,浅谈Linux内核创建新进程的全过程

进程描述

进程描述符(task_struct)

用来描述进程的数据结构，可以理解为进程的属性。比如进程的状态、进程的标识(PID)等，都被封装在了进程描述符这个数据结构中，该数据结构被定义为task_struct

进程控制块(PCB)

是操作系统核心中一种数据结构，主要表示进程状态。

进程状态

fork()

fork()在父、子进程各返回一次。在父进程中返回子进程的 pid，在子进程中返回0。

fork一个子进程的代码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32#include

#include

#include

int main(int argc,char * argv[])

{

int pid;

/* fork another process */

pid = fork();

if (pid < 0)

{

/* error occurred */

fprintf(stderr,"Fork Failed!");

exit(-1);

}

else if (pid == 0)

{

/* child process */

printf("This is Child Process!\n");

}

else

{

/* parent process */

printf("This is Parent Process!\n");

/* parent will wait for the child to complete*/

wait(NULL);

printf("Child Complete!\n");

}

}

进程创建

1、大致流程

fork 通过0x80中断(系统调用)来陷入内核，由系统提供的相应系统调用来完成进程的创建。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51fork.c

//fork

#ifdef __ARCH_WANT_SYS_FORK

SYSCALL_DEFINE0(fork)

{

#ifdef CONFIG_MMU

return do_fork(SIGCHLD, 0, 0, NULL, NULL);

#else

/* can not supportin nommu mode */

return -EINVAL;

#endif

}

#endif

//vfork

#ifdef __ARCH_WANT_SYS_VFORK

SYSCALL_DEFINE0(vfork)

{

return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,

0, NULL, NULL);

}

#endif

//clone

#ifdef __ARCH_WANT_SYS_CLONE

#ifdef CONFIG_CLONE_BACKWARDS

SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,

int __user *, parent_tidptr,

int, tls_val,

int __user *, child_tidptr)

#elif defined(CONFIG_CLONE_BACKWARDS2)

SYSCALL_DEFINE5(clone, unsigned long, newsp, unsigned long, clone_flags,

int __user *, parent_tidptr,

int __user *, child_tidptr,

int, tls_val)

#elif defined(CONFIG_CLONE_BACKWARDS3)

SYSCALL_DEFINE6(clone, unsigned long, clone_flags, unsigned long, newsp,

int, stack_size,

int __user *, parent_tidptr,

int __user *, child_tidptr,

int, tls_val)

#else

SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,

int __user *, parent_tidptr,

int __user *, child_tidptr,

int, tls_val)

#endif

{

return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);

}

#endif

通过看上边的代码，我们可以清楚的看到，不论是使用 fork 还是 vfork 来创建进程，最终都是通过 do_fork() 方法来实现的。接下来我们可以追踪到 do_fork()的代码：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54long do_fork(unsignedlong clone_flags,

unsignedlong stack_start,

unsignedlong stack_size,

int __user *parent_tidptr,

int __user *child_tidptr)

{

//创建进程描述符指针

struct task_struct *p;

//……

//复制进程描述符，copy_process()的返回值是一个 task_struct 指针。

p = copy_process(clone_flags, stack_start, stack_size,

child_tidptr, NULL, trace);

if (!IS_ERR(p)) {

struct completion vfork;

struct pid *pid;

trace_sched_process_fork(current, p);

//得到新创建的进程描述符中的pid

pid = get_task_pid(p, PIDTYPE_PID);

nr = pid_vnr(pid);

if (clone_flags & CLONE_PARENT_SETTID)

put_user(nr, parent_tidptr);

//如果调用的 vfork()方法，初始化 vfork 完成处理信息。

if (clone_flags & CLONE_VFORK) {

p->vfork_done = &vfork;

init_completion(&vfork);

get_task_struct(p);

}

//将子进程加入到调度器中，为其分配 CPU，准备执行

wake_up_new_task(p);

//fork 完成，子进程即将开始运行

if (unlikely(trace))

ptrace_event_pid(trace, pid);

//如果是 vfork，将父进程加入至等待队列，等待子进程完成

if (clone_flags & CLONE_VFORK) {

if (!wait_for_vfork_done(p, &vfork))

ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);

}

put_pid(pid);

}else {

nr = PTR_ERR(p);

}

return nr;

}

2、do_fork 流程

调用 copy_process 为子进程复制出一份进程信息

如果是 vfork 初始化完成处理信息

调用 wake_up_new_task 将子进程加入调度器，为之分配 CPU

如果是 vfork，父进程等待子进程完成 exec 替换自己的地址空间

3、copy_process 流程

追踪copy_process 代码(部分)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106static struct task_struct *copy_process(unsignedlong clone_flags,

unsignedlong stack_start,

unsignedlong stack_size,

int __user *child_tidptr,

struct pid *pid,

int trace)

{

int retval;

//创建进程描述符指针

struct task_struct *p;

//……

//复制当前的 task_struct

p = dup_task_struct(current);

//……

//初始化互斥变量

rt_mutex_init_task(p);

//检查进程数是否超过限制，由操作系统定义

if (atomic_read(&p->real_cred->user->processes) >=

task_rlimit(p, RLIMIT_NPROC)) {

if (p->real_cred->user != INIT_USER &&

!capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))

goto bad_fork_free;

}

//……

//检查进程数是否超过 max_threads 由内存大小决定

if (nr_threads >= max_threads)

goto bad_fork_cleanup_count;

//……

//初始化自旋锁

spin_lock_init(&p->alloc_lock);

//初始化挂起信号

init_sigpending(&p->pending);

//初始化 CPU 定时器

posix_cpu_timers_init(p);

//……

//初始化进程数据结构，并把进程状态设置为 TASK_RUNNING

retval = sched_fork(clone_flags, p);

//复制所有进程信息，包括文件系统、信号处理函数、信号、内存管理等

if (retval)

goto bad_fork_cleanup_policy;

retval = perf_event_init_task(p);

if (retval)

goto bad_fork_cleanup_policy;

retval = audit_alloc(p);

if (retval)

goto bad_fork_cleanup_perf;

/* copy all the process information */

shm_init_task(p);

retval = copy_semundo(clone_flags, p);

if (retval)

goto bad_fork_cleanup_audit;

retval = copy_files(clone_flags, p);

if (retval)

goto bad_fork_cleanup_semundo;

retval = copy_fs(clone_flags, p);

if (retval)

goto bad_fork_cleanup_files;

retval = copy_sighand(clone_flags, p);

if (retval)

goto bad_fork_cleanup_fs;

retval = copy_signal(clone_flags, p);

if (retval)

goto bad_fork_cleanup_sighand;

retval = copy_mm(clone_flags, p);

if (retval)

goto bad_fork_cleanup_signal;

retval = copy_namespaces(clone_flags, p);

if (retval)

goto bad_fork_cleanup_mm;

retval = copy_io(clone_flags, p);

//初始化子进程内核栈

retval = copy_thread(clone_flags, stack_start, stack_size, p);

//为新进程分配新的 pid

if (pid != &init_struct_pid) {

retval = -ENOMEM;

pid = alloc_pid(p->nsproxy->pid_ns_for_children);

if (!pid)

goto bad_fork_cleanup_io;

}

//设置子进程 pid

p->pid = pid_nr(pid);

//……

//返回结构体 p

return p;

调用 dup_task_struct 复制当前的 task_struct

检查进程数是否超过限制

初始化自旋锁、挂起信号、CPU 定时器等

调用 sched_fork 初始化进程数据结构，并把进程状态设置为 TASK_RUNNING

复制所有进程信息，包括文件系统、信号处理函数、信号、内存管理等

调用 copy_thread 初始化子进程内核栈

为新进程分配并设置新的 pid

4、dup_task_struct 流程

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25static struct task_struct *dup_task_struct(struct task_struct *orig)

{

struct task_struct *tsk;

struct thread_info *ti;

int node = tsk_fork_get_node(orig);

int err;

//分配一个 task_struct 节点

tsk = alloc_task_struct_node(node);

if (!tsk)

return NULL;

//分配一个 thread_info 节点，包含进程的内核栈，ti 为栈底

ti = alloc_thread_info_node(tsk, node);

if (!ti)

goto free_tsk;

//将栈底的值赋给新节点的栈

tsk->stack = ti;

//……

return tsk;

}

调用alloc_task_struct_node分配一个 task_struct 节点

调用alloc_thread_info_node分配一个 thread_info 节点，其实是分配了一个thread_union联合体,将栈底返回给 ti

1

2

3

4union thread_union {

struct thread_info thread_info;

unsignedlong stack[THREAD_SIZE/sizeof(long)];

};

最后将栈底的值 ti 赋值给新节点的栈

最终执行完dup_task_struct之后，子进程除了tsk->stack指针不同之外，全部都一样！

5、sched_fork 流程

core.c

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18int sched_fork(unsignedlong clone_flags, struct task_struct *p)

{

unsignedlong flags;

int cpu = get_cpu();

__sched_fork(clone_flags, p);

//将子进程状态设置为 TASK_RUNNING

p->state = TASK_RUNNING;

//……

//为子进程分配 CPU

set_task_cpu(p, cpu);

put_cpu();

return 0;

}

我们可以看到sched_fork大致完成了两项重要工作，一是将子进程状态设置为 TASK_RUNNING，二是为其分配 CPU

6、copy_thread 流程

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44int copy_thread(unsignedlong clone_flags, unsignedlong sp,

unsignedlong arg, struct task_struct *p)

{

//获取寄存器信息

struct pt_regs *childregs = task_pt_regs(p);

struct task_struct *tsk;

int err;

p->thread.sp = (unsignedlong) childregs;

p->thread.sp0 = (unsignedlong) (childregs+1);

memset(p->thread.ptrace_bps,0, sizeof(p->thread.ptrace_bps));

if (unlikely(p->flags & PF_KTHREAD)) {

//内核线程

memset(childregs,0, sizeof(struct pt_regs));

p->thread.ip = (unsignedlong) ret_from_kernel_thread;

task_user_gs(p) = __KERNEL_STACK_CANARY;

childregs->ds = __USER_DS;

childregs->es = __USER_DS;

childregs->fs = __KERNEL_PERCPU;

childregs->bx = sp;/* function */

childregs->bp = arg;

childregs->orig_ax = -1;

childregs->cs = __KERNEL_CS | get_kernel_rpl();

childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_FIXED;

p->thread.io_bitmap_ptr = NULL;

return 0;

}

//将当前寄存器信息复制给子进程

*childregs = *current_pt_regs();

//子进程 eax 置 0，因此fork 在子进程返回0

childregs->ax =0;

if (sp)

childregs->sp = sp;

//子进程ip 设置为ret_from_fork，因此子进程从ret_from_fork开始执行

p->thread.ip = (unsignedlong) ret_from_fork;

//……

return err;

}

copy_thread 这段代码为我们解释了两个相当重要的问题！

一是，为什么 fork 在子进程中返回0，原因是childregs->ax = 0;这段代码将子进程的 eax 赋值为0

二是，p->thread.ip = (unsigned long) ret_from_fork;将子进程的 ip 设置为 ret_form_fork 的首地址，因此子进程是从 ret_from_fork 开始执行的

总结

新进程的执行源于以下前提：

dup_task_struct中为其分配了新的堆栈

调用了sched_fork，将其置为TASK_RUNNING

copy_thread中将父进程的寄存器上下文复制给子进程，保证了父子进程的堆栈信息是一致的

将ret_from_fork的地址设置为eip寄存器的值

最终子进程从ret_from_fork开始执行。

以上就是针对Linux内核创建一个新进程的过程的详细分析，希望对大家的学习有所帮助。