我知道fopen()在C标准库中，因此我绝对可以在C程序中调用fopen()函数。令我困惑的是为什么我也可以调用open()函数。 open()应该是系统调用，因此它不是标准库中的C函数。由于我能够成功调用open()函数，我是在调用C函数还是系统调用？
答案 0 :(得分：4)
EJP对该问题的评论和Steve Summit's answer完全符合要点：open() 两者系统调用和标准C库中的函数; fopen()是标准C库中的一个函数，用于设置文件句柄 - 类型为FILE的数据结构，其中包含可选缓冲等附加内容，以及内部调用open()还
为了进一步理解，我将展示hello.c，一个用C语言编写的用于Linux的64位x86（x86-64 AKA AMD64架构）的Hello world -program示例，它不使用该标准完全是C库。
首先，hello.c需要定义一些带内联汇编的宏，以便我们能够调用系统调用。这些是非常依赖于体系结构和操作系统的，这就是为什么它仅适用于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指的是＆＃34;独立执行环境＆＃34; ;当没有可用的C库时就是这种情况。例如，Linux内核的编写方式相同。顺便说一句，我们熟悉的正常环境称为＆＃34;托管执行环境＆＃34; 。
接下来，我们可以在系统调用周围定义两个函数或＆＃34;包装器＆＃34;：
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语言没有定义任何一种进行系统调用的方法，所以我们总是需要一个＆＃34;包装器＆＃34;某种功能。 （GNU C库确实为我们提供了syscall()函数来执行我们希望的任何系统调用 - 但这个例子的重点是根本不使用C库。）
包装函数总是涉及一些（内联）汇编。同样，由于C没有内置的方式来进行系统调用，我们需要＆＃34;扩展＆＃34;通过添加一些汇编代码来添加语言。此（内联）程序集和系统调用号是使此示例，操作系统和体系结构相关的原因。是的：例如，GNU C库包含quite a few architectures的等效包装器。
C库中的某些功能不使用任何系统调用。我们还需要一个，相当于strlen()：
static inline int my_strlen(const char *str)
{
int len = 0L;
if (!str)
return -1;
while (*str++)
len++;
return len;
}
请注意，上述代码中的任何位置均未使用NULL。这是因为它是由C库定义的宏。相反，我依赖＆＃34;逻辑null＆＃34;：(!pointer)当且仅当pointer是零指针时才是真的，这是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千字节）静态二进制文件，运行时，
./hello
输出
Hello, world!
您可以使用file hello检查文件的内容。如果文件大小非常重要，您可以运行strip hello删除所有（不需要的）符号，将文件大小进一步减小到大约1.5千字节。 （但是，这会使对象转储不那么有趣，所以在你这样做之前，请先检查下一步。）
我们可以使用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（十六进制）= 15字节的只读数据，d9（十六进制）= 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
程序集本身并不是那么有趣，除了在my_write和my_exit中你可以看到SYSCALL...()宏生成的内联汇编只是将变量加载到特定的寄存器中，并且＆＃34;做系统调用＆＃34; - 恰好是x86-64汇编指令，这里也称为syscall;在32位x86架构中，它是int $80，而在其他架构中则是其他东西。
有一个最后的皱纹，与我使用前缀my_的函数模拟C库中的函数的原因有关：C编译器可以为某些C库函数提供优化的快捷方式。对于海湾合作委员会，列出here;该列表包括strlen()。
这意味着我们实际上并不需要my_strlen()函数，因为我们可以使用GCC提供的优化__builtin_strlen()函数，即使在独立环境中也是如此。内置插件通常非常优化;在使用GCC-5.4.0的x86-64上的__builtin_strlen()的情况下，它优化到几个寄存器加载和repnz scasb %es:(%rdi),%al指令（看起来很长，但实际上只需要两个字节）。
换句话说，最后的皱纹是有第三种类型的函数，编译器内置函数，由编译器提供（但是就像C库提供的函数一样）以优化的形式提供，具体取决于使用的编译器选项和架构。
如果我们要扩展上面的示例，以便我们打开文件并将Hello, world!写入其中，并比较低级unistd.h（open() / { {1}} / write()）和标准I / O close()（stdio.h / fopen() / puts()）方法，我们发现主要区别在于标准I / O方法使用的fclose()句柄包含许多额外的东西（这使得标准文件处理非常通用，在这样一个简单的例子中没有用），最明显的是它具有缓冲方法。在汇编级别，我们仍然会看到相同的系统调用 - FILE，open，write - 已使用。
即使乍一看ELF格式（用于Linux中的二进制文件）也包含很多不需要的东西＆＃34; （对于我们上面的示例程序大约一千字节），它实际上是一种非常强大的格式。它和Linux中的动态加载器提供了一种在程序启动时（使用close环境变量）自动加载库，以及在其他库中插入函数的方法 - 实质上，用新的替换它们，但仍然可以调用函数的原始插入版本。这些允许有许多有用的技巧，修复，实验和调试方法。
答案 1 :(得分：2)
虽然“系统调用”和“库函数”之间的区别可能是一个有用的记忆，但是你必须能够以某种方式调用系统调用。通常，每个系统调用都存在于C库中 - 作为一个很小的库函数，除了转移到系统调用之外什么都不做（但是已经实现了）。
所以，是的，如果你愿意，你可以从C代码中调用open()。 （在某个地方，也许在一个名为fopen.c的文件中，你的C库的作者也可能在fopen()的实现中调用它。）
答案 2 :(得分：0)
回答问题的出发点是提出另一个问题：什么是系统调用？
通常，人们将系统调用视为在提升的处理器权限级别执行的过程。通常，这意味着从用户模式切换到内核模式（某些系统使用多种模式）。
进入内核模式的机制和应用程序取决于系统（以及一种英特尔有多种方式）。调用系统服务的一般顺序是进程执行触发更改处理器模式异常的指令。 CPU通过调用适当的异常/中断处理程序然后调度到适当的操作系统服务来响应异常。
C编程的问题在于调用系统服务需要执行特定的硬件指令并设置硬件寄存器值。操作系统提供包装函数，用于处理将参数打包到寄存器中，触发异常，然后从寄存器中解压缩返回值。
open（）函数通常是高级语言调用系统服务的包装器。如果你想一想，fopen（）通常是open（）的“包装器”。
因此，我们通常认为的系统调用是除了调用系统服务之外什么都不做的功能。