glibc-IO源码分析

字数统计: 8.2k字   |   阅读时长≈ 39分

上次对 malloc 进行了源码分析，然后加深了我对 堆利用的理解，让我觉得读源码确实有很大的好处。所以决定在对 IO 这一块的源码进行分析一下，由于 IO 相关的源码太多了，我只对其中的典型进行分析，然后相关的类似函数就不进行过多分析。虽然才开始习惯要去读源码分析漏洞，但是向前走吧，加油吧。

基本结构

stat

stat 结构体是用来保存文件或者文件夹信息的结构体

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
struct stat
{
    //文件所在的设备的ID
    __dev_t st_dev;		/* Device.  */
    #ifndef __x86_64__
    unsigned short int __pad1;
    #endif
    //inode节点号
    #if defined __x86_64__ || !defined __USE_FILE_OFFSET64
    __ino_t st_ino;		/* File serial number.	*/
    #else
    __ino_t __st_ino;			/* 32bit file serial number.	*/
    #endif
    #ifndef __x86_64__
    __mode_t st_mode;			/* File mode.  */
    //文件链接数
    __nlink_t st_nlink;			/* Link count.  */
    #else
    __nlink_t st_nlink;		/* Link count.  */
    __mode_t st_mode;		/* File mode.  */
    #endif
    __uid_t st_uid;		/* User ID of the file's owner.	*/
    __gid_t st_gid;		/* Group ID of the file's group.*/
    #ifdef __x86_64__
    int __pad0;
    #endif
    //设备号，针对设备文件
    __dev_t st_rdev;		/* Device number, if device.  */
    #ifndef __x86_64__
    unsigned short int __pad2;
    #endif
    #if defined __x86_64__ || !defined __USE_FILE_OFFSET64
    //文件大小，以字节为单位
    __off_t st_size;			/* Size of file, in bytes.  */
    #else
    __off64_t st_size;			/* Size of file, in bytes.  */
    #endif
    //系统块的大小
    __blksize_t st_blksize;	/* Optimal block size for I/O.  */
    //文件所占用的系统块的个数
    #if defined __x86_64__  || !defined __USE_FILE_OFFSET64
    __blkcnt_t st_blocks;		/* Number 512-byte blocks allocated. */
    #else
    __blkcnt64_t st_blocks;		/* Number 512-byte blocks allocated. */
    #endif
    #ifdef __USE_XOPEN2K8
    /* Nanosecond resolution timestamps are stored in a format
       equivalent to 'struct timespec'.  This is the type used
       whenever possible but the Unix namespace rules do not allow the
       identifier 'timespec' to appear in the <sys/stat.h> header.
       Therefore we have to handle the use of this header in strictly
       standard-compliant sources special.  */
    //最后一次存取时间
    struct timespec st_atim;		/* Time of last access.  */
    //最后一次修改时间
    struct timespec st_mtim;		/* Time of last modification.  */
    struct timespec st_ctim;		/* Time of last status change.  */
    # define st_atime st_atim.tv_sec	/* Backward compatibility.  */
    # define st_mtime st_mtim.tv_sec
    # define st_ctime st_ctim.tv_sec
    #else
    __time_t st_atime;			/* Time of last access.  */
    __syscall_ulong_t st_atimensec;	/* Nscecs of last access.  */
    __time_t st_mtime;			/* Time of last modification.  */
    __syscall_ulong_t st_mtimensec;	/* Nsecs of last modification.  */
    __time_t st_ctime;			/* Time of last status change.  */
    __syscall_ulong_t st_ctimensec;	/* Nsecs of last status change.  */
    #endif
    #ifdef __x86_64__
    __syscall_slong_t __glibc_reserved[3];
    #else
    # ifndef __USE_FILE_OFFSET64
    unsigned long int __glibc_reserved4;
    unsigned long int __glibc_reserved5;
    # else
    __ino64_t st_ino;			/* File serial number.	*/
    # endif
    #endif
};

_IO_FILE_plus

1
2
3
4
5
6
7
struct _IO_FILE_plus
{
  //文件结构体
  _IO_FILE file;
  //虚表指针
  const struct _IO_jump_t *vtable;
};

每个文件结构其实是由上述 结构体描述，其中第一个变量是真实的 _IO_FILE 结构体，第二个变量 vtable 指向了 _IO_jump_t 的虚表，该虚表记录了FILE 能够执行的函数指针，在 libc2.23 32版本中的 vtable 的偏移 0x94 ，64位下的偏移为 0xd8。

每个 _IO_FILE_plus 会组成一个 FILE 链表，链表的头部 是 _IO_list_all 全局变量，通过这个全局变量可以遍历所有的 FILE 结构体，在每个程序启动的时候， 会自动创建 stdin, stdout, stderr 三个文件流，也就是 _IO_list_all 指向由 这三个 文件流构成的链表。

_IO_FILE

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
43
44
45
46
47
48
49
50
struct _IO_FILE {
  int _flags;		/* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags

  /* The following pointers correspond to the C++ streambuf protocol. */
  /* Note:  Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
  //当前文件读指针
  char* _IO_read_ptr;	/* Current read pointer */
  //文件读取结束地址
  char* _IO_read_end;	/* End of get area. */
  //文件读取开始地址
  char* _IO_read_base;	/* Start of putback+get area. */
  //文件输出开始地址
  char* _IO_write_base;	/* Start of put area. */
  //文件输出指针
  char* _IO_write_ptr;	/* Current put pointer. */
  //文件输出结束地址
  char* _IO_write_end;	/* End of put area. */
  //缓冲区开始地址
  char* _IO_buf_base;	/* Start of reserve area. */
  //缓冲区结束地址
  char* _IO_buf_end;	/* End of reserve area. */
  /* The following fields are used to support backing up and undo. */
  char *_IO_save_base; /* Pointer to start of non-current get area. */
  char *_IO_backup_base;  /* Pointer to first valid character of backup area */
  char *_IO_save_end; /* Pointer to end of non-current get area. */

  struct _IO_marker *_markers;
  //文件链指针，指向下一个_IO_FILE结构
  struct _IO_FILE *_chain;

  int _fileno;	//文件编号
#if 0
  int _blksize;
#else
  int _flags2;
#endif
  _IO_off_t _old_offset; /* This used to be _offset but it's too small.  */

#define __HAVE_COLUMN /* temporary */
  /* 1+column number of pbase(); 0 is unknown. */
  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];

  /*  char* _save_gptr;  char* _save_egptr; */

  _IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};

所有的 FILE 结构体都是如上图所示，结构体指明了 IO 读取、输出的 开始、结束地址和指针，同时指定了输入输出缓冲区的 开始结束地址。其中有一个 chian 指针指明了 FILE链表的下一个 FILE 结构体。

_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
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);
}

_IO_jump_t 保存了一些函数指针，在一系列标准 IO 函数中会调用这些函数指针。

重要函数

fopen

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

Tips:

如果想要对自己写得源代码编译生成的二进制文件，在调试时加入符号信息，可以使用如下命令：

1
2
gcc test.c -g
patchelf --set-rpath ~/Desktop/glibc/x64/glibc2.23/lib/ fopentest

fopen函数首先会调用 _IO_new_fopen 函数，内部会调用 __fopen_internal 函数

image-20201001150905494

1
2
3
4
5
_IO_FILE *
_IO_new_fopen (const char *filename, const char *mode)
{
  return __fopen_internal (filename, mode, 1);
}

在 __fopen_internal 函数中，总共主要执行 4步：

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
_IO_FILE *
__fopen_internal (const char *filename, const char *mode, int is32)
{
  //初始化创建FILE结构空间
  struct locked_FILE
  {
    struct _IO_FILE_plus fp;
#ifdef _IO_MTSAFE_IO
    _IO_lock_t lock;
#endif
    //针对宽字节
    struct _IO_wide_data wd;
  } 
  //为FILE在堆上分配空间
  *new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));

  if (new_f == NULL)
    return NULL;
#ifdef _IO_MTSAFE_IO
  new_f->fp.file._lock = &new_f->lock;
#endif
    //初始化 FILE结构内容
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
  _IO_no_init (&new_f->fp.file, 0, 0, &new_f->wd, &_IO_wfile_jumps);
#else
  _IO_no_init (&new_f->fp.file, 1, 0, NULL, NULL);
#endif
  //初始vtable
  _IO_JUMPS (&new_f->fp) = &_IO_file_jumps;
  //初始化FILE结构
  _IO_file_init (&new_f->fp);
#if  !_IO_UNIFIED_JUMPTABLES
  new_f->fp.vtable = NULL;
#endif
  if (_IO_file_fopen ((_IO_FILE *) new_f, filename, mode, is32) != NULL)
    return __fopen_maybe_mmap (&new_f->fp.file);
	
  _IO_un_link (&new_f->fp);
  free (new_f);
  return NULL;
}

malloc 分配 locked_FILE 结构体

首先需要 FILE 结构体分配内存，调用 malloc 函数分配 locked_FILE 结构，其中包含了 _IO_FILE_plus 结构。此外还有 _IO_wide_data 表示宽字节处理，结构内容和 _IO_FIE类似，分配的结果如下：

image-20201001151443790

调用 _IO_no_init 对结构体进行全 null 初始化

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
void
_IO_old_init (_IO_FILE *fp, int flags)
{
  fp->_flags = _IO_MAGIC|flags;
  fp->_flags2 = 0;
  fp->_IO_buf_base = NULL;
  fp->_IO_buf_end = NULL;
  fp->_IO_read_base = NULL;
  fp->_IO_read_ptr = NULL;
  fp->_IO_read_end = NULL;
  fp->_IO_write_base = NULL;
  fp->_IO_write_ptr = NULL;
  fp->_IO_write_end = NULL;
  fp->_chain = NULL; /* Not necessary. */

  fp->_IO_save_base = NULL;
  fp->_IO_backup_base = NULL;
  fp->_IO_save_end = NULL;
  fp->_markers = NULL;
  fp->_cur_column = 0;
#if _IO_JUMPS_OFFSET
  fp->_vtable_offset = 0;
#endif
#ifdef _IO_MTSAFE_IO
  if (fp->_lock != NULL)
    _IO_lock_init (*fp->_lock);
#endif
}

void
_IO_no_init (_IO_FILE *fp, int flags, int orientation,
	     struct _IO_wide_data *wd, const struct _IO_jump_t *jmp)
{
  _IO_old_init (fp, flags);
  fp->_mode = orientation;
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
  if (orientation >= 0)
    {
      fp->_wide_data = wd;
      fp->_wide_data->_IO_buf_base = NULL;
      fp->_wide_data->_IO_buf_end = NULL;
      fp->_wide_data->_IO_read_base = NULL;
      fp->_wide_data->_IO_read_ptr = NULL;
      fp->_wide_data->_IO_read_end = NULL;
      fp->_wide_data->_IO_write_base = NULL;
      fp->_wide_data->_IO_write_ptr = NULL;
      fp->_wide_data->_IO_write_end = NULL;
      fp->_wide_data->_IO_save_base = NULL;
      fp->_wide_data->_IO_backup_base = NULL;
      fp->_wide_data->_IO_save_end = NULL;

      fp->_wide_data->_wide_vtable = jmp;
    }
  else
    /* Cause predictable crash when a wide function is called on a byte
       stream.  */
    fp->_wide_data = (struct _IO_wide_data *) -1L;
#endif
  fp->_freeres_list = NULL;
}

首先调用了_IO_old_init函数，即将结构体中的成员变量设置为默认值。并且将_wide_data结构体中的成员变量也设置为默认值。

调用 _IO_file_init 函数对结构体进行初始化

随后就要调用 _IO_file_init 函数对 FILE结构进行更深入的初始化。其实 本质上是调用了 _IO_new_file_init 函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
void
_IO_new_file_init (struct _IO_FILE_plus *fp)
{
  /* POSIX.1 allows another file handle to be used to change the position
     of our file descriptor.  Hence we actually don't know the actual
     position before we do the first fseek (and until a following fflush). */
  fp->file._offset = _IO_pos_BAD;
  fp->file._IO_file_flags |= CLOSED_FILEBUF_FLAGS;

  _IO_link_in (fp);
  fp->file._fileno = -1;
}
libc_hidden_ver (_IO_new_file_init, _IO_file_init)

在 _IO_link_in 函数中，

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
void
_IO_link_in (struct _IO_FILE_plus *fp)
{
  if ((fp->file._flags & _IO_LINKED) == 0)
    {
      fp->file._flags |= _IO_LINKED;
#ifdef _IO_MTSAFE_IO
      _IO_cleanup_region_start_noarg (flush_cleanup);
      _IO_lock_lock (list_all_lock);
      run_fp = (_IO_FILE *) fp;
      _IO_flockfile ((_IO_FILE *) fp);
#endif
      //将FILE加入 io链表
      fp->file._chain = (_IO_FILE *) _IO_list_all;
      _IO_list_all = fp;
      ++_IO_list_all_stamp;
#ifdef _IO_MTSAFE_IO
      _IO_funlockfile ((_IO_FILE *) fp);
      run_fp = NULL;
      _IO_lock_unlock (list_all_lock);
      _IO_cleanup_region_end (0);
#endif
    }
}
libc_hidden_def (_IO_link_in)

首先是判断该结构体是否已经加入到链表中。接着将该结构体的_chain指针指向_IO_list_all指针当前指向的结构体，也就是下一个结构体，更新IO_list_all

image-20201001153034918

可以看到当前创建的结构体已经加入 _IO_list_all 列表，并且位于 _IO_list_all 链表头部，其下一个 结构体是 _IO_2_1_stderr_ 。整个FILE链表现在如下：

1
IO_list_all->new_f->_IO_2_1_stderr->_IO_2_1_stdout_->_IO_2_1_stdin_

调用 _IO_file_fopen 执行系统调用打开文件

本质上调用 _IO_new_file_fopen 函数，会检查文件是否打开，根据传入的mode设置 FILE结构的mode，最后调用 open 函数实现打开文件，更新 FILE 结构体。

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
_IO_FILE *
_IO_new_file_fopen (_IO_FILE *fp, const char *filename, const char *mode,
		    int is32not64)
{
  int oflags = 0, omode;
  int read_write;
  int oprot = 0666;
  int i;
  _IO_FILE *result;
#ifdef _LIBC
  const char *cs;
  const char *last_recognized;
#endif
  //判断文件是否打开
  if (_IO_file_is_open (fp))
    return 0;
  //根据不同mode设置FILE不同参数
  switch (*mode)
    {
    case 'r':
      omode = O_RDONLY;
      read_write = _IO_NO_WRITES;
      break;
    case 'w':
      omode = O_WRONLY;
      oflags = O_CREAT|O_TRUNC;
      read_write = _IO_NO_READS;
      break;
    case 'a':
      omode = O_WRONLY;
      oflags = O_CREAT|O_APPEND;
      read_write = _IO_NO_READS|_IO_IS_APPENDING;
      break;
    default:
      __set_errno (EINVAL);
      return NULL;
    }
#ifdef _LIBC
  last_recognized = mode;
#endif
  for (i = 1; i < 7; ++i)
    {
      switch (*++mode)
	{
	case '\0':
	  break;
	case '+':
	  omode = O_RDWR;
	  read_write &= _IO_IS_APPENDING;
#ifdef _LIBC
	  last_recognized = mode;
#endif
	  continue;
	case 'x':
	  oflags |= O_EXCL;
#ifdef _LIBC
	  last_recognized = mode;
#endif
	  continue;
	case 'b':
#ifdef _LIBC
	  last_recognized = mode;
#endif
	  continue;
	case 'm':
	  fp->_flags2 |= _IO_FLAGS2_MMAP;
	  continue;
	case 'c':
	  fp->_flags2 |= _IO_FLAGS2_NOTCANCEL;
	  continue;
	case 'e':
#ifdef O_CLOEXEC
	  oflags |= O_CLOEXEC;
#endif
	  fp->_flags2 |= _IO_FLAGS2_CLOEXEC;
	  continue;
	default:
	  /* Ignore.  */
	  continue;
	}
      break;
    }

  result = _IO_file_open (fp, filename, omode|oflags, oprot, read_write,
			  is32not64);

  if (result != NULL)
    {
#ifndef __ASSUME_O_CLOEXEC
      if ((fp->_flags2 & _IO_FLAGS2_CLOEXEC) != 0 && __have_o_cloexec <= 0)
	{
	  int fd = _IO_fileno (fp);
	  if (__have_o_cloexec == 0)
	    {
	      int flags = __fcntl (fd, F_GETFD);
	      __have_o_cloexec = (flags & FD_CLOEXEC) == 0 ? -1 : 1;
	    }
	  if (__have_o_cloexec < 0)
	    __fcntl (fd, F_SETFD, FD_CLOEXEC);
	}
#endif
...

总结：

  • 使用 malloc 分配 FILE 结构
  • 设置 FILE 结构的 vtable
  • 初始化分配的 FILE 结构
  • 将初始化的 FILE 结构链入 FILE 结构链表中
  • 调用系统调用打开文件

fread

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

fread函数主要调用 _IO_fread 函数，里面主要先计算了 用户读取的size大小，检查 FILE 结构体是否存在，然后获得 FILE锁，最后调用了 _IO_sgetn 函数去读取文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
_IO_size_t
_IO_fread (void *buf, _IO_size_t size, _IO_size_t count, _IO_FILE *fp)
{
  //获取用户读取的大小
  _IO_size_t bytes_requested = size * count;
  _IO_size_t bytes_read;
  CHECK_FILE (fp, 0);
  if (bytes_requested == 0)
    return 0;
  //获得FILE结构锁
  _IO_acquire_lock (fp);
  //读取文件内容
  bytes_read = _IO_sgetn (fp, (char *) buf, bytes_requested);
  _IO_release_lock (fp);
  return bytes_requested == bytes_read ? count : bytes_read / size;
}
libc_hidden_def (_IO_fread)

_IO_sgetn 函数主要调用 _IO_XSGETN 函数，_IO_XSGETN调用的是虚函数表中的__xsgetn，默认调用的是IO_file_xsgetn函数

1
2
3
4
5
6
7
_IO_size_t
_IO_sgetn (_IO_FILE *fp, void *data, _IO_size_t n)
{
  /* FIXME handle putback buffer here! */
  return _IO_XSGETN (fp, data, n);
}
libc_hidden_def (_IO_sgetn)

_IO_file_xsgetn函数 首先判断FILE 结构体输入输出缓冲区是否存在，如果不存在则调用 _IO_doallocbuf 去分配缓冲区。然后才会去读取数据到缓冲区中。

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
_IO_size_t
_IO_file_xsgetn (_IO_FILE *fp, void *data, _IO_size_t n)
{
  _IO_size_t want, have;
  _IO_ssize_t count;
  char *s = data;

  want = n;
  //判断输入输出缓冲区是否为空
  if (fp->_IO_buf_base == NULL)
    {
      /* Maybe we already have a push back pointer.  */
      //
      if (fp->_IO_save_base != NULL)
	{
	  free (fp->_IO_save_base);
	  fp->_flags &= ~_IO_IN_BACKUP;
	}
      //分配缓冲区
      _IO_doallocbuf (fp);
    }
//读取数据
  while (want > 0)
    {
      //得到输入输出缓冲区还剩余的数据大小
      have = fp->_IO_read_end - fp->_IO_read_ptr;
    //剩余数据大于用户请求数据，则直接全部读入到buf中
      if (want <= have)
	{
      //直接将缓冲区数据拷贝用户请求大小到buf中
	  memcpy (s, fp->_IO_read_ptr, want);
      //更新 _IO_read_ptr 指针
	  fp->_IO_read_ptr += want;
	  want = 0;
	}
      //剩余数据小于用户请求的数据大小
      else
	{
	  if (have > 0)
	    {
#ifdef _LIBC
          //先将剩余数据拷贝到buf
	      s = __mempcpy (s, fp->_IO_read_ptr, have);
#else
	      memcpy (s, fp->_IO_read_ptr, have);
          //更新已读取的数据指针
	      s += have;
#endif
          //更新用户请求的大小
	      want -= have;
          //更新_IO_read_ptr
	      fp->_IO_read_ptr += have;
	    }

	  /* Check for backup and repeat */
	  if (_IO_in_backup (fp))
	    {
	      _IO_switch_to_main_get_area (fp);
	      continue;
	    }

	  /* If we now want less than a buffer, underflow and repeat
	     the copy.  Otherwise, _IO_SYSREAD directly to
	     the user buffer. */
      //输入缓冲区存在，且输入缓冲区大小大于用户请求的数据
	  if (fp->_IO_buf_base
	      && want < (size_t) (fp->_IO_buf_end - fp->_IO_buf_base))
	    {
          //读取数据到输入缓冲区
	      if (__underflow (fp) == EOF)
		break;
		  //进入下一下循环
	      continue;
	    }

	  /* These must be set before the sysread as we might longjmp out
	     waiting for input. */
	  _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
	  _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);

	  /* Try to maintain alignment: read a whole number of blocks.  */
	  count = want;
	  if (fp->_IO_buf_base)
	    {
	      _IO_size_t block_size = fp->_IO_buf_end - fp->_IO_buf_base;
	      if (block_size >= 128)
              //count表示的最大block块数的数据大小
		count -= want % block_size;
	    }
		//调用系统读取函数
	  count = _IO_SYSREAD (fp, s, count);
	  if (count <= 0)
	    {
	      if (count == 0)
		fp->_flags |= _IO_EOF_SEEN;
	      else
		fp->_flags |= _IO_ERR_SEEN;

	      break;
	    }

	  s += count;
	  want -= count;
	  if (fp->_offset != _IO_pos_BAD)
	    _IO_pos_adjust (fp->_offset, count);
	}
    }

  return n - want;
}
libc_hidden_def (_IO_file_xsgetn)

创建输入输出缓冲区

在 _IO_doallocbuf 函数中，会判断 FILE 结构体，如果flag不是IO_UNBUFFERED且model>0，则调用_IO_DOALLOCATE，该函数调用的是虚函数表中的__doallocate函数，默认调用的_IO_file_doallocate函数。而 _IO_setb 是设置 FILE 结构体输入输出指针的地址。

1
2
3
4
5
6
7
8
9
10
11
12
13
void
_IO_doallocbuf (_IO_FILE *fp)
{
  if (fp->_IO_buf_base)
    return;
  if (!(fp->_flags & _IO_UNBUFFERED) || fp->_mode > 0)
    //分配堆区
    if (_IO_DOALLOCATE (fp) != EOF)
      return;
   //设置FILE结构体输入输出指针地址
  _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
}
libc_hidden_def (_IO_doallocbuf)

在 _IO_file_doallocate 函数中首先会调用 _IO_SYSSTAT 获取文件信息，并保存在 stat 结构体，_IO_SYSSTAT调用的是虚函数表中的__stat函数，获取文件信息，修改相应的需要申请的size。然后会调用 _IO_setb 去设置IO_buf_base和IO_buf_end，也就是设置结构体中输入输出缓冲区的位置。执行完毕之后函数返回，接着alloc相关函数返回，这样输入输出缓冲区就初始化完毕了。

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
43
44
int
_IO_file_doallocate (_IO_FILE *fp)
{
  _IO_size_t size;
  char *p;
  struct stat64 st;

#ifndef _LIBC
  /* If _IO_cleanup_registration_needed is non-zero, we should call the
     function it points to.  This is to make sure _IO_cleanup gets called
     on exit.  We call it from _IO_file_doallocate, since that is likely
     to get called by any program that does buffered I/O. */
  if (__glibc_unlikely (_IO_cleanup_registration_needed != NULL))
    (*_IO_cleanup_registration_needed) ();
#endif

  size = _IO_BUFSIZ;
  //获取文件信息
  if (fp->_fileno >= 0 && __builtin_expect (_IO_SYSSTAT (fp, &st), 0) >= 0)
    {
      if (S_ISCHR (st.st_mode))
	{
	  /* Possibly a tty.  */
	  if (
#ifdef DEV_TTY_P
	      DEV_TTY_P (&st) ||
#endif
	      local_isatty (fp->_fileno))
	    fp->_flags |= _IO_LINE_BUF;
	}
#if _IO_HAVE_ST_BLKSIZE
      if (st.st_blksize > 0)
	size = st.st_blksize;
#endif
    }
  //分配缓冲区
  p = malloc (size);
  if (__glibc_unlikely (p == NULL))
    return EOF;
  //设置FILE结构体输入输出地址
  _IO_setb (fp, p, p + size, 1);
  return 1;
}
libc_hidden_def (_IO_file_doallocate)

获取的 st 文件信息如下：

image-20201001161456077

执行完 _IO_setb 函数后，可以看到已经分配了 输入输出缓冲区，并且更新了 FILE 结构体中 _IO_buf_base 和 _IO_buf_end

image-20201001161718875

此时就完成了 输入输出缓冲区的创建，随后就进入数读取的过程。

读取文件数据

读取文件分为两步：

  1. 输入缓冲区存在，且剩余输入缓冲区数据大小大于用户请求的数据大小，直接拷贝数据到用户指定的buf。
  2. 如果剩余缓冲区数据大小小于用户请求的数据大小，则先将buf填满，再调用系统调用 _IO_SYSREAD 读取文件数据。

第一步的过程如下：

1
2
3
4
5
6
7
8
9
10
11
     //得到输入缓冲区还剩余的数据大小
     have = fp->_IO_read_end - fp->_IO_read_ptr;
   //剩余数据大于用户请求数据，则直接全部读入
     if (want <= have)
{
     //直接将缓冲区数据拷贝用户请求大小到buf
  memcpy (s, fp->_IO_read_ptr, want);
     //更新 _IO_read_ptr 指针
  fp->_IO_read_ptr += want;
  want = 0;
}

第二步系统调用：

先是将剩余缓冲区数据全部拷贝的buf 中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
	  if (have > 0)
	    {
#ifdef _LIBC
          //先将剩余数据拷贝到buf
	      s = __mempcpy (s, fp->_IO_read_ptr, have);
#else
	      memcpy (s, fp->_IO_read_ptr, have);
          //更新已读取的数据指针
	      s += have;
#endif
          //更新用户请求的大小
	      want -= have;
          //更新_IO_read_ptr
	      fp->_IO_read_ptr += have;
	    }

若当前的输入输出缓冲区中不存在可读数据就需要系统调用从文件中读取数据了。

  • 用户需要读取的数据大于blksize即一个block的大小，则调用IO_SYSREAD将最大的block数的数据直接读取到s中。
  • 否则调用IO_UNDERFLOW从文件中读取最大一个block的数据。
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
   //输入缓冲区存在且用户需要读取的数据小于输入缓冲区的大小
      if (fp->_IO_buf_base
          && want < (size_t) (fp->_IO_buf_end - fp->_IO_buf_base))
      {
          //读取数据到输入缓冲区
          if (__underflow (fp) == EOF)
              break;
          //进入下一个循环
          continue;
      }
      
      /* These must be set before the sysread as we might longjmp out
waiting for input. */
      _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
      _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);

      /* Try to maintain alignment: read a whole number of blocks.  */
      count = want;
      if (fp->_IO_buf_base)
      {
          _IO_size_t block_size = fp->_IO_buf_end - fp->_IO_buf_base;
          if (block_size >= 128)
              //count表示的最大block块数的数据大小
              count -= want % block_size;
      }

      count = _IO_SYSREAD (fp, s, count);
      if (count <= 0)
      {
          if (count == 0)
              fp->_flags |= _IO_EOF_SEEN;
          else
              fp->_flags |= _IO_ERR_SEEN;

          break;
      }

      s += count;
      want -= count;
      if (fp->_offset != _IO_pos_BAD)
          _IO_pos_adjust (fp->_offset, count);
_underflow

按照执行流程，此时是第一次读取数据，也就是_IO_read_ptr与_IO_read_end等指针均为空值，输入缓冲区中不存在待读数据，且我们读取的数据的大小小于一个block size，因此会进入到__underflow函数中。

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
int
__underflow (_IO_FILE *fp)
{
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
  if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1)
    return EOF;
#endif

  if (fp->_mode == 0)
    _IO_fwide (fp, -1);
  if (_IO_in_put_mode (fp))
    if (_IO_switch_to_get_mode (fp) == EOF)
      return EOF;
  if (fp->_IO_read_ptr < fp->_IO_read_end)
    return *(unsigned char *) fp->_IO_read_ptr;
  if (_IO_in_backup (fp))
    {
      _IO_switch_to_main_get_area (fp);
      if (fp->_IO_read_ptr < fp->_IO_read_end)
	return *(unsigned char *) fp->_IO_read_ptr;
    }
  if (_IO_have_markers (fp))
    {
      if (save_for_backup (fp, fp->_IO_read_end))
	return EOF;
    }
  else if (_IO_have_backup (fp))
    _IO_free_backup_area (fp);
  return _IO_UNDERFLOW (fp);
}
libc_hidden_def (__underflow)

首先会对FILE结构体的model进行检查，保证其处于get模式。如果fp->_IO_read_ptr < fp->_IO_read_end 成立则表示还存在未被读取的数据，直接返回，否则就调用_IO_UNDERFLOW读取文件中的数据。该函数调用的是虚函数表中的__underflow函数，默认调用的是IO_file_underflow函数.

_IO_UNDERFLOW

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
int
_IO_new_file_underflow (_IO_FILE *fp)
{
  _IO_ssize_t count;
#if 0
  /* SysV does not make this test; take it out for compatibility */
  if (fp->_flags & _IO_EOF_SEEN)
    return (EOF);
#endif
  //检查文件是否允许读
  if (fp->_flags & _IO_NO_READS)
    {
      fp->_flags |= _IO_ERR_SEEN;
      __set_errno (EBADF);
      return EOF;
    }
    //存在未读取的数据，直接返回
  if (fp->_IO_read_ptr < fp->_IO_read_end)
    return *(unsigned char *) fp->_IO_read_ptr;
	//输入输出缓冲区未被初始化，则初始化缓冲区
  if (fp->_IO_buf_base == NULL)
    {
      /* Maybe we already have a push back pointer.  */
      if (fp->_IO_save_base != NULL)
	{
	  free (fp->_IO_save_base);
	  fp->_flags &= ~_IO_IN_BACKUP;
	}
      _IO_doallocbuf (fp);
    }

  /* Flush all line buffered files before reading. */
  /* FIXME This can/should be moved to genops ?? */
    //输出 stdout 中未被输出的数据
  if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
    {
#if 0
      _IO_flush_all_linebuffered ();
#else
      /* We used to flush all line-buffered stream.  This really isn't
	 required by any standard.  My recollection is that
	 traditional Unix systems did this for stdout.  stderr better
	 not be line buffered.  So we do just that here
	 explicitly.  --drepper */
      _IO_acquire_lock (_IO_stdout);

      if ((_IO_stdout->_flags & (_IO_LINKED | _IO_NO_WRITES | _IO_LINE_BUF))
	  == (_IO_LINKED | _IO_LINE_BUF))
	_IO_OVERFLOW (_IO_stdout, EOF);

      _IO_release_lock (_IO_stdout);
#endif
    }

  _IO_switch_to_get_mode (fp);

  /* This is very tricky. We have to adjust those
     pointers before we call _IO_SYSREAD () since
     we may longjump () out while waiting for
     input. Those pointers may be screwed up. H.J. */
    //初始化读位置等指针
  fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
  fp->_IO_read_end = fp->_IO_buf_base;
  fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
    = fp->_IO_buf_base;
	//调用系统调用读取文件数据
  count = _IO_SYSREAD (fp, fp->_IO_buf_base,
		       fp->_IO_buf_end - fp->_IO_buf_base);
  if (count <= 0)
    {
      if (count == 0)
	fp->_flags |= _IO_EOF_SEEN;
      else
	fp->_flags |= _IO_ERR_SEEN, count = 0;
  }
    //更新指针，处理错误
  fp->_IO_read_end += count;
  if (count == 0)
    {
      /* If a stream is read to EOF, the calling application may switch active
	 handles.  As a result, our offset cache would no longer be valid, so
	 unset it.  */
      fp->_offset = _IO_pos_BAD;
      return EOF;
    }
  if (fp->_offset != _IO_pos_BAD)
    _IO_pos_adjust (fp->_offset, count);
  return *(unsigned char *) fp->_IO_read_ptr;
}
libc_hidden_ver (_IO_new_file_underflow, _IO_file_underflow)

函数的执行流程如下

  1. 首先是检查文件是否允许读，若不允许则直接返回EOF
  2. 检查输入输出缓冲区是否被初始化，如果未被初始化则初始化输入输出缓冲区（分配block size大小的内存空间）
  3. 输出stdout中未被输出的内容，即调用_IO_OVERFLOW表示的虚函数
  4. 调用_IO_SYSREAD读取文件数据，函数返回读取的文件的字节数
  5. 设置读取的末尾指针。

_IO_SYSREAD

1
2
3
4
5
6
7
8
_IO_ssize_t
_IO_file_read (_IO_FILE *fp, void *buf, _IO_ssize_t size)
{
  return (__builtin_expect (fp->_flags2 & _IO_FLAGS2_NOTCANCEL, 0)
	  ? read_not_cancel (fp->_fileno, buf, size)
	  : read (fp->_fileno, buf, size));
}
libc_hidden_def (_IO_file_read)

函数在进行一定的检查之后直接调用系统调用read读取文件内容到buf缓冲区中。在执行完毕_IO_UNDERFLOW之后，FILE结构体中的读位置指针已经指向了输入输出缓冲区。

最终可以看到 输入输出缓冲中 已经有了数据：

image-20201001170707210

总结：

  1. 若输入输出缓冲区未初始化则初始化输入输出缓冲区
  2. 若用户需要读取的数据的大小小于当前的输入输出缓冲区的可读取数据的大小，则直接memcpy将数据拷贝到返回值中
  3. 否则先将当前输入输出缓冲区的可读数据拷贝到返回值中。若剩余需要读取的数据的大小小于block size则调用__underflow读取最大一个block size的数据保存在缓冲区中，返回第2步。也就是直接memcpy
  4. 若剩余需要读取的数据大于一个block size则调用IO_SYSREAD将最大block数的数据直接读取到s中，返回第2步，也就是下一步通过__underflow读取剩余的数据。

fwrite

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

fwrite 本质上调用的是 _IO_fwrite，_IO_fwrite 函数刚开始是获取用户请求的size大小，然后获取文件锁，最后是调用 _IO_sputn ，而 _IO_sputn 默认调用的是 _IO_new_file_xsputn 函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
_IO_size_t
_IO_fwrite (const void *buf, _IO_size_t size, _IO_size_t count, _IO_FILE *fp)
{
  _IO_size_t request = size * count;
  _IO_size_t written = 0;
  CHECK_FILE (fp, 0);
  if (request == 0)
    return 0;
  _IO_acquire_lock (fp);
  if (_IO_vtable_offset (fp) != 0 || _IO_fwide (fp, -1) == -1)
    written = _IO_sputn (fp, (const char *) buf, request);
  _IO_release_lock (fp);
  /* We have written all of the input in case the return value indicates
     this or EOF is returned.  The latter is a special case where we
     simply did not manage to flush the buffer.  But the data is in the
     buffer and therefore written as far as fwrite is concerned.  */
  if (written == request || written == EOF)
    return count;
  else
    return written / size;
}
libc_hidden_def (_IO_fwrite)

_IO_new_file_xputn

计算输出缓冲区可用空间

通过 缓冲区结束地址 和 输出地址指针，计算缓冲区中可用的空间，保存到 count 变量里。

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
_IO_size_t
_IO_new_file_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
{
  const char *s = (const char *) data;
  _IO_size_t to_do = n;
  int must_flush = 0;
  _IO_size_t count = 0;

  if (n <= 0)
    return 0;
  /* This is an optimized implementation.
     If the amount to be written straddles a block boundary
     (or the filebuf is unbuffered), use sys_write directly. */

  /* First figure out how much space is available in the buffer. */
    //计算可用缓冲区大小
  if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
    {
      count = f->_IO_buf_end - f->_IO_write_ptr;
      if (count >= n)
	{
	  const char *p;
	  for (p = s + n; p > s; )
	    {
	      if (*--p == '\n')
		{
		  count = p - s + 1;
		  must_flush = 1;
		  break;
		}
	    }
	}
    }
  else if (f->_IO_write_end > f->_IO_write_ptr)
    count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */

  /* Then fill the buffer. */
   //缓冲区有剩余空间
  if (count > 0)
    {
      if (count > to_do)
	count = to_do;
#ifdef _LIBC
      //将输出数据拷贝到输出缓冲区
      f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
#else
      memcpy (f->_IO_write_ptr, s, count);
      f->_IO_write_ptr += count;
#endif
      s += count;
      to_do -= count;
    }
   //输出缓冲区大小不足，还剩余输出数据未拷贝到缓冲区
  if (to_do + must_flush > 0)
    {
      _IO_size_t block_size, do_write;
      /* Next flush the (full) buffer. */
      //刷新输出缓冲区，返回值EOF 表示函数调用出错
      if (_IO_OVERFLOW (f, EOF) == EOF)
	/* If nothing else has to be written we must not signal the
	   caller that everything has been written.  */
	return to_do == 0 ? EOF : n - to_do;

      /* Try to maintain alignment: write a whole number of blocks.  */
      block_size = f->_IO_buf_end - f->_IO_buf_base;
      do_write = to_do - (block_size >= 128 ? to_do % block_size : 0);
	
      if (do_write)
	{
	  count = new_do_write (f, s, do_write);
	  to_do -= count;
	  if (count < do_write)
	    return n - to_do;
	}

      /* Now write out the remainder.  Normally, this will fit in the
	 buffer, but it's somewhat messier for line-buffered files,
	 so we let _IO_default_xsputn handle the general case. */
      if (to_do)
	to_do -= _IO_default_xsputn (f, s+do_write, to_do);
    }
  return n - to_do;
}
libc_hidden_ver (_IO_new_file_xsputn, _IO_file_xsputn)

写入数据

输入缓冲区空间存在

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
_IO_size_t
    _IO_new_file_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
{
    //计算可用缓冲区的大小
    /* Then fill the buffer. */
    if (count > 0)
    {
        if (count > to_do)
            count = to_do;
        #ifdef _LIBC
        f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
        #else
        memcpy (f->_IO_write_ptr, s, count);
        f->_IO_write_ptr += count;
        #endif
        s += count;
        to_do -= count;
    }
    //...
}

to_do 表示剩余需要写入的数据的大小，若当前的缓冲区中存在剩余，且满足用户的需求则使用 memcpy将数据拷贝到输出缓冲区中。如果此时的 to_do 仍存在数值的话，表示输出缓冲区的空间不足，存在剩余的数据。

为建立输出缓冲区或空间不足

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
_IO_size_t
    _IO_new_file_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
{ 
    //计算当前的输出缓冲区的可用空间
    //如果存在可用的剩余空间则将数据拷贝到输出缓冲区中
    
    //这里是判断数据是否存在剩余，若数据存在剩余则表示的是输出缓冲区未建立或者已经被用尽
    if (to_do + must_flush > 0)
    {
        _IO_size_t block_size, do_write;
        /* Next flush the (full) buffer. */
        //返回值为EOF的时候表示的是函数调用出错
        if (_IO_OVERFLOW (f, EOF) == EOF)
            /* If nothing else has to be written we must not signal the
	   caller that everything has been written.  */
            return to_do == 0 ? EOF : n - to_do;
        //...
    }
    return n - to_do;
}

如果仍然剩余需要被写入的数据，则表示当前输出缓冲区已经用尽，或者未建立输出缓冲区。此时调用 _IO_OVERFLOW 所表示的虚函数进行输出缓冲区的初始化，或者刷新输出缓冲区。当程序时第一次读数据，由于未建立输出缓冲区，所以首先会调用该函数。

IO_OVERFLOW

该函数调用的是虚函数表中的 __overflow，默认会调用 _IO_new_file_overflow函数，该函数作用是刷新输出缓冲区。

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
int
    _IO_new_file_overflow (_IO_FILE *f, int ch)
{
    //判断是否具有可写权限
    if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
    {
        f->_flags |= _IO_ERR_SEEN;
        __set_errno (EBADF);
        return EOF;
    }
    //对当前处于读模式或者输入输出缓冲区未初始化的情况进行处理
    /* If currently reading or no buffer allocated. */
    if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL)
    {
        //初始化输入输出缓冲区
        /* Allocate a buffer if needed. */
        if (f->_IO_write_base == NULL)
        {
            _IO_doallocbuf (f);
            //设置读位置指针
            _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
        }
        /* Otherwise must be currently reading.
	 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
	 logically slide the buffer forwards one block (by setting the
	 read pointers to all point at the beginning of the block).  This
	 makes room for subsequent output.   g that
	 alone, so it can continue to correspond to the external position). */
        if (__glibc_unlikely (_IO_in_backup (f)))
        {
            size_t nbackup = f->_IO_read_end - f->_IO_read_ptr;
            _IO_free_backup_area (f);
            f->_IO_read_base -= MIN (nbackup,
                                     f->_IO_read_base - f->_IO_buf_base);
            f->_IO_read_ptr = f->_IO_read_base;
        }

        if (f->_IO_read_ptr == f->_IO_buf_end)
            f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
        f->_IO_write_ptr = f->_IO_read_ptr;
        f->_IO_write_base = f->_IO_write_ptr;
        f->_IO_write_end = f->_IO_buf_end;
        f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;

        f->_flags |= _IO_CURRENTLY_PUTTING;
        if (f->_mode <= 0 && f->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
            f->_IO_write_end = f->_IO_write_ptr;
    }
    //传入的是EOF，所以直接调用IO_do_write
    if (ch == EOF)
        return _IO_do_write (f, f->_IO_write_base,
                             f->_IO_write_ptr - f->_IO_write_base);
    if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
        if (_IO_do_flush (f) == EOF)
            return EOF;
    *f->_IO_write_ptr++ = ch;
    if ((f->_flags & _IO_UNBUFFERED)
        || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
        if (_IO_do_write (f, f->_IO_write_base,
                          f->_IO_write_ptr - f->_IO_write_base) == EOF)
            return EOF;
    return (unsigned char) ch;
}
libc_hidden_ver (_IO_new_file_overflow, _IO_file_overflow)

首先判断了当前的 FILE结构体指向的文件是否具有可写权限，然后若当前的输入输出缓冲区未被初始化，则调用 IO_doallocbuf初始化输入输出缓冲区。在初始化缓冲区之后对 FILE结构体中的读指针进行了赋值。

1
2
#define _IO_setg(fp, eb, g, eg)  ((fp)->_IO_read_base = (eb),\
	(fp)->_IO_read_ptr = (g), (fp)->_IO_read_end = (eg))

接着对当前的写指针进行了赋值，主要是将_IO_write_ptr赋值为了_IO_read_ptr。在执行完毕之后调用了_IO_do_write来进行写入操作。

_IO_do_write

函数调用的 _IO_new_do_write函数，若需要写入的字节数为 0则直接返回，否则调用 new_do_write函数，由于初次使用，写指针刚被赋值，此时的 to_do值为0，因此会直接返回 0。

如果此前存在输入输出缓冲区或者处于写模式，且存在未被刷新的输出缓冲区数据，那么就会调用 new_do_write函数，将当前为被写入的数据写入到文件中，即刷新输出缓冲区。

分块数据写入

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
_IO_size_t
    _IO_new_file_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
{ 
    //计算当前的输出缓冲区的可用空间
    //如果存在可用的剩余空间则将数据拷贝到输出缓冲区中

    //这里是判断数据是否存在剩余，若数据存在剩余则表示的是输出缓冲区未建立或者已经被用完
    if (to_do + must_flush > 0)
    {
        //初始化输入输出缓冲区，并进行刷新
        //返回EOF则表示出错。
        if (_IO_OVERFLOW (f, EOF) == EOF)
            //return to_do == 0 ? EOF : n - to_do;
        //判断需要写入的数据是否为大块的数据
        /* Try to maintain alignment: write a whole number of blocks.  */
        block_size = f->_IO_buf_end - f->_IO_buf_base;
        do_write = to_do - (block_size >= 128 ? to_do % block_size : 0);

        if (do_write)
        {
            count = new_do_write (f, s, do_write);
            to_do -= count;
            if (count < do_write)
                return n - to_do;
        }

        /* Now write out the remainder.  Normally, this will fit in the
	 buffer, but it's somewhat messier for line-buffered files,
	 so we let _IO_default_xsputn handle the general case. */
        if (to_do)
            to_do -= _IO_default_xsputn (f, s+do_write, to_do);
    }
    return n - to_do;
}

如果需要写入的数据是大块的数据(block_size>128)且待写入数据 to_do大于一个 block，那么首先将 do_write赋值为整块的数据，调用 new_do_write 函数进行文件数据写入，我们知道 new_do_write 函数返回值是写入的文件的字节数，如果 count<do_write 则表示写入出错，直接返回。

new_do_write

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
static
    _IO_size_t
    new_do_write (_IO_FILE *fp, const char *data, _IO_size_t to_do)
{
    _IO_size_t count;
    if (fp->_flags & _IO_IS_APPENDING)
        /* On a system without a proper O_APPEND implementation,
       you would need to sys_seek(0, SEEK_END) here, but is
       not needed nor desirable for Unix- or Posix-like systems.
       Instead, just indicate that offset (before and after) is
       unpredictable. */
        fp->_offset = _IO_pos_BAD;
    else if (fp->_IO_read_end != fp->_IO_write_base)
    {
        _IO_off64_t new_pos
            = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
        if (new_pos == _IO_pos_BAD)
            return 0;
        fp->_offset = new_pos;
    }
    count = _IO_SYSWRITE (fp, data, to_do);
    if (fp->_cur_column && count)
        fp->_cur_column = _IO_adjust_column (fp->_cur_column - 1, data, count) + 1;
    _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
    fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
    fp->_IO_write_end = (fp->_mode <= 0
                         && (fp->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
                         ? fp->_IO_buf_base : fp->_IO_buf_end);
    return count;
}

_IO_SYSWRITE

首先函数对写指针进行一个判断，防止读写冲突，接着调用 _IO_SYSWRITE 进行写入操作，该函数调用的是虚函数表的 __write函数，默认调用的是 IO_new_file_write 函数，也是最终执行系统调用的地方：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
_IO_ssize_t
    _IO_new_file_write (_IO_FILE *f, const void *data, _IO_ssize_t n)
{
    _IO_ssize_t to_do = n;
    while (to_do > 0)
    {
        _IO_ssize_t count = (__builtin_expect (f->_flags2
                                               & _IO_FLAGS2_NOTCANCEL, 0)
                             ? write_not_cancel (f->_fileno, data, to_do)
                             : write (f->_fileno, data, to_do));
        if (count < 0)
        {
            f->_flags |= _IO_ERR_SEEN;
            break;
        }
        to_do -= count;
        data = (void *) ((char *) data + count);
    }
    n -= to_do;
    if (f->_offset >= 0)
        f->_offset += n;
    return n;
}

最终调用系统调用数据写入到文件中，更新文件的偏移位置。

将整个 block 的数据写入完成之后，就剩下小块的数据，此时调用 _IO_default_xsputn 函数进行写入。

_IO_default_xsputn

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
43
44
_IO_size_t
    _IO_default_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
{
    const char *s = (char *) data;
    _IO_size_t more = n;
    if (more <= 0)
        return 0;
    for (;;)
    {
        /* Space available. */
        //输出缓冲区存在可用空间
        if (f->_IO_write_ptr < f->_IO_write_end)
        {
            _IO_size_t count = f->_IO_write_end - f->_IO_write_ptr;
            if (count > more)
                count = more;
            if (count > 20)
            {
                #ifdef _LIBC
                f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
                #else
                memcpy (f->_IO_write_ptr, s, count);
                f->_IO_write_ptr += count;
                #endif
                s += count;
            }
            else if (count)
            {
                char *p = f->_IO_write_ptr;
                _IO_ssize_t i;
                for (i = count; --i >= 0; )
                    *p++ = *s++;
                f->_IO_write_ptr = p;
            }
            more -= count;
        }
        //此时输出已经完成  或者输出缓冲区不存在空间或空间已经用尽
        if (more == 0 || _IO_OVERFLOW (f, (unsigned char) *s++) == EOF)
            break;
        more--;
    }
    return n - more;
}
libc_hidden_def (_IO_default_xsputn)

先判断了输出缓冲区是否存在剩余空间，如果不存在则调用 _IO_OVERFLOW刷新输出缓冲区。

若缓冲区存在剩余空间：

  • 若写入的数据大于 20字节，则依次赋值
  • 否则通过 memcpy 拷贝数据

完成之后若 more即数据仍然存在剩余则表示输出缓冲区已经用尽则调用 IO_OVERFLOW 刷新输出缓冲区，到此用户的数据已经全部写入到文件中。

总结

  1. 首先计算当前的输出缓冲区存在的剩余空间的大小，若存在空间剩余则将数据拷贝到输出缓冲区中
  2. 若此时仍然存在剩余的数据，则表示的是输出缓冲区未建立或者是空间用尽，则此时调用 IO_OVERFLOW函数进行输出缓冲区的建立或刷新
  3. 输出缓冲区准备完毕后，首先判断写入的数据是否大于整块的数据，若大于则调用 IO_do_write函数进行整块数据写入
  4. 调用 _IO_default_xsputn函数将剩余部分写入文件
赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing