Tia*_*nyi 1 c linux operating-system linux-kernel
我知道fopen()它在C标准库中，因此我绝对可以fopen()在C程序中调用该函数。我感到困惑的是为什么我也可以调用该open()函数。open()应该是系统调用，因此它不是标准库中的C函数。因为我能够成功调用该open()函数，所以我是在调用C函数还是系统调用？
EJP对问题和意见史蒂夫峰会的回答是完全相同的一点：open()是这两个系统调用，并在标准C库中的函数; fopen()是标准C库中的一个函数，该函数设置文件句柄（一种类型的数据结构，FILE其中包含诸如可选缓冲之类的其他内容），并在内部进行调用open()。
为了进一步理解，我将展示hello.c一个示例性的Hello world程序，它是用C语言为Linux编写的，用于64位x86（x86-64 AKA AMD64架构），它根本不使用标准C库。
首先，hello.c需要使用内联汇编定义一些宏，以便我们能够调用syscall。这些是非常依赖于体系结构和操作系统的，这就是为什么它仅在x86-64体系结构上的Linux中有效的原因：
/* Freestanding Hello World example in Linux on x86_64/x86.
* Compile using
* gcc -march=x86-64 -mtune=generic -m64 -ffreestanding -nostdlib -nostartfiles hello.c -o hello
*/
#define STDOUT_FILENO 1
#define EXIT_SUCCESS 0
#ifndef __x86_64__
#error This program only works on x86_64 architecture!
#endif
#define SYS_write 1
#define SYS_exit 60
#define SYSCALL1_NORET(nr, arg1) \
__asm__ ( "syscall\n\t" \
: \
: "a" (nr), "D" (arg1) \
: "rcx", "r11" )
#define SYSCALL3(retval, nr, arg1, arg2, arg3) \
__asm__ ( "syscall\n\t" \
: "=a" (retval) \
: "a" (nr), "D" (arg1), "S" (arg2), "d" (arg3) \
: "rcx", "r11" )
将Freestanding在该文件的开头的注释是指“独立执行环境” ; 根本没有C库可用的情况。例如，Linux内核是用相同的方式编写的。顺便说一句，我们熟悉的普通环境称为“托管执行环境”。
接下来，我们可以围绕syscall定义两个函数或“包装器”：
static inline void my_exit(int retval)
{
SYSCALL1_NORET(SYS_exit, retval);
}
static inline int my_write(int fd, const void *data, int len)
{
int retval;
if (fd == -1 || !data || len < 0)
return -1;
SYSCALL3(retval, SYS_write, fd, data, len);
if (retval < 0)
return -1;
return retval;
}
以上，my_exit()大致相当于C标准库exit()函数，my_write()来write()。
C语言没有定义执行syscall的任何方式，因此这就是为什么我们总是需要某种“包装器”功能的原因。（GNU C库确实syscall()为我们提供了执行所需的任何系统调用的功能-但本示例的要点是根本不使用C库。）
包装函数始终涉及一些（内联）汇编。同样，由于C没有内置的方法可以进行系统调用，因此我们需要通过添加一些汇编代码来“扩展”该语言。此（嵌入式）程序集和syscall编号使此示例与操作系统和体系结构相关。是的：例如，GNU C库包含相当多体系结构的等效包装器。
C库中的某些函数不使用任何系统调用。我们还需要一个，相当于strlen()：
static inline int my_strlen(const char *str)
{
int len = 0L;
if (!str)
return -1;
while (*str++)
len++;
return len;
}
请注意，NULL以上代码中的任何地方都没有使用过。这是因为它是C库定义的宏。相反，我依赖于“逻辑空”：(!pointer)当且仅当pointer是零指针时才为true ，这NULL在Linux中的所有体系结构上都是如此。我本可以定义NULL自己，但我没有定义自己，希望有人可以注意到它的不足。
最后，main()它本身就是GNU C库调用的东西，例如在Linux中，二进制文件的实际起点称为_start。在_start由托管运行时环境提供，并初始化C库的数据结构并执行其它类似的制剂。我们的示例程序是如此简单，我们不需要它，因此我们可以将简单的主程序部分放入其中_start：
void _start(void)
{
const char *msg = "Hello, world!\n";
my_write(STDOUT_FILENO, msg, my_strlen(msg));
my_exit(EXIT_SUCCESS);
}
如果将以上所有内容放在一起，然后使用进行编译
gcc -march=x86-64 -mtune=generic -m64 -ffreestanding -nostdlib -nostartfiles hello.c -o hello
根据文件开头的注释，您将得到一个很小的（约2 KB）静态二进制文件，该二进制文件在运行时，
./hello
输出
Hello, world!
您可以file hello用来检查文件的内容。strip hello如果文件大小确实很重要，则可以删除所有（不需要的）符号，将文件大小进一步减小到大约一个半字节。（但是，这将使对象转储变得不那么有趣，因此，在执行此操作之前，请先检查下一步。）
我们可以objdump -x hello用来检查文件中的各个部分：
hello: file format elf64-x86-64
hello
architecture: i386:x86-64, flags 0x00000112:
EXEC_P, HAS_SYMS, D_PAGED
start address 0x00000000004001e1
Program Header:
LOAD off 0x0000000000000000 vaddr 0x0000000000400000 paddr 0x0000000000400000 align 2**21
filesz 0x00000000000002f0 memsz 0x00000000000002f0 flags r-x
NOTE off 0x0000000000000120 vaddr 0x0000000000400120 paddr 0x0000000000400120 align 2**2
filesz 0x0000000000000024 memsz 0x0000000000000024 flags r--
EH_FRAME off 0x000000000000022c vaddr 0x000000000040022c paddr 0x000000000040022c align 2**2
filesz 0x000000000000002c memsz 0x000000000000002c flags r--
STACK off 0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**4
filesz 0x0000000000000000 memsz 0x0000000000000000 flags rw-
Sections:
Idx Name Size VMA LMA File off Algn
0 .note.gnu.build-id 00000024 0000000000400120 0000000000400120 00000120 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
1 .text 000000d9 0000000000400144 0000000000400144 00000144 2**0
CONTENTS, ALLOC, LOAD, READONLY, CODE
2 .rodata 0000000f 000000000040021d 000000000040021d 0000021d 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
3 .eh_frame_hdr 0000002c 000000000040022c 000000000040022c 0000022c 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
4 .eh_frame 00000098 0000000000400258 0000000000400258 00000258 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
5 .comment 00000034 0000000000000000 0000000000000000 000002f0 2**0
CONTENTS, READONLY
SYMBOL TABLE:
0000000000400120 l d .note.gnu.build-id 0000000000000000 .note.gnu.build-id
0000000000400144 l d .text 0000000000000000 .text
000000000040021d l d .rodata 0000000000000000 .rodata
000000000040022c l d .eh_frame_hdr 0000000000000000 .eh_frame_hdr
0000000000400258 l d .eh_frame 0000000000000000 .eh_frame
0000000000000000 l d .comment 0000000000000000 .comment
0000000000000000 l df *ABS* 0000000000000000 hello.c
0000000000400144 l F .text 0000000000000016 my_exit
000000000040015a l F .text 000000000000004e my_write
00000000004001a8 l F .text 0000000000000039 my_strlen
0000000000000000 l df *ABS* 0000000000000000
000000000040022c l .eh_frame_hdr 0000000000000000 __GNU_EH_FRAME_HDR
00000000004001e1 g F .text 000000000000003c _start
0000000000601000 g .eh_frame 0000000000000000 __bss_start
0000000000601000 g .eh_frame 0000000000000000 _edata
0000000000601000 g .eh_frame 0000000000000000 _end
本.text节包含我们的代码和.rodata不可变常量；在这里，只是Hello, world!字符串文字。其余部分是链接器添加的内容以及系统使用的内容。我们可以看到，我们有f（hex）= 15字节的只读数据，和d9（hex）= 217字节的代码；文件的其余部分（大约一千字节左右）是链接器添加的ELF内容，供内核在执行此二进制文件时使用。
我们甚至可以hello通过运行objdump -d hello以下命令检查其中包含的实际汇编代码：
hello: file format elf64-x86-64
Disassembly of section .text:
0000000000400144 <my_exit>:
400144: 55 push %rbp
400145: 48 89 e5 mov %rsp,%rbp
400148: 89 7d fc mov %edi,-0x4(%rbp)
40014b: b8 3c 00 00 00 mov $0x3c,%eax
400150: 8b 55 fc mov -0x4(%rbp),%edx
400153: 89 d7 mov %edx,%edi
400155: 0f 05 syscall
400157: 90 nop
400158: 5d pop %rbp
400159: c3 retq
000000000040015a <my_write>:
40015a: 55 push %rbp
40015b: 48 89 e5 mov %rsp,%rbp
40015e: 89 7d ec mov %edi,-0x14(%rbp)
400161: 48 89 75 e0 mov %rsi,-0x20(%rbp)
400165: 89 55 e8 mov %edx,-0x18(%rbp)
400168: 83 7d ec ff cmpl $0xffffffff,-0x14(%rbp)
40016c: 74 0d je 40017b <my_write+0x21>
40016e: 48 83 7d e0 00 cmpq $0x0,-0x20(%rbp)
400173: 74 06 je 40017b <my_write+0x21>
400175: 83 7d e8 00 cmpl $0x0,-0x18(%rbp)
400179: 79 07 jns 400182 <my_write+0x28>
40017b: b8 ff ff ff ff mov $0xffffffff,%eax
400180: eb 24 jmp 4001a6 <my_write+0x4c>
400182: b8 01 00 00 00 mov $0x1,%eax
400187: 8b 7d ec mov -0x14(%rbp),%edi
40018a: 48 8b 75 e0 mov -0x20(%rbp),%rsi
40018e: 8b 55 e8 mov -0x18(%rbp),%edx
400191: 0f 05 syscall
400193: 89 45 fc mov %eax,-0x4(%rbp)
400196: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
40019a: 79 07 jns 4001a3 <my_write+0x49>
40019c: b8 ff ff ff ff mov $0xffffffff,%eax
4001a1: eb 03 jmp 4001a6 <my_write+0x4c>
4001a3: 8b 45 fc mov -0x4(%rbp),%eax
4001a6: 5d pop %rbp
4001a7: c3 retq
00000000004001a8 <my_strlen>:
4001a8: 55 push %rbp
4001a9: 48 89 e5 mov %rsp,%rbp
4001ac: 48 89 7d e8 mov %rdi,-0x18(%rbp)
4001b0: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
4001b7: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
4001bc: 75 0b jne 4001c9 <my_strlen+0x21>
4001be: b8 ff ff ff ff mov $0xffffffff,%eax
4001c3: eb 1a jmp 4001df <my_strlen+0x37>
4001c5: 83 45 fc 01 addl $0x1,-0x4(%rbp)
4001c9: 48 8b 45 e8 mov -0x18(%rbp),%rax
4001cd: 48 8d 50 01 lea 0x1(%rax),%rdx
4001d1: 48 89 55 e8 mov %rdx,-0x18(%rbp)
4001d5: 0f b6 00 movzbl (%rax),%eax
4001d8: 84 c0 test %al,%al
4001da: 75 e9 jne 4001c5 <my_strlen+0x1d>
4001dc: 8b 45 fc mov -0x4(%rbp),%eax
4001df: 5d pop %rbp
4001e0: c3 retq
00000000004001e1 <_start>:
4001e1: 55 push %rbp
4001e2: 48 89 e5 mov %rsp,%rbp
4001e5: 48 83 ec 10 sub $0x10,%rsp
4001e9: 48 c7 45 f8 1d 02 40 movq $0x40021d,-0x8(%rbp)
4001f0: 00
4001f1: 48 8b 45 f8 mov -0x8(%rbp),%rax
4001f5: 48 89 c7 mov %rax,%rdi
4001f8: e8 ab ff ff ff callq 4001a8 <my_strlen>
4001fd: 89 c2 mov %eax,%edx
4001ff: 48 8b 45 f8 mov -0x8(%rbp),%rax
400203: 48 89 c6 mov %rax,%rsi
400206: bf 01 00 00 00 mov $0x1,%edi
40020b: e8 4a ff ff ff callq 40015a <my_write>
400210: bf 00 00 00 00 mov $0x0,%edi
400215: e8 2a ff ff ff callq 400144 <my_exit>
40021a: 90 nop
40021b: c9 leaveq
40021c: c3 retq
程序集本身并没有那么有趣，除了in my_write，my_exit您可以看到SYSCALL...()宏生成的内联程序集如何将变量仅加载到特定寄存器中，并执行“ do syscall”（恰好是x86-64）汇编指令syscall在这里也称为；在32位x86架构中，它是int $80，而在其他架构中则是其他。
最后一个皱纹，与我为什么要使用my_类似于C库中函数的函数前缀有关：C编译器可以为某些C库函数提供优化的快捷方式。对于海湾合作委员会，这些在这里列出；清单包括strlen()。
这意味着我们实际上并不需要该my_strlen()功能，因为__builtin_strlen()即使在独立环境中，我们也可以使用GCC提供的优化功能。内置的通常是非常优化的。在__builtin_strlen()使用GCC-5.4.0的x86-64上，它优化为只有几个寄存器加载和一条repnz scasb %es:(%rdi),%al指令（看起来很长，但实际上只占用两个字节）。
换句话说，最后的难题是存在第三种类型的函数，即编译器内置程序，它们由编译器以优化形式提供（但与C库提供的功能类似），具体取决于编译器选项和使用的架构。
如果我们扩展上面的示例，以便我们打开一个文件并将其写入Hello, world!其中，并比较低级unistd.h（open()/ write()/ close()）和标准I / O stdio.h（fopen()/ puts()/ fclose()）方法，我们会发现主要区别在于FILE因为标准I / O方法使用的句柄包含很多额外的内容（这使得标准文件句柄相当通用，只是在这种琐碎的示例中没有用），在其缓冲方法中最明显。在装配水平，我们仍然会看到相同的系统调用- ，，open -使用。writeclose
即使乍一看，ELF格式（用于Linux中的二进制文件）包含许多“不需要的东西”（对于我们上面的示例程序来说，大约是一千字节），但实际上它是一种非常强大的格式。它以及Linux中的动态加载器，提供了一种在程序启动时自动加载库的方法（使用LD_PRELOAD环境变量），以及将函数插入其他库中的方法-本质上是用新的库替换它们，但仍然可以能够调用该函数的原始插入版本。这些允许使用许多有用的技巧，修复，实验和调试方法。
尽管“系统调用”和“库函数”之间的区别可能是一个值得记住的有用的区别，但存在的问题是您必须能够以某种方式调用系统调用。一般来说，每个系统调用都存在于 C 库中——作为一个瘦小的库函数，除了转移到系统调用之外什么也不做（不管它是如何实现的）。
所以，是的，open()如果您愿意，您可以从 C 代码中调用。（在某个地方，也许在一个名为 的文件中fopen.c，您的 C 库的作者也可能在 的实现中调用了它fopen()。）
| 归档时间： |
|
| 查看次数： |
1247 次 |
| 最近记录： |