1
void
2
exit (int status)
3
{
4
__run_exit_handlers (status, &__exit_funcs, true, true);
5
}

1
void
2
attribute_hidden
3
__run_exit_handlers (int status, struct exit_function_list **listp,
4
bool run_list_atexit, bool run_dtors)
5
{
6
...
7
while (true)
8
{
9
...
10
}
11
while (cur->idx > 0)
12
{
13
struct exit_function *const f = &cur->fns[--cur->idx];
14
const uint64_t new_exitfn_called = __new_exitfn_called;
15
switch (f->flavor)
16
{
17
.....
18

19
}
20
....
21
__libc_lock_unlock (__exit_funcs_lock);
22
if (run_list_atexit)
23
call_function_static_weak (_IO_cleanup);//This is our target function to trace for File stream flush operations..
24
_exit (status);
25
}

1
int
2
IOcleanup (void)
3
{
4
  int result = IOflush_all ();
5
  IOunbuffer_all ();
6
  return result;
7
}

1
FILE *fp = fopen("data.txt", "w");

1
struct _IO_FILE {
2
   int _flags;                // File status flags (read/write/eof/error)
3
   char *_IO_read_ptr;        // Current read pointer in the buffer
4
   char *_IO_read_end;        // End of readable buffer
5
   char *_IO_read_base;       // Start of readable buffer
6
   char *_IO_write_base;      // Start of write buffer
7
   char *_IO_write_ptr;       // Current write pointer
8
   char *_IO_write_end;       // End of write buffer
9
   char *_IO_buf_base;        // Base of allocated buffer (for read/write)
10
   char *_IO_buf_end;         // End of allocated buffer
11
   char *_IO_save_base;       // Backup of buffer base (used in ungetc)
12
   char *_IO_backup_base;     // Backup buffer base
13
   char *_IO_save_end;        // Backup buffer end
14
   struct _IO_marker *_markers;  // Linked list of markers (used for positioning)
15
   struct _IO_FILE *_chain;      // Next FILE in linked list of open streams
16
   int _fileno;               // File descriptor (OS handle)
17
   int _flags2 : 24;          // Extra flags for internal use
18
   char _short_backupbuf[1];  // Tiny backup buffer for special cases
19
   __off_t _old_offset;       // Previous file offset (for seek operations)
20
   unsigned short _cur_column;// Current column number (for text streams)
21
   signed char _vtable_offset;// Offset of vtable pointer in object (0 for normal FILE)
22
   char _shortbuf[1];         // Tiny buffer for putc/ungetc
23
   _IO_lock_t *_lock;         // Lock for thread-safe access
24
   __off64_t _offset;         // Current file position (64-bit offset)
25

26
   // Wide character support
27
   struct _IO_codecvt *_codecvt;  // Codecvt object for character conversion (wide char support)
28
   struct _IO_wide_data *_wide_data; // Buffer and state for wide-character I/O
29
   struct _IO_FILE *_freeres_list;    // List of freed FILE objects (for cleanup)
30
   void *_freeres_buf;                // Buffer used for freeing FILEs
31
   struct _IO_FILE **_prevchain;      // Previous FILE in the global chain
32
   int _mode;                          // Stream orientation: 0 = undecided, >0 = wide, <0 = byte
33
   char _unused2[20];                  // Padding / reserved for future use
34
};
35

36
//Finally
37
struct _IO_FILE_plus
38
{
39
 FILE file;
40
 const struct _IO_jump_t *vtable;
41
};

1
fopen()
2
 └── _IO_new_fopen()
3
      └── _IO_new_file_fopen()
4
           ├── _IO_file_open()     ← does low-level open() syscall
5
           ├── _IO_file_init()     ← initializes vtable & buffering
6
           └── returns _IO_FILE_plus object  // this is our struct file

1
int
2
_IO_flush_all (void)
3
{
4
  int result = 0;
5
  FILE *fp;
6

7
#ifdef _IO_MTSAFE_IO
8
  _IO_cleanup_region_start_noarg (flush_cleanup);
9
  _IO_lock_lock (list_all_lock); //lock global list all
10
#endif
11

12
  for (fp = (FILE *) _IO_list_all; fp != NULL; fp = fp->_chain) // started loop to scan all opened file pointer via the concurrent process
13
    {
14
      run_fp = fp;
15
      _IO_flockfile (fp); //lock the file to avoid race condition via another thread
16

17
      if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)  //  checking for normal byte or not decided and then checking if we are in mid of writing or not , if we are then need to flush it before end of main thread
18
     || (_IO_vtable_offset (fp) == 0 //checking for standared stream file pointer
19
         && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
20
            > fp->_wide_data->_IO_write_base)) // again checking for any pending _wide_data (_mode>0) buffer
21
     )
22
    && _IO_OVERFLOW (fp, EOF) == EOF) //do flush if any pending buffer ## This is our target now to explore..
23
  result = EOF;
24

25
      _IO_funlockfile (fp); //unlock the file pointer to be used by another thread
26
      run_fp = NULL;
27
    }
28

29
#ifdef _IO_MTSAFE_IO
30
  _IO_lock_unlock (list_all_lock);
31
  _IO_cleanup_region_end (0);
32
#endif
33

34
  return result;
35
}

1
# define _IO_JUMPS_FUNC(THIS) \
2
  (IO_validate_vtable                                                   \
3
   (*(struct _IO_jump_t **) ((void *) &_IO_JUMPS_FILE_plus (THIS) \
4
           + (THIS)->_vtable_offset)))