__IO_FILE 结构分析

参考资料：https://blog.csdn.net/yjh_fnu_ltn/article/details/141143289?spm=1001.2101.3001.10752

https://xz.aliyun.com/news/15283

https://blog.csdn.net/KaliLinux_V/article/details/146547239?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0-146547239-blog-115327308.235^v43^pc_blog_bottom_relevance_base4&spm=1001.2101.3001.4242.1&utm_relevant_index=2

https://p0ach1l.github.io/2024/12/07/IO%E7%B3%BB%E5%88%97%E4%B9%8B%E8%AE%A4%E8%AF%86IO_FILE/

__IO_FILE 结构体：

__IO_FILE 结构体：通过 chain 域链接 stderr、stdout、stdin 的链表，链表的表头是 __IO_list_all，stderr，stdout，stdin，是程序启动时打开的文件流。__IO_FILE 结构体定义在 libio.h 文件当中，gdb 查看结构体可以使用命令：p *__IO_list_all

FILE 在 Linux 系统的 IO 库中是用于描述文件的结构，称为文件流。FILE 结构在程序执行 fopen 等函数是会进行创建，并分配在堆中。我们常定义一个指向 FILE 结构的指针来接收这个返回值。FILE 结构定义在 libio.h，如下图所示：

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
struct _IO_FILE {
  int _flags;       /* 高字位为_IO_MAGIC魔数；剩余位为文件状态标志 */
#define _IO_file_flags _flags

  char* _IO_read_ptr;   /* 当前读指针：指向缓冲区中下一个待读取的字符 */
  char* _IO_read_end;   /* 读缓冲区结束指针：读取区域的末尾边界 */
  char* _IO_read_base;  /* 读缓冲区基地址：回退区域+读取区域的起始位置 */
  char* _IO_write_base; /* 写缓冲区基地址：写入区域的起始位置 */
  char* _IO_write_ptr;  /* 当前写指针：指向缓冲区中下一个待写入的位置 */
  char* _IO_write_end;  /* 写缓冲区结束指针：写入区域的末尾边界 */
  char* _IO_buf_base;   /* 缓冲区起始地址：预留缓冲区的起始位置 */
  char* _IO_buf_end;    /* 缓冲区结束地址：预留缓冲区的末尾位置 */
  /* 以下字段用于支持文件位置回退与撤销操作 */
  char *_IO_save_base; /* 保存的基地址：指向非当前读取区域的起始位置 */
  char *_IO_backup_base;  /* 备份基地址：指向备份区域中第一个有效字符 */
  char *_IO_save_end; /* 保存的结束地址：指向非当前读取区域的末尾位置 */

  struct _IO_marker *_markers; /* 文件标记链表：用于记录流的标记位置 */

  struct _IO_FILE *_chain; /* 流链表指针：将所有打开的文件流串联起来 */

  int _fileno; /* 文件描述符：对应操作系统打开文件的编号 */
#if 0
  int _blksize; /* 块大小（已废弃） */
#else
  int _flags2;  /* 扩展文件状态标志 */
#endif
  _IO_off_t _old_offset; /* 文件偏移量（旧版）：原名为_offset，因空间不足重命名 */

#define __HAVE_COLUMN /* 临时宏定义：表示支持列号功能 */
  /* 写基地址的列号+1；0表示未知 */
  unsigned short _cur_column; /* 当前列号：记录输出的列位置 */
  signed char _vtable_offset; /* 虚表偏移量：用于C++流继承体系 */
  char _shortbuf[1]; /* 微型临时缓冲区：用于无缓冲I/O的临时存储 */

  /*  废弃字段：原保存读指针和读结束指针 */
  /*  char* _save_gptr;  char* _save_egptr; */

  _IO_lock_t *_lock; /* 线程互斥锁：保证多线程环境下I/O操作安全 */
#ifdef _IO_USE_OLD_IO_FILE
};

1
2
3
stderr           stdout           stdin
IO_list_all  ––⇨     flag      ¦ ⇨   flag      ¦ ⇨   flag
                     chain   __/     chain    __/      chain

stdin、stdout和stderr是C语言中标准输入、标准输出和标准错误流的文件指针。它们是通过_IO_FILE结构体实现的，并在程序启动时由系统自动初始化，并与对应的_IO_FILE结构体实例相关联，提供了标准化的输入输出接口。

1774930607848-b42fe989-5575-41e5-a433-cac5a0902878.png

他们之间的连接用的就是上面结构题中的chain字段，而链表的头部是依靠全局变量io_list_all来串起来的。

我们还可以通过 ptype _IO_list_all.file查找 chain 的偏移：

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
pwndbg> ptype _IO_list_all.file
type = struct _IO_FILE {    
    int _flags;    
    char *_IO_read_ptr;    
    char *_IO_read_end;    
    char *_IO_read_base;    
    char *_IO_write_base;    
    char *_IO_write_ptr;    
    char *_IO_write_end;    
    char *_IO_buf_base;    
    char *_IO_buf_end;    
    char *_IO_save_base;    
    char *_IO_backup_base;    
    char *_IO_save_end;    
    
    struct _IO_marker *_markers;    
    struct _IO_FILE *_chain;       // chain的偏移在0x68处
    int _fileno;    
    int _flags2 : 24;    
    char _short_backupbuf[1];    
    __off_t _old_offset;    
    unsigned short _cur_column;    
    signed char _vtable_offset;    
    char _shortbuf[1];    
    _IO_lock_t *_lock;    
    __off64_t _offset;    
    struct _IO_codecvt *_codecvt;    
    struct _IO_wide_data *_wide_data;    
    struct _IO_FILE *_freeres_list;    
    void *_freeres_buf;    
    struct _IO_FILE **_prevchain;    
    int _mode;    
    int _unused3;    
    __uint64_t _total_written;    
    char _unused2[8];
}

上面说过了，这三个部分在程序启动的时候就会自动初始化 ，所以我们只要运行程序，就可以找到这三个部分，要注意的是，他们位于libc，也就是泄露libc，就可以找到他们，当然，其实不泄露也可以找到，这三个部分会在bss上面有数据

以上是 LINUX 系统 C 语言标准库(glibc)中 FILE*的底层实现，我们常用的 fopen/fread/fwrite 都是基于它封装的。管理文件缓冲区、文件状态、读写指针、线程安全、文件描述符 等所有文件流相关信息。

__IO_FILE_plus 结构体：

定义在 libioP.h 中，包含 vtable 虚函数表：

1
2
3
4
5
// 扩展结构体 _IO_FILE_plus（包含 vtable）
struct _IO_FILE_plus {
    struct _IO_FILE file;             // 基础 _IO_FILE 结构体
    const struct _IO_jump_t* vtable;  // 虚函数表指针（核心利用点）
};

1774932600446-07972400-1404-4145-abd3-57f6c8c8cbe3.png

1772972824034-cdf82f60-5fce-477b-8cf4-cbc86e9b08b9.png

vtable 本质是指向 _IO_jump_t 结构体的指针，而 _IO_jump_t 里的每一个成员都是**函数指针**，glibc 内部的标准 IO 函数（如 fflush、fwrite、fclose 等）最终都会通过这些函数指针执行具体逻辑。

vtable 是一个函数指针数组，存储量一个类的虚函数的地址， __IO_jump_t 是一个结构体，它定义类一组函数指针，用于实现 __IO_FILE_plus 结构体中的虚函数表。这些函数指针对应了__IO_FILE_plus 就够提的各种操作。通过虚函数表可以实现对 _IO_FILE_plus 中的函数进行动态绑定，使得在运行时可以根据具体对象的类型来调用相应的函数。

gdb查看结构体内容时可以使用命令:p *_IO_list_all->vtable

__IO_ jump_t 结构体

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
struct _IO_jump_t
{
    JUMP_FIELD(size_t, __dummy);
    JUMP_FIELD(size_t, __dummy2);
    JUMP_FIELD(_IO_finish_t, __finish);
    JUMP_FIELD(_IO_overflow_t, __overflow);
    JUMP_FIELD(_IO_underflow_t, __underflow);
    JUMP_FIELD(_IO_underflow_t, __uflow);
    JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
    /* showmany */
    JUMP_FIELD(_IO_xsputn_t, __xsputn);
    JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
    JUMP_FIELD(_IO_seekoff_t, __seekoff);
    JUMP_FIELD(_IO_seekpos_t, __seekpos);
    JUMP_FIELD(_IO_setbuf_t, __setbuf);
    JUMP_FIELD(_IO_sync_t, __sync);
    JUMP_FIELD(_IO_doallocate_t, __doallocate);
    JUMP_FIELD(_IO_read_t, __read);
    JUMP_FIELD(_IO_write_t, __write);
    JUMP_FIELD(_IO_seek_t, __seek);
    JUMP_FIELD(_IO_close_t, __close);
    JUMP_FIELD(_IO_stat_t, __stat);
    JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
    JUMP_FIELD(_IO_imbue_t, __imbue);
#if 0
    get_column;
    set_column;
#endif
};

__IO_wide_data 结构体：结构体中实现了虚表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
struct _IO_wide_data
{
  wchar_t *_IO_read_ptr;    /* 当前读指针：指向宽字符缓冲区中下一个待读取的位置 */
  wchar_t *_IO_read_end;    /* 读区域结束指针：宽字符读取区域的末尾边界 */
  wchar_t *_IO_read_base;   /* 读区域基地址：宽字符回退区域+读取区域的起始地址 */
  wchar_t *_IO_write_base;  /* 写区域基地址：宽字符写入区域的起始地址 */
  wchar_t *_IO_write_ptr;   /* 当前写指针：指向宽字符缓冲区中下一个待写入的位置 */
  wchar_t *_IO_write_end;   /* 写区域结束指针：宽字符写入区域的末尾边界 */
  wchar_t *_IO_buf_base;    /* 缓冲区基地址：宽字符预留缓冲区的起始地址 */
  wchar_t *_IO_buf_end;     /* 缓冲区结束指针：宽字符预留缓冲区的末尾地址 */
  /* 以下字段用于支持文件位置回退与撤销操作 */
  wchar_t *_IO_save_base;   /* 保存基地址：指向非当前宽字符读取区域的起始位置 */
  wchar_t *_IO_backup_base; /* 备份基地址：指向宽字符备份区域中第一个有效字符 */
  wchar_t *_IO_save_end;    /* 保存结束指针：指向非当前宽字符读取区域的末尾位置 */

  __mbstate_t _IO_state;        /* 多字节/宽字符转换状态：当前字符编码转换状态 */
  __mbstate_t _IO_last_state;   /* 上一次转换状态：记录编码转换的历史状态 */
  struct _IO_codecvt _codecvt;  /* 字符转换规则：多字节与宽字符之间的转换策略 */

  wchar_t _shortbuf[1];         /* 微型临时宽字符缓冲区：无缓冲I/O时临时存储 */

  const struct _IO_jump_t *_wide_vtable; /* 宽字符虚函数表：宽字符流操作的函数指针集合 */
};

st结构体：struct stat64是一个结构体，用于存储文件的状态信息。在_IO_file_doallocate函数中，通过调用_IO_SYSSTAT宏来获取文件的状态信息，并将其存储在st结构体中。然后根据文件的类型和块大小来确定缓冲区的大小，并使用malloc函数分配相应大小的内存。最后，使用_IO_setb函数将分配的内存设置为文件的缓冲区

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct stat64 {
    __dev_t         st_dev;         /* 文件所在的设备的ID */
    __ino64_t       st_ino;         /* 文件的inode号 */
    __mode_t        st_mode;        /* 文件的类型和访问权限 */
    __nlink_t       st_nlink;       /* 文件的硬链接数 */
    __uid_t         st_uid;         /* 文件的所有者的用户ID */
    __gid_t         st_gid;         /* 文件的所有者的组ID */
    __dev_t         st_rdev;        /* 如果文件是特殊文件（如设备文件），则为其设备号 */
    __off64_t       st_size;        /* 文件的大小（以字节为单位） */
    __blksize_t     st_blksize;     /* 文件系统的块大小 */
    __blkcnt64_t    st_blocks;      /* 文件所占用的块数 */
    struct timespec st_atim;        /* 文件的最后访问时间 */
    struct timespec st_mtim;        /* 文件的最后修改时间 */
    struct timespec st_ctim;        /* 文件的最后状态更改时间 */
    __ino64_t       st_ino;         /* 文件的inode号（备用） */
};

简单总结一下吧，首先最外层是我们的 __IO_file_plus结构体，在 __IO_file_plus结构体之内，包括两个部分，一个是 __IO_file，另一个是 __IO_jump_t，__IO_file结构体里面有我们要找的chain字段，连接着stdin，stdout和stderr三个结构体，而 __IO_jump_t里面存放一些函数指针，指向实现各种文件操作的函数。

1774932641980-15f19348-87de-4a40-a56a-2e005ec3d1d5.png

常见的标准 IO 库函数：

fread

fread 是标准 IO 库函数，作用是从文件中读取数据，函数原型如下：

1
size_t fread ( void *buffer, size_t size, size_t count, FILE *stream) ;
  • buffer：存放数据读取的缓冲区
  • size：制定每个记录的长度
  • count：制定记录的个数
  • stream：目标文件流
  • 返回值：返回读取到数据缓冲区中记录的个数。

fread 的代码位于 /libio/iofread.c 中，函数名为_IO_fread，但真正的功能实现在子函数 _IO_sgetn 中：

1
2
3
4
5
6
7
8
9
10
11
_IO_size_t
_IO_fread (buf, size, count, fp)
    void *buf;
_IO_size_t size;
_IO_size_t count;
_IO_FILE *fp;
{
    ...
        bytes_read = _IO_sgetn (fp, (char *) buf, bytes_requested);
    ...
    }

在_ IO_sgetn 函数中会调用 _IO_XSGETN，而 _ IO_XSGETN 是_IO_FILE_plus.vtable 中的函数指针，在调用这个函数时会首先取出 vtable 中的指针然后再进行调用：

1
2
3
4
5
6
7
8
9
_IO_size_t
_IO_sgetn (fp, data, n)
    _IO_FILE *fp;
void *data;
_IO_size_t n;
{
    return _IO_XSGETN (fp, data, n);
}

在默认情况下函数指针是指向_IO_file_xsgetn 函数的：

1
2
3
4
5
6
7
8
if (fp->_IO_buf_base
      && want < (size_t) (fp->_IO_buf_end - fp->_IO_buf_base))
{
    if (__underflow (fp) == EOF)
        break;

    continue;
}
fwrite

fwrite 同样是标准 IO 库函数，作用是项文件流写入数据，函数原型如下：

1
size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream);
  • buffer: 是一个指针，对 fwrite 来说，是要写入数据的地址
  • size：要写入的单字节数
  • count：要进行吸入 size 字节的数据项个数
  • stream：目标文件指针
  • 返回值：实际写入的数据项个数 count
fopen

fopen 在标准 IO 库中用于打开文件，函数原型如下：

1
FILE *fopen(char *filename, *type);
  • filename: 目标文件的路径
  • type: 打开方式的类型
  • 返回值：返回一个文件指针

在 fopen 内部会创建 FILE 结构并进行一些初始化操作，下面来看一看这个过程：

1. 使用 malloc 分配 FILE 结构 2. 设置 FILE 结构的 vtable 3. 初始化分配的 FILE 结构 4. 将初始化的 FILE 结构链入 FILE 结构链表中 5. 调用系统调用打开文件

fclose

fclose 在标准 IO 库中用于关闭已经打开的文件，其函数原型如下：

1
int fclose(FILE *stream)

关闭一个文件流，使用 fclose 就可以把缓冲区最后剩余的数据输出到磁盘文件中，并释放文件指针和有关的缓冲区。

fclose 会首先调用 _IO_unlink_it 将指定的 FILE 从 _chain 链表中脱链：

1
2
if (fp->_IO_file_flags & _IO_IS_FILEBUF)
    _IO_un_link ((struct _IO_FILE_plus *) fp);

之后会调用 _IO_file_close_it 函数，该函数会调用系统接口 close 关闭文件：

1
2
if (fp->_IO_file_flags & _IO_IS_FILEBUF)
    status = _IO_file_close_it (fp);

最后调用 vtable 中的 _IO_FINISH，其对应的是 _IO_file_finish 函数，其中会调用 free 函数释放之前分配的 FILE 结构：

1
_IO_FINISH (fp);
printf/puts

printf 和 puts 是常用的输出函数，在 printf 的参数是以’\n’结束的纯字符串时，printf 会被优化为 puts 函数并去除换行符。

puts 在源码中实现的函数是_ IO_puts，这个函数的操作与 fwrite 的流程大致相同，函数内部同样会调用 vtable 中的_ IO_sputn，结果会执行_IO_new_file_xsputn，最后会调用到系统接口 write 函数。

更新: 2026-04-01 20:00:55
原文: https://www.yuque.com/idcm/wnemg9/gky3p0het3vp91pq