c - C标准库函数与系统调用。哪个是 `open()`？

Question

我知道fopen()在C标准库中，因此我可以肯定在C程序中调用fopen()函数。我感到困惑的是为什么我也可以调用open()函数。 open()应该是系统调用，因此它不是标准库中的C函数。因为我能够成功调用open()函数，所以我正在调用C函数还是系统调用？

Answer 1

EJP对问题和Steve Summit's answer的评论恰到好处:open()既是系统调用，又是标准C库中的函数； fopen()是标准C库中的一个函数，用于设置文件句柄(即FILE类型的数据结构，其中包含诸如可选缓冲之类的其他内容)，并且还在内部调用open()。

为了进一步理解，我将展示hello.c，它是一个用C语言为Linux编写的示例，它是在64位x86(x86-64 AKA AMD64架构)上用Linux编写的，它根本不使用标准C库。

首先，hello.c需要使用内联汇编定义一些宏，以便我们能够调用syscalls。这些是非常依赖于体系结构和操作系统的，这就是为什么它仅在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，因此我们需要通过添加一些汇编代码来“扩展”该语言。此(嵌入式)程序集和syscall编号使此示例与操作系统和体系结构相关。是的:例如，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库定义的宏。相反，我依靠的是“逻辑空值”:当且仅当 (!pointer)是零指针时 pointer才为true，这是Linux中所有体系结构上 NULL的含义。我本可以定义 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  

程序集本身并没有那么有趣，除了在 my_write和 my_exit中，您可以看到 SYSCALL...()宏生成的内联程序集如何将变量加载到特定的寄存器中，并执行“do syscall”-恰好是x86-64汇编指令在这里也称为 syscall；在32位x86体系结构中，它是 int $80，而在其他体系结构中则是其他东西。

最后的皱纹与我为什么在与C库中的函数类似的函数中使用前缀 my_的原因有关: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()/ write()/ close())和标准I/O stdio.h( fopen()/ puts()/ fclose())方法，我们发现主要区别在于标准I/O方法使用的 FILE句柄包含很多额外的内容(这使标准文件句柄具有相当多的用途，只是在这样的琐碎示例中没有用)，大多数在其缓冲方法中可见。在汇编级别，我们仍然会看到相同的系统调用- open， write和 close。

即使乍一看，ELF格式(用于Linux中的二进制文件)包含许多“不需要的东西”(对于我们上面的示例程序来说，大约是一千字节)，但实际上它是一种非常强大的格式。它以及Linux中的动态加载器，提供了一种在程序启动时自动加载库的方法(使用 LD_PRELOAD环境变量)，以及将函数插入其他库中的方法-本质上是用新的库替换它们，但是可以通过仍然能够调用该函数的原始插入版本。这些允许使用许多有用的技巧，修复，实验和调试方法。