linux clone线程,进程和线程创建glibc部分分析——clone() fork()

深藏阁楼爱情的钟 2023-01-21 02:19 13阅读 0赞

系统调用是操作系统提供的服务，用户程序通过各种系统调用，来引用内核提供的各种服务，系统调用的执行让

用户程序陷入内核，该陷入动作由swi软中断完成。当用户态的进程调用一个系统调用时，CPU通过软中断切换到

SVC模式并开始执行一个内核函数，完成用户态进程需要完成的工作。

fork():

path: glibc-2.3.6/nptl/sysdeps/unix/sysv/linux/pt-fork.c

\#include // include \_\_libc\_fork()函数声明

pid\_t \_\_fork (void)

return \_\_libc\_fork ();

strong\_alias (\_\_fork, fork) // ./include/libc-symbols.h

// 实际上这里告诉编译器fork这个名字就代表着\_\_fork这个名字，如果这里没有

// \_\_fork()的定义，编译器就会报错。

// 类似地，存在weak\_alias(XXX, xxx),也是取别名，但是编译器在XXX没有定义

// 的时候，不会报错。

// 可以参考强符号、弱符号，强引用和弱引用来理解它

vfork():

path: glibc-2.3.6/sysdeps/generic/vfork.c

\#include

\_\_pid\_t \_\_vfork (void)

return \_\_fork ();

libc\_hidden\_def (\_\_vfork)

weak\_alias (\_\_vfork, vfork)

可以看出调用vfork是\_\_vfork的别名,并且实际上是调用了\_\_fork函数来实现\_\_vfork函数的

clone():

path: glibc-2.3.6/sysdeps/unix/sysv/linux/arm/clone.S

该文件中是用汇编代码实现了\_\_clone函数，存在：

weak\_alias (\_\_clone, clone)

\_\_clone()函数声明如下：

extern int \_\_clone (int (\*\_\_fn) (void \*\_\_arg), void \*\_\_child\_stack,

int \_\_flags, void \*\_\_arg, ...);

path: glibc-2.3.6/include/sched.h

pthread\_create():

该函数的源码位置比较特殊，位于目录linuxthread目录下。

path:linuxthread/pthread.c

...

\_\_pthread\_create\_2\_1()

\_\_pthread\_create\_2\_0(),最终还是调用\_\_pthread\_create\_2\_1()来实现的。

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

\_\_libc\_fork():

path: glibc-2.3.6/nptl/sysdeps/unix/sysv/linux/fork.c

...

\#ifdef ARCH\_FORK

pid = ARCH\_FORK ();

\#else

\# error "ARCH\_FORK must be defined so that the CLONE\_SETTID flag is

used"

pid = INLINE\_SYSCALL (fork, 0);

\#endif

...

这里pid = INLINE\_SYSCALL (fork, 0);语句会得到执行，下面是3个重要的头文件：

sysdeps/unix/sysv/linux/arm/sysdep.h

sysdeps/unix/arm/sysdep.h

sysdeps/unix/sysdep.h

sysdeps/arm/sysdep.h

INLINE\_SYSCALL这个宏定义于文件sysdeps/unix/sysv/linux/arm/sysdep.h中,该处的宏定义很复杂：

...

\#define SYS\_ify(syscall\_name) (\_\_NR\_\#\#syscall\_name) // 获取中断号

中断号定义在：arm平台文件系统(制作文件系统时，需要拷贝交叉工具链中的头文件和库)中include/asm/unistd.h

\#define \_\_NR\_restart\_syscall (\_\_NR\_SYSCALL\_BASE+ 0)

\#define \_\_NR\_exit (\_\_NR\_SYSCALL\_BASE+ 1)

\#define \_\_NR\_fork (\_\_NR\_SYSCALL\_BASE+ 2)

\#define \_\_NR\_read (\_\_NR\_SYSCALL\_BASE+ 3)

\#define \_\_NR\_write (\_\_NR\_SYSCALL\_BASE+ 4)

\#define \_\_NR\_open (\_\_NR\_SYSCALL\_BASE+ 5)

...

\#define \_\_NR\_vfork (\_\_NR\_SYSCALL\_BASE+ 190)

...

\#define \_\_NR\_clone (\_\_NR\_SYSCALL\_BASE+ 120)

...

\*\*\*/

...

\#undef INLINE\_SYSCALL

\#define INLINE\_SYSCALL(name, nr, args...) \\

(\{ unsigned int \_sys\_result = INTERNAL\_SYSCALL (name, , nr, args);

\\ // note1

if (\_\_builtin\_expect (INTERNAL\_SYSCALL\_ERROR\_P (\_sys\_result, ), 0))

\\ // 软中断异常返回处理

\{ \\

\_\_set\_errno (INTERNAL\_SYSCALL\_ERRNO (\_sys\_result, )); \\

\_sys\_result = (unsigned int) -1; \\

\} \\

(int) \_sys\_result; \})

\#undef INTERNAL\_SYSCALL\_DECL

\#define INTERNAL\_SYSCALL\_DECL(err) do \{ \} while (0)

\#undef INTERNAL\_SYSCALL // note1

\#define INTERNAL\_SYSCALL(name, err, nr, args...) \\

(\{ unsigned int \_sys\_result; \\

\{ \\

LOAD\_ARGS\_\#\#nr (args) \\

asm volatile ("swi %1 @ syscall " \#name \\ // swi

产生一个软中断异常，%1代表第一个输入参数

: "=r" (\_a1) \\ // \_a1 = rx

: "i" (SYS\_ify(name)) ASM\_ARGS\_\#\#nr \\ // 输入参数：软中断号(立即数)，参数列表

: "memory"); \\ // 告诉编译器内存可能被改变

\_sys\_result = \_a1; \\

\} \\

(int) \_sys\_result; \})

\#undef INTERNAL\_SYSCALL\_ERROR\_P

\#define INTERNAL\_SYSCALL\_ERROR\_P(val, err) \\

((unsigned int) (val) >= 0xfffff001u)

\#undef INTERNAL\_SYSCALL\_ERRNO

\#define INTERNAL\_SYSCALL\_ERRNO(val, err) (-(val))

\#define LOAD\_ARGS\_0()

\#define ASM\_ARGS\_0

\#define LOAD\_ARGS\_1(a1) \\

\_a1 = (int) (a1); \\

LOAD\_ARGS\_0 ()

\#define ASM\_ARGS\_1 ASM\_ARGS\_0, "r" (\_a1)

\#define LOAD\_ARGS\_2(a1, a2) \\

LOAD\_ARGS\_1 (a1)

\#define ASM\_ARGS\_2 ASM\_ARGS\_1, "r" (\_a2)

\#define LOAD\_ARGS\_3(a1, a2, a3) \\

LOAD\_ARGS\_2 (a1, a2)

\#define ASM\_ARGS\_3 ASM\_ARGS\_2, "r" (\_a3)

\#define LOAD\_ARGS\_4(a1, a2, a3, a4) \\

LOAD\_ARGS\_3 (a1, a2, a3)

\#define ASM\_ARGS\_4 ASM\_ARGS\_3, "r" (\_a4)

\#define LOAD\_ARGS\_5(a1, a2, a3, a4, a5) \\

LOAD\_ARGS\_4 (a1, a2, a3, a4)

\#define ASM\_ARGS\_5 ASM\_ARGS\_4, "r" (\_v1)

\#define LOAD\_ARGS\_6(a1, a2, a3, a4, a5, a6) \\

LOAD\_ARGS\_5 (a1, a2, a3, a4, a5)

\#define ASM\_ARGS\_6 ASM\_ARGS\_5, "r" (\_v2)

\#define LOAD\_ARGS\_7(a1, a2, a3, a4, a5, a6, a7) \\

LOAD\_ARGS\_6 (a1, a2, a3, a4, a5, a6)

\#define ASM\_ARGS\_7 ASM\_ARGS\_6, "r" (\_v3)

APCS 是arm过程调用标准(ARM Procedure Call Standard)。

APCS 对我们通常称为 R0 到 R14 的寄存器起了不同的名字，如下：

Reg\# APCS 意义

R0 a1 工作寄存器

R1 a2 "

R2 a3 "

R3 a4 "

R4 v1 必须保护

R5 v2 "

R6 v3 "

R7 v4 "

R8 v5 "

R9 v6 "

R10 sl 栈限制

R11 fp 桢指针

R12 ip

R13 sp 栈指针

R14 lr 连接寄存器

R15 pc 程序计数器

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

\_\_clone()

.text

ENTRY(\_\_clone)

@ sanity check args

cmp r0, \#0

cmpne r1, \#0

moveq r0, \#-EINVAL

beq PLTJMP(syscall\_error)

@ insert the args onto the new stack

str r3, \[r1, \#-4\]! // 线程函数参数入栈，(child\_stack)

str r0, \[r1, \#-4\]! // 线程函数指针入栈

@ do the system call

@ get flags

mov r0, r2 // flags 存入r0

@ new sp is already in r1

swi SYS\_ify(clone) // swi \_\_NR\_clone, 产生软中断异常

movs a1, a1

blt PLTJMP(C\_SYMBOL\_NAME(\_\_syscall\_error))

RETINSTR(ne, lr)

@ pick the function arg and call address off the stack and

execute

ldr r0, \[sp, \#4\]

mov lr, pc

ldr pc, \[sp\]

@ and we are done, passing the return value through r0

b PLTJMP(\_exit)

linux clone线程,进程和线程创建glibc部分分析——clone() fork()

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关【Linux基础】进程和线程

相关【多线程】什么是线程？线程和进程的关系？创建线程，生命周期

相关多线程之进程、线程以及线程的创建

相关【Linux】进程和线程

相关 linux clone线程,进程和线程创建glibc部分分析——clone() fork()

相关多线程和fork

相关操作系统 — 线程和fork

相关 linux进程创建过程与原理 & linux进程创建：fork、vfork和clone联系与区别

相关 linux进程创建：fork、vfork和clone联系与区别

相关复习linux进程和线程