1 /* Copyright (C) 1993-2018 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Written by Per Bothner <bothner@cygnus.com>.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>.
19 As a special exception, if you link the code in this file with
20 files compiled with a GNU compiler to produce an executable,
21 that does not cause the resulting executable to be covered by
22 the GNU Lesser General Public License. This exception does not
23 however invalidate any other reasons why the executable file
24 might be covered by the GNU Lesser General Public License.
25 This exception applies to code released by its copyright holders
26 in files containing the exception. */
33 #include <sys/param.h>
34 #include <sys/types.h>
40 #include "../wcsmbs/wcsmbsload.h"
41 #include "../iconv/gconv_charset.h"
42 #include "../iconv/gconv_int.h"
43 #include <shlib-compat.h>
44 #include <not-cancel.h>
45 #include <kernel-features.h>
47 extern struct __gconv_trans_data __libio_translit attribute_hidden
;
49 /* An fstream can be in at most one of put mode, get mode, or putback mode.
50 Putback mode is a variant of get mode.
52 In a filebuf, there is only one current position, instead of two
53 separate get and put pointers. In get mode, the current position
54 is that of gptr(); in put mode that of pptr().
56 The position in the buffer that corresponds to the position
57 in external file system is normally _IO_read_end, except in putback
58 mode, when it is _IO_save_end and also when the file is in append mode,
59 since switching from read to write mode automatically sends the position in
60 the external file system to the end of file.
61 If the field _fb._offset is >= 0, it gives the offset in
62 the file as a whole corresponding to eGptr(). (?)
65 If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
66 and _IO_read_base are equal to each other. These are usually equal
67 to _IO_buf_base, though not necessarily if we have switched from
68 get mode to put mode. (The reason is to maintain the invariant
69 that _IO_read_end corresponds to the external file position.)
70 _IO_write_base is non-NULL and usually equal to _IO_buf_base.
71 We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
72 The un-flushed character are those between _IO_write_base and _IO_write_ptr.
75 If a filebuf is in get or putback mode, eback() != egptr().
76 In get mode, the unread characters are between gptr() and egptr().
77 The OS file position corresponds to that of egptr().
80 Putback mode is used to remember "excess" characters that have
81 been sputbackc'd in a separate putback buffer.
82 In putback mode, the get buffer points to the special putback buffer.
83 The unread characters are the characters between gptr() and egptr()
84 in the putback buffer, as well as the area between save_gptr()
85 and save_egptr(), which point into the original reserve buffer.
86 (The pointers save_gptr() and save_egptr() are the values
87 of gptr() and egptr() at the time putback mode was entered.)
88 The OS position corresponds to that of save_egptr().
91 During line buffered output, _IO_write_base==base() && epptr()==base().
92 However, ptr() may be anywhere between base() and ebuf().
93 This forces a call to filebuf::overflow(int C) on every put.
94 If there is more space in the buffer, and C is not a '\n',
95 then C is inserted, and pptr() incremented.
98 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
101 #define CLOSED_FILEBUF_FLAGS \
102 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
106 _IO_new_file_init_internal (struct _IO_FILE_plus
*fp
)
108 /* POSIX.1 allows another file handle to be used to change the position
109 of our file descriptor. Hence we actually don't know the actual
110 position before we do the first fseek (and until a following fflush). */
111 fp
->file
._offset
= _IO_pos_BAD
;
112 fp
->file
._flags
|= CLOSED_FILEBUF_FLAGS
;
115 fp
->file
._fileno
= -1;
118 /* External version of _IO_new_file_init_internal which switches off
119 vtable validation. */
121 _IO_new_file_init (struct _IO_FILE_plus
*fp
)
123 IO_set_accept_foreign_vtables (&_IO_vtable_check
);
124 _IO_new_file_init_internal (fp
);
128 _IO_new_file_close_it (FILE *fp
)
131 if (!_IO_file_is_open (fp
))
134 if ((fp
->_flags
& _IO_NO_WRITES
) == 0
135 && (fp
->_flags
& _IO_CURRENTLY_PUTTING
) != 0)
136 write_status
= _IO_do_flush (fp
);
140 _IO_unsave_markers (fp
);
142 int close_status
= ((fp
->_flags2
& _IO_FLAGS2_NOCLOSE
) == 0
143 ? _IO_SYSCLOSE (fp
) : 0);
148 if (_IO_have_wbackup (fp
))
149 _IO_free_wbackup_area (fp
);
150 _IO_wsetb (fp
, NULL
, NULL
, 0);
151 _IO_wsetg (fp
, NULL
, NULL
, NULL
);
152 _IO_wsetp (fp
, NULL
, NULL
);
154 _IO_setb (fp
, NULL
, NULL
, 0);
155 _IO_setg (fp
, NULL
, NULL
, NULL
);
156 _IO_setp (fp
, NULL
, NULL
);
158 _IO_un_link ((struct _IO_FILE_plus
*) fp
);
159 fp
->_flags
= _IO_MAGIC
|CLOSED_FILEBUF_FLAGS
;
161 fp
->_offset
= _IO_pos_BAD
;
163 return close_status
? close_status
: write_status
;
165 libc_hidden_ver (_IO_new_file_close_it
, _IO_file_close_it
)
168 _IO_new_file_finish (FILE *fp
, int dummy
)
170 if (_IO_file_is_open (fp
))
173 if (!(fp
->_flags
& _IO_DELETE_DONT_CLOSE
))
176 _IO_default_finish (fp
, 0);
178 libc_hidden_ver (_IO_new_file_finish
, _IO_file_finish
)
181 _IO_file_open (FILE *fp
, const char *filename
, int posix_mode
, int prot
,
182 int read_write
, int is32not64
)
185 if (__glibc_unlikely (fp
->_flags2
& _IO_FLAGS2_NOTCANCEL
))
186 fdesc
= __open_nocancel (filename
,
187 posix_mode
| (is32not64
? 0 : O_LARGEFILE
), prot
);
189 fdesc
= __open (filename
, posix_mode
| (is32not64
? 0 : O_LARGEFILE
), prot
);
193 _IO_mask_flags (fp
, read_write
,_IO_NO_READS
+_IO_NO_WRITES
+_IO_IS_APPENDING
);
194 /* For append mode, send the file offset to the end of the file. Don't
195 update the offset cache though, since the file handle is not active. */
196 if ((read_write
& (_IO_IS_APPENDING
| _IO_NO_READS
))
197 == (_IO_IS_APPENDING
| _IO_NO_READS
))
199 off64_t new_pos
= _IO_SYSSEEK (fp
, 0, _IO_seek_end
);
200 if (new_pos
== _IO_pos_BAD
&& errno
!= ESPIPE
)
202 __close_nocancel (fdesc
);
206 _IO_link_in ((struct _IO_FILE_plus
*) fp
);
209 libc_hidden_def (_IO_file_open
)
212 _IO_new_file_fopen (FILE *fp
, const char *filename
, const char *mode
,
215 int oflags
= 0, omode
;
221 const char *last_recognized
;
223 if (_IO_file_is_open (fp
))
229 read_write
= _IO_NO_WRITES
;
233 oflags
= O_CREAT
|O_TRUNC
;
234 read_write
= _IO_NO_READS
;
238 oflags
= O_CREAT
|O_APPEND
;
239 read_write
= _IO_NO_READS
|_IO_IS_APPENDING
;
242 __set_errno (EINVAL
);
245 last_recognized
= mode
;
246 for (i
= 1; i
< 7; ++i
)
254 read_write
&= _IO_IS_APPENDING
;
255 last_recognized
= mode
;
259 last_recognized
= mode
;
262 last_recognized
= mode
;
265 fp
->_flags2
|= _IO_FLAGS2_MMAP
;
268 fp
->_flags2
|= _IO_FLAGS2_NOTCANCEL
;
272 fp
->_flags2
|= _IO_FLAGS2_CLOEXEC
;
281 result
= _IO_file_open (fp
, filename
, omode
|oflags
, oprot
, read_write
,
286 /* Test whether the mode string specifies the conversion. */
287 cs
= strstr (last_recognized
+ 1, ",ccs=");
290 /* Yep. Load the appropriate conversions and set the orientation
292 struct gconv_fcts fcts
;
293 struct _IO_codecvt
*cc
;
294 char *endp
= __strchrnul (cs
+ 5, ',');
295 char *ccs
= malloc (endp
- (cs
+ 5) + 3);
299 int malloc_err
= errno
; /* Whatever malloc failed with. */
300 (void) _IO_file_close_it (fp
);
301 __set_errno (malloc_err
);
305 *((char *) __mempcpy (ccs
, cs
+ 5, endp
- (cs
+ 5))) = '\0';
308 if (__wcsmbs_named_conv (&fcts
, ccs
[2] == '\0'
309 ? upstr (ccs
, cs
+ 5) : ccs
) != 0)
311 /* Something went wrong, we cannot load the conversion modules.
312 This means we cannot proceed since the user explicitly asked
314 (void) _IO_file_close_it (fp
);
316 __set_errno (EINVAL
);
322 assert (fcts
.towc_nsteps
== 1);
323 assert (fcts
.tomb_nsteps
== 1);
325 fp
->_wide_data
->_IO_read_ptr
= fp
->_wide_data
->_IO_read_end
;
326 fp
->_wide_data
->_IO_write_ptr
= fp
->_wide_data
->_IO_write_base
;
328 /* Clear the state. We start all over again. */
329 memset (&fp
->_wide_data
->_IO_state
, '\0', sizeof (__mbstate_t
));
330 memset (&fp
->_wide_data
->_IO_last_state
, '\0', sizeof (__mbstate_t
));
332 cc
= fp
->_codecvt
= &fp
->_wide_data
->_codecvt
;
334 /* The functions are always the same. */
335 *cc
= __libio_codecvt
;
337 cc
->__cd_in
.__cd
.__nsteps
= fcts
.towc_nsteps
;
338 cc
->__cd_in
.__cd
.__steps
= fcts
.towc
;
340 cc
->__cd_in
.__cd
.__data
[0].__invocation_counter
= 0;
341 cc
->__cd_in
.__cd
.__data
[0].__internal_use
= 1;
342 cc
->__cd_in
.__cd
.__data
[0].__flags
= __GCONV_IS_LAST
;
343 cc
->__cd_in
.__cd
.__data
[0].__statep
= &result
->_wide_data
->_IO_state
;
345 cc
->__cd_out
.__cd
.__nsteps
= fcts
.tomb_nsteps
;
346 cc
->__cd_out
.__cd
.__steps
= fcts
.tomb
;
348 cc
->__cd_out
.__cd
.__data
[0].__invocation_counter
= 0;
349 cc
->__cd_out
.__cd
.__data
[0].__internal_use
= 1;
350 cc
->__cd_out
.__cd
.__data
[0].__flags
351 = __GCONV_IS_LAST
| __GCONV_TRANSLIT
;
352 cc
->__cd_out
.__cd
.__data
[0].__statep
=
353 &result
->_wide_data
->_IO_state
;
355 /* From now on use the wide character callback functions. */
356 _IO_JUMPS_FILE_plus (fp
) = fp
->_wide_data
->_wide_vtable
;
358 /* Set the mode now. */
365 libc_hidden_ver (_IO_new_file_fopen
, _IO_file_fopen
)
368 _IO_new_file_attach (FILE *fp
, int fd
)
370 if (_IO_file_is_open (fp
))
373 fp
->_flags
&= ~(_IO_NO_READS
+_IO_NO_WRITES
);
374 fp
->_flags
|= _IO_DELETE_DONT_CLOSE
;
375 /* Get the current position of the file. */
376 /* We have to do that since that may be junk. */
377 fp
->_offset
= _IO_pos_BAD
;
378 int save_errno
= errno
;
379 if (_IO_SEEKOFF (fp
, (off64_t
)0, _IO_seek_cur
, _IOS_INPUT
|_IOS_OUTPUT
)
380 == _IO_pos_BAD
&& errno
!= ESPIPE
)
382 __set_errno (save_errno
);
385 libc_hidden_ver (_IO_new_file_attach
, _IO_file_attach
)
388 _IO_new_file_setbuf (FILE *fp
, char *p
, ssize_t len
)
390 if (_IO_default_setbuf (fp
, p
, len
) == NULL
)
393 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
395 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
399 libc_hidden_ver (_IO_new_file_setbuf
, _IO_file_setbuf
)
403 _IO_file_setbuf_mmap (FILE *fp
, char *p
, ssize_t len
)
407 /* Change the function table. */
408 _IO_JUMPS_FILE_plus (fp
) = &_IO_file_jumps
;
409 fp
->_wide_data
->_wide_vtable
= &_IO_wfile_jumps
;
411 /* And perform the normal operation. */
412 result
= _IO_new_file_setbuf (fp
, p
, len
);
414 /* If the call failed, restore to using mmap. */
417 _IO_JUMPS_FILE_plus (fp
) = &_IO_file_jumps_mmap
;
418 fp
->_wide_data
->_wide_vtable
= &_IO_wfile_jumps_mmap
;
424 static size_t new_do_write (FILE *, const char *, size_t);
426 /* Write TO_DO bytes from DATA to FP.
427 Then mark FP as having empty buffers. */
430 _IO_new_do_write (FILE *fp
, const char *data
, size_t to_do
)
433 || (size_t) new_do_write (fp
, data
, to_do
) == to_do
) ? 0 : EOF
;
435 libc_hidden_ver (_IO_new_do_write
, _IO_do_write
)
438 new_do_write (FILE *fp
, const char *data
, size_t to_do
)
441 if (fp
->_flags
& _IO_IS_APPENDING
)
442 /* On a system without a proper O_APPEND implementation,
443 you would need to sys_seek(0, SEEK_END) here, but is
444 not needed nor desirable for Unix- or Posix-like systems.
445 Instead, just indicate that offset (before and after) is
447 fp
->_offset
= _IO_pos_BAD
;
448 else if (fp
->_IO_read_end
!= fp
->_IO_write_base
)
451 = _IO_SYSSEEK (fp
, fp
->_IO_write_base
- fp
->_IO_read_end
, 1);
452 if (new_pos
== _IO_pos_BAD
)
454 fp
->_offset
= new_pos
;
456 count
= _IO_SYSWRITE (fp
, data
, to_do
);
457 if (fp
->_cur_column
&& count
)
458 fp
->_cur_column
= _IO_adjust_column (fp
->_cur_column
- 1, data
, count
) + 1;
459 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
460 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_buf_base
;
461 fp
->_IO_write_end
= (fp
->_mode
<= 0
462 && (fp
->_flags
& (_IO_LINE_BUF
| _IO_UNBUFFERED
))
463 ? fp
->_IO_buf_base
: fp
->_IO_buf_end
);
468 _IO_new_file_underflow (FILE *fp
)
472 /* SysV does not make this test; take it out for compatibility */
473 if (fp
->_flags
& _IO_EOF_SEEN
)
477 if (fp
->_flags
& _IO_NO_READS
)
479 fp
->_flags
|= _IO_ERR_SEEN
;
483 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
484 return *(unsigned char *) fp
->_IO_read_ptr
;
486 if (fp
->_IO_buf_base
== NULL
)
488 /* Maybe we already have a push back pointer. */
489 if (fp
->_IO_save_base
!= NULL
)
491 free (fp
->_IO_save_base
);
492 fp
->_flags
&= ~_IO_IN_BACKUP
;
497 /* FIXME This can/should be moved to genops ?? */
498 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
500 /* We used to flush all line-buffered stream. This really isn't
501 required by any standard. My recollection is that
502 traditional Unix systems did this for stdout. stderr better
503 not be line buffered. So we do just that here
504 explicitly. --drepper */
505 _IO_acquire_lock (_IO_stdout
);
507 if ((_IO_stdout
->_flags
& (_IO_LINKED
| _IO_NO_WRITES
| _IO_LINE_BUF
))
508 == (_IO_LINKED
| _IO_LINE_BUF
))
509 _IO_OVERFLOW (_IO_stdout
, EOF
);
511 _IO_release_lock (_IO_stdout
);
514 _IO_switch_to_get_mode (fp
);
516 /* This is very tricky. We have to adjust those
517 pointers before we call _IO_SYSREAD () since
518 we may longjump () out while waiting for
519 input. Those pointers may be screwed up. H.J. */
520 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
521 fp
->_IO_read_end
= fp
->_IO_buf_base
;
522 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
525 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
526 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
530 fp
->_flags
|= _IO_EOF_SEEN
;
532 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
534 fp
->_IO_read_end
+= count
;
537 /* If a stream is read to EOF, the calling application may switch active
538 handles. As a result, our offset cache would no longer be valid, so
540 fp
->_offset
= _IO_pos_BAD
;
543 if (fp
->_offset
!= _IO_pos_BAD
)
544 _IO_pos_adjust (fp
->_offset
, count
);
545 return *(unsigned char *) fp
->_IO_read_ptr
;
547 libc_hidden_ver (_IO_new_file_underflow
, _IO_file_underflow
)
549 /* Guts of underflow callback if we mmap the file. This stats the file and
550 updates the stream state to match. In the normal case we return zero.
551 If the file is no longer eligible for mmap, its jump tables are reset to
552 the vanilla ones and we return nonzero. */
554 mmap_remap_check (FILE *fp
)
558 if (_IO_SYSSTAT (fp
, &st
) == 0
559 && S_ISREG (st
.st_mode
) && st
.st_size
!= 0
560 /* Limit the file size to 1MB for 32-bit machines. */
561 && (sizeof (ptrdiff_t) > 4 || st
.st_size
< 1*1024*1024))
563 const size_t pagesize
= __getpagesize ();
564 # define ROUNDED(x) (((x) + pagesize - 1) & ~(pagesize - 1))
565 if (ROUNDED (st
.st_size
) < ROUNDED (fp
->_IO_buf_end
568 /* We can trim off some pages past the end of the file. */
569 (void) __munmap (fp
->_IO_buf_base
+ ROUNDED (st
.st_size
),
570 ROUNDED (fp
->_IO_buf_end
- fp
->_IO_buf_base
)
571 - ROUNDED (st
.st_size
));
572 fp
->_IO_buf_end
= fp
->_IO_buf_base
+ st
.st_size
;
574 else if (ROUNDED (st
.st_size
) > ROUNDED (fp
->_IO_buf_end
577 /* The file added some pages. We need to remap it. */
580 p
= __mremap (fp
->_IO_buf_base
, ROUNDED (fp
->_IO_buf_end
582 ROUNDED (st
.st_size
), MREMAP_MAYMOVE
);
585 (void) __munmap (fp
->_IO_buf_base
,
586 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
590 (void) __munmap (fp
->_IO_buf_base
,
591 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
592 p
= __mmap64 (NULL
, st
.st_size
, PROT_READ
, MAP_SHARED
,
597 fp
->_IO_buf_base
= p
;
598 fp
->_IO_buf_end
= fp
->_IO_buf_base
+ st
.st_size
;
602 /* The number of pages didn't change. */
603 fp
->_IO_buf_end
= fp
->_IO_buf_base
+ st
.st_size
;
607 fp
->_offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
608 _IO_setg (fp
, fp
->_IO_buf_base
,
609 fp
->_offset
< fp
->_IO_buf_end
- fp
->_IO_buf_base
610 ? fp
->_IO_buf_base
+ fp
->_offset
: fp
->_IO_buf_end
,
613 /* If we are already positioned at or past the end of the file, don't
614 change the current offset. If not, seek past what we have mapped,
615 mimicking the position left by a normal underflow reading into its
618 if (fp
->_offset
< fp
->_IO_buf_end
- fp
->_IO_buf_base
)
620 if (__lseek64 (fp
->_fileno
, fp
->_IO_buf_end
- fp
->_IO_buf_base
,
622 != fp
->_IO_buf_end
- fp
->_IO_buf_base
)
623 fp
->_flags
|= _IO_ERR_SEEN
;
625 fp
->_offset
= fp
->_IO_buf_end
- fp
->_IO_buf_base
;
632 /* Life is no longer good for mmap. Punt it. */
633 (void) __munmap (fp
->_IO_buf_base
,
634 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
636 fp
->_IO_buf_base
= fp
->_IO_buf_end
= NULL
;
637 _IO_setg (fp
, NULL
, NULL
, NULL
);
639 _IO_JUMPS_FILE_plus (fp
) = &_IO_file_jumps
;
641 _IO_JUMPS_FILE_plus (fp
) = &_IO_wfile_jumps
;
642 fp
->_wide_data
->_wide_vtable
= &_IO_wfile_jumps
;
648 /* Special callback replacing the underflow callbacks if we mmap the file. */
650 _IO_file_underflow_mmap (FILE *fp
)
652 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
653 return *(unsigned char *) fp
->_IO_read_ptr
;
655 if (__glibc_unlikely (mmap_remap_check (fp
)))
656 /* We punted to the regular file functions. */
657 return _IO_UNDERFLOW (fp
);
659 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
660 return *(unsigned char *) fp
->_IO_read_ptr
;
662 fp
->_flags
|= _IO_EOF_SEEN
;
667 decide_maybe_mmap (FILE *fp
)
669 /* We use the file in read-only mode. This could mean we can
670 mmap the file and use it without any copying. But not all
671 file descriptors are for mmap-able objects and on 32-bit
672 machines we don't want to map files which are too large since
673 this would require too much virtual memory. */
676 if (_IO_SYSSTAT (fp
, &st
) == 0
677 && S_ISREG (st
.st_mode
) && st
.st_size
!= 0
678 /* Limit the file size to 1MB for 32-bit machines. */
679 && (sizeof (ptrdiff_t) > 4 || st
.st_size
< 1*1024*1024)
681 && (fp
->_offset
== _IO_pos_BAD
|| fp
->_offset
<= st
.st_size
))
683 /* Try to map the file. */
686 p
= __mmap64 (NULL
, st
.st_size
, PROT_READ
, MAP_SHARED
, fp
->_fileno
, 0);
689 /* OK, we managed to map the file. Set the buffer up and use a
690 special jump table with simplified underflow functions which
691 never tries to read anything from the file. */
693 if (__lseek64 (fp
->_fileno
, st
.st_size
, SEEK_SET
) != st
.st_size
)
695 (void) __munmap (p
, st
.st_size
);
696 fp
->_offset
= _IO_pos_BAD
;
700 _IO_setb (fp
, p
, (char *) p
+ st
.st_size
, 0);
702 if (fp
->_offset
== _IO_pos_BAD
)
705 _IO_setg (fp
, p
, p
+ fp
->_offset
, p
+ st
.st_size
);
706 fp
->_offset
= st
.st_size
;
709 _IO_JUMPS_FILE_plus (fp
) = &_IO_file_jumps_mmap
;
711 _IO_JUMPS_FILE_plus (fp
) = &_IO_wfile_jumps_mmap
;
712 fp
->_wide_data
->_wide_vtable
= &_IO_wfile_jumps_mmap
;
719 /* We couldn't use mmap, so revert to the vanilla file operations. */
722 _IO_JUMPS_FILE_plus (fp
) = &_IO_file_jumps
;
724 _IO_JUMPS_FILE_plus (fp
) = &_IO_wfile_jumps
;
725 fp
->_wide_data
->_wide_vtable
= &_IO_wfile_jumps
;
729 _IO_file_underflow_maybe_mmap (FILE *fp
)
731 /* This is the first read attempt. Choose mmap or vanilla operations
732 and then punt to the chosen underflow routine. */
733 decide_maybe_mmap (fp
);
734 return _IO_UNDERFLOW (fp
);
739 _IO_new_file_overflow (FILE *f
, int ch
)
741 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
743 f
->_flags
|= _IO_ERR_SEEN
;
747 /* If currently reading or no buffer allocated. */
748 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0 || f
->_IO_write_base
== NULL
)
750 /* Allocate a buffer if needed. */
751 if (f
->_IO_write_base
== NULL
)
754 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
756 /* Otherwise must be currently reading.
757 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
758 logically slide the buffer forwards one block (by setting the
759 read pointers to all point at the beginning of the block). This
760 makes room for subsequent output.
761 Otherwise, set the read pointers to _IO_read_end (leaving that
762 alone, so it can continue to correspond to the external position). */
763 if (__glibc_unlikely (_IO_in_backup (f
)))
765 size_t nbackup
= f
->_IO_read_end
- f
->_IO_read_ptr
;
766 _IO_free_backup_area (f
);
767 f
->_IO_read_base
-= MIN (nbackup
,
768 f
->_IO_read_base
- f
->_IO_buf_base
);
769 f
->_IO_read_ptr
= f
->_IO_read_base
;
772 if (f
->_IO_read_ptr
== f
->_IO_buf_end
)
773 f
->_IO_read_end
= f
->_IO_read_ptr
= f
->_IO_buf_base
;
774 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
775 f
->_IO_write_base
= f
->_IO_write_ptr
;
776 f
->_IO_write_end
= f
->_IO_buf_end
;
777 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
779 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
780 if (f
->_mode
<= 0 && f
->_flags
& (_IO_LINE_BUF
| _IO_UNBUFFERED
))
781 f
->_IO_write_end
= f
->_IO_write_ptr
;
784 return _IO_do_write (f
, f
->_IO_write_base
,
785 f
->_IO_write_ptr
- f
->_IO_write_base
);
786 if (f
->_IO_write_ptr
== f
->_IO_buf_end
) /* Buffer is really full */
787 if (_IO_do_flush (f
) == EOF
)
789 *f
->_IO_write_ptr
++ = ch
;
790 if ((f
->_flags
& _IO_UNBUFFERED
)
791 || ((f
->_flags
& _IO_LINE_BUF
) && ch
== '\n'))
792 if (_IO_do_write (f
, f
->_IO_write_base
,
793 f
->_IO_write_ptr
- f
->_IO_write_base
) == EOF
)
795 return (unsigned char) ch
;
797 libc_hidden_ver (_IO_new_file_overflow
, _IO_file_overflow
)
800 _IO_new_file_sync (FILE *fp
)
805 /* char* ptr = cur_ptr(); */
806 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
)
807 if (_IO_do_flush(fp
)) return EOF
;
808 delta
= fp
->_IO_read_ptr
- fp
->_IO_read_end
;
811 off64_t new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
812 if (new_pos
!= (off64_t
) EOF
)
813 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
814 else if (errno
== ESPIPE
)
815 ; /* Ignore error from unseekable devices. */
820 fp
->_offset
= _IO_pos_BAD
;
821 /* FIXME: Cleanup - can this be shared? */
822 /* setg(base(), ptr, ptr); */
825 libc_hidden_ver (_IO_new_file_sync
, _IO_file_sync
)
828 _IO_file_sync_mmap (FILE *fp
)
830 if (fp
->_IO_read_ptr
!= fp
->_IO_read_end
)
832 if (__lseek64 (fp
->_fileno
, fp
->_IO_read_ptr
- fp
->_IO_buf_base
,
834 != fp
->_IO_read_ptr
- fp
->_IO_buf_base
)
836 fp
->_flags
|= _IO_ERR_SEEN
;
840 fp
->_offset
= fp
->_IO_read_ptr
- fp
->_IO_buf_base
;
841 fp
->_IO_read_end
= fp
->_IO_read_ptr
= fp
->_IO_read_base
;
845 /* ftell{,o} implementation. The only time we modify the state of the stream
846 is when we have unflushed writes. In that case we seek to the end and
847 record that offset in the stream object. */
851 off64_t result
, offset
= 0;
853 /* No point looking at unflushed data if we haven't allocated buffers
855 if (fp
->_IO_buf_base
!= NULL
)
857 bool unflushed_writes
= fp
->_IO_write_ptr
> fp
->_IO_write_base
;
859 bool append_mode
= (fp
->_flags
& _IO_IS_APPENDING
) == _IO_IS_APPENDING
;
861 /* When we have unflushed writes in append mode, seek to the end of the
862 file and record that offset. This is the only time we change the file
863 stream state and it is safe since the file handle is active. */
864 if (unflushed_writes
&& append_mode
)
866 result
= _IO_SYSSEEK (fp
, 0, _IO_seek_end
);
867 if (result
== _IO_pos_BAD
)
870 fp
->_offset
= result
;
873 /* Adjust for unflushed data. */
874 if (!unflushed_writes
)
875 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
876 /* We don't trust _IO_read_end to represent the current file offset when
877 writing in append mode because the value would have to be shifted to
878 the end of the file during a flush. Use the write base instead, along
879 with the new offset we got above when we did a seek to the end of the
881 else if (append_mode
)
882 offset
+= fp
->_IO_write_ptr
- fp
->_IO_write_base
;
883 /* For all other modes, _IO_read_end represents the file offset. */
885 offset
+= fp
->_IO_write_ptr
- fp
->_IO_read_end
;
888 if (fp
->_offset
!= _IO_pos_BAD
)
889 result
= fp
->_offset
;
891 result
= _IO_SYSSEEK (fp
, 0, _IO_seek_cur
);
900 __set_errno (EINVAL
);
908 _IO_new_file_seekoff (FILE *fp
, off64_t offset
, int dir
, int mode
)
911 off64_t delta
, new_offset
;
914 /* Short-circuit into a separate function. We don't want to mix any
915 functionality and we don't want to touch anything inside the FILE
918 return do_ftell (fp
);
920 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
921 offset of the underlying file must be exact. */
922 int must_be_exact
= (fp
->_IO_read_base
== fp
->_IO_read_end
923 && fp
->_IO_write_base
== fp
->_IO_write_ptr
);
925 bool was_writing
= (fp
->_IO_write_ptr
> fp
->_IO_write_base
926 || _IO_in_put_mode (fp
));
928 /* Flush unwritten characters.
929 (This may do an unneeded write if we seek within the buffer.
930 But to be able to switch to reading, we would need to set
931 egptr to pptr. That can't be done in the current design,
932 which assumes file_ptr() is eGptr. Anyway, since we probably
933 end up flushing when we close(), it doesn't make much difference.)
934 FIXME: simulate mem-mapped files. */
935 if (was_writing
&& _IO_switch_to_get_mode (fp
))
938 if (fp
->_IO_buf_base
== NULL
)
940 /* It could be that we already have a pushback buffer. */
941 if (fp
->_IO_read_base
!= NULL
)
943 free (fp
->_IO_read_base
);
944 fp
->_flags
&= ~_IO_IN_BACKUP
;
947 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
948 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
954 /* Adjust for read-ahead (bytes is buffer). */
955 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
957 if (fp
->_offset
== _IO_pos_BAD
)
959 /* Make offset absolute, assuming current pointer is file_ptr(). */
960 offset
+= fp
->_offset
;
963 __set_errno (EINVAL
);
974 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG (st
.st_mode
))
976 offset
+= st
.st_size
;
984 _IO_free_backup_area (fp
);
986 /* At this point, dir==_IO_seek_set. */
988 /* If destination is within current buffer, optimize: */
989 if (fp
->_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
990 && !_IO_in_backup (fp
))
992 off64_t start_offset
= (fp
->_offset
993 - (fp
->_IO_read_end
- fp
->_IO_buf_base
));
994 if (offset
>= start_offset
&& offset
< fp
->_offset
)
996 _IO_setg (fp
, fp
->_IO_buf_base
,
997 fp
->_IO_buf_base
+ (offset
- start_offset
),
999 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1001 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
1006 if (fp
->_flags
& _IO_NO_READS
)
1009 /* Try to seek to a block boundary, to improve kernel page management. */
1010 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
1011 delta
= offset
- new_offset
;
1012 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
1014 new_offset
= offset
;
1017 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
1024 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
1026 ? delta
: fp
->_IO_buf_end
- fp
->_IO_buf_base
));
1029 /* We weren't allowed to read, but try to seek the remainder. */
1030 offset
= count
== EOF
? delta
: delta
-count
;
1035 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ delta
,
1036 fp
->_IO_buf_base
+ count
);
1037 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1038 fp
->_offset
= result
+ count
;
1039 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
1043 _IO_unsave_markers (fp
);
1044 result
= _IO_SYSSEEK (fp
, offset
, dir
);
1047 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
1048 fp
->_offset
= result
;
1049 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1050 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1055 /* We need to do it since it is possible that the file offset in
1056 the kernel may be changed behind our back. It may happen when
1057 we fopen a file and then do a fork. One process may access the
1058 file and the kernel file offset will be changed. */
1059 if (fp
->_offset
>= 0)
1060 _IO_SYSSEEK (fp
, fp
->_offset
, 0);
1064 libc_hidden_ver (_IO_new_file_seekoff
, _IO_file_seekoff
)
1067 _IO_file_seekoff_mmap (FILE *fp
, off64_t offset
, int dir
, int mode
)
1071 /* If we are only interested in the current position, calculate it and
1072 return right now. This calculation does the right thing when we are
1073 using a pushback buffer, but in the usual case has the same value as
1074 (fp->_IO_read_ptr - fp->_IO_buf_base). */
1076 return fp
->_offset
- (fp
->_IO_read_end
- fp
->_IO_read_ptr
);
1081 /* Adjust for read-ahead (bytes is buffer). */
1082 offset
+= fp
->_IO_read_ptr
- fp
->_IO_read_base
;
1087 offset
+= fp
->_IO_buf_end
- fp
->_IO_buf_base
;
1090 /* At this point, dir==_IO_seek_set. */
1094 /* No negative offsets are valid. */
1095 __set_errno (EINVAL
);
1099 result
= _IO_SYSSEEK (fp
, offset
, 0);
1103 if (offset
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
1104 /* One can fseek arbitrarily past the end of the file
1105 and it is meaningless until one attempts to read.
1106 Leave the buffer pointers in EOF state until underflow. */
1107 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_end
, fp
->_IO_buf_end
);
1109 /* Adjust the read pointers to match the file position,
1110 but so the next read attempt will call underflow. */
1111 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ offset
,
1112 fp
->_IO_buf_base
+ offset
);
1114 fp
->_offset
= result
;
1116 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
1122 _IO_file_seekoff_maybe_mmap (FILE *fp
, off64_t offset
, int dir
,
1125 /* We only get here when we haven't tried to read anything yet.
1126 So there is nothing more useful for us to do here than just
1127 the underlying lseek call. */
1129 off64_t result
= _IO_SYSSEEK (fp
, offset
, dir
);
1133 fp
->_offset
= result
;
1138 _IO_file_read (FILE *fp
, void *buf
, ssize_t size
)
1140 return (__builtin_expect (fp
->_flags2
& _IO_FLAGS2_NOTCANCEL
, 0)
1141 ? __read_nocancel (fp
->_fileno
, buf
, size
)
1142 : __read (fp
->_fileno
, buf
, size
));
1144 libc_hidden_def (_IO_file_read
)
1147 _IO_file_seek (FILE *fp
, off64_t offset
, int dir
)
1149 return __lseek64 (fp
->_fileno
, offset
, dir
);
1151 libc_hidden_def (_IO_file_seek
)
1154 _IO_file_stat (FILE *fp
, void *st
)
1156 return __fxstat64 (_STAT_VER
, fp
->_fileno
, (struct stat64
*) st
);
1158 libc_hidden_def (_IO_file_stat
)
1161 _IO_file_close_mmap (FILE *fp
)
1163 /* In addition to closing the file descriptor we have to unmap the file. */
1164 (void) __munmap (fp
->_IO_buf_base
, fp
->_IO_buf_end
- fp
->_IO_buf_base
);
1165 fp
->_IO_buf_base
= fp
->_IO_buf_end
= NULL
;
1166 /* Cancelling close should be avoided if possible since it leaves an
1167 unrecoverable state behind. */
1168 return __close_nocancel (fp
->_fileno
);
1172 _IO_file_close (FILE *fp
)
1174 /* Cancelling close should be avoided if possible since it leaves an
1175 unrecoverable state behind. */
1176 return __close_nocancel (fp
->_fileno
);
1178 libc_hidden_def (_IO_file_close
)
1181 _IO_new_file_write (FILE *f
, const void *data
, ssize_t n
)
1186 ssize_t count
= (__builtin_expect (f
->_flags2
1187 & _IO_FLAGS2_NOTCANCEL
, 0)
1188 ? __write_nocancel (f
->_fileno
, data
, to_do
)
1189 : __write (f
->_fileno
, data
, to_do
));
1192 f
->_flags
|= _IO_ERR_SEEN
;
1196 data
= (void *) ((char *) data
+ count
);
1199 if (f
->_offset
>= 0)
1205 _IO_new_file_xsputn (FILE *f
, const void *data
, size_t n
)
1207 const char *s
= (const char *) data
;
1214 /* This is an optimized implementation.
1215 If the amount to be written straddles a block boundary
1216 (or the filebuf is unbuffered), use sys_write directly. */
1218 /* First figure out how much space is available in the buffer. */
1219 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
1221 count
= f
->_IO_buf_end
- f
->_IO_write_ptr
;
1225 for (p
= s
+ n
; p
> s
; )
1236 else if (f
->_IO_write_end
> f
->_IO_write_ptr
)
1237 count
= f
->_IO_write_end
- f
->_IO_write_ptr
; /* Space available. */
1239 /* Then fill the buffer. */
1244 f
->_IO_write_ptr
= __mempcpy (f
->_IO_write_ptr
, s
, count
);
1248 if (to_do
+ must_flush
> 0)
1250 size_t block_size
, do_write
;
1251 /* Next flush the (full) buffer. */
1252 if (_IO_OVERFLOW (f
, EOF
) == EOF
)
1253 /* If nothing else has to be written we must not signal the
1254 caller that everything has been written. */
1255 return to_do
== 0 ? EOF
: n
- to_do
;
1257 /* Try to maintain alignment: write a whole number of blocks. */
1258 block_size
= f
->_IO_buf_end
- f
->_IO_buf_base
;
1259 do_write
= to_do
- (block_size
>= 128 ? to_do
% block_size
: 0);
1263 count
= new_do_write (f
, s
, do_write
);
1265 if (count
< do_write
)
1269 /* Now write out the remainder. Normally, this will fit in the
1270 buffer, but it's somewhat messier for line-buffered files,
1271 so we let _IO_default_xsputn handle the general case. */
1273 to_do
-= _IO_default_xsputn (f
, s
+do_write
, to_do
);
1277 libc_hidden_ver (_IO_new_file_xsputn
, _IO_file_xsputn
)
1280 _IO_file_xsgetn (FILE *fp
, void *data
, size_t n
)
1288 if (fp
->_IO_buf_base
== NULL
)
1290 /* Maybe we already have a push back pointer. */
1291 if (fp
->_IO_save_base
!= NULL
)
1293 free (fp
->_IO_save_base
);
1294 fp
->_flags
&= ~_IO_IN_BACKUP
;
1296 _IO_doallocbuf (fp
);
1301 have
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
1304 memcpy (s
, fp
->_IO_read_ptr
, want
);
1305 fp
->_IO_read_ptr
+= want
;
1312 s
= __mempcpy (s
, fp
->_IO_read_ptr
, have
);
1314 fp
->_IO_read_ptr
+= have
;
1317 /* Check for backup and repeat */
1318 if (_IO_in_backup (fp
))
1320 _IO_switch_to_main_get_area (fp
);
1324 /* If we now want less than a buffer, underflow and repeat
1325 the copy. Otherwise, _IO_SYSREAD directly to
1327 if (fp
->_IO_buf_base
1328 && want
< (size_t) (fp
->_IO_buf_end
- fp
->_IO_buf_base
))
1330 if (__underflow (fp
) == EOF
)
1336 /* These must be set before the sysread as we might longjmp out
1337 waiting for input. */
1338 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1339 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1341 /* Try to maintain alignment: read a whole number of blocks. */
1343 if (fp
->_IO_buf_base
)
1345 size_t block_size
= fp
->_IO_buf_end
- fp
->_IO_buf_base
;
1346 if (block_size
>= 128)
1347 count
-= want
% block_size
;
1350 count
= _IO_SYSREAD (fp
, s
, count
);
1354 fp
->_flags
|= _IO_EOF_SEEN
;
1356 fp
->_flags
|= _IO_ERR_SEEN
;
1363 if (fp
->_offset
!= _IO_pos_BAD
)
1364 _IO_pos_adjust (fp
->_offset
, count
);
1370 libc_hidden_def (_IO_file_xsgetn
)
1373 _IO_file_xsgetn_mmap (FILE *fp
, void *data
, size_t n
)
1376 char *read_ptr
= fp
->_IO_read_ptr
;
1377 char *s
= (char *) data
;
1379 have
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
1383 if (__glibc_unlikely (_IO_in_backup (fp
)))
1385 s
= __mempcpy (s
, read_ptr
, have
);
1387 _IO_switch_to_main_get_area (fp
);
1388 read_ptr
= fp
->_IO_read_ptr
;
1389 have
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
1394 /* Check that we are mapping all of the file, in case it grew. */
1395 if (__glibc_unlikely (mmap_remap_check (fp
)))
1396 /* We punted mmap, so complete with the vanilla code. */
1397 return s
- (char *) data
+ _IO_XSGETN (fp
, data
, n
);
1399 read_ptr
= fp
->_IO_read_ptr
;
1400 have
= fp
->_IO_read_end
- read_ptr
;
1405 fp
->_flags
|= _IO_EOF_SEEN
;
1409 have
= MIN (have
, n
);
1410 s
= __mempcpy (s
, read_ptr
, have
);
1411 fp
->_IO_read_ptr
= read_ptr
+ have
;
1414 return s
- (char *) data
;
1418 _IO_file_xsgetn_maybe_mmap (FILE *fp
, void *data
, size_t n
)
1420 /* We only get here if this is the first attempt to read something.
1421 Decide which operations to use and then punt to the chosen one. */
1423 decide_maybe_mmap (fp
);
1424 return _IO_XSGETN (fp
, data
, n
);
1427 versioned_symbol (libc
, _IO_new_do_write
, _IO_do_write
, GLIBC_2_1
);
1428 versioned_symbol (libc
, _IO_new_file_attach
, _IO_file_attach
, GLIBC_2_1
);
1429 versioned_symbol (libc
, _IO_new_file_close_it
, _IO_file_close_it
, GLIBC_2_1
);
1430 versioned_symbol (libc
, _IO_new_file_finish
, _IO_file_finish
, GLIBC_2_1
);
1431 versioned_symbol (libc
, _IO_new_file_fopen
, _IO_file_fopen
, GLIBC_2_1
);
1432 versioned_symbol (libc
, _IO_new_file_init
, _IO_file_init
, GLIBC_2_1
);
1433 versioned_symbol (libc
, _IO_new_file_setbuf
, _IO_file_setbuf
, GLIBC_2_1
);
1434 versioned_symbol (libc
, _IO_new_file_sync
, _IO_file_sync
, GLIBC_2_1
);
1435 versioned_symbol (libc
, _IO_new_file_overflow
, _IO_file_overflow
, GLIBC_2_1
);
1436 versioned_symbol (libc
, _IO_new_file_seekoff
, _IO_file_seekoff
, GLIBC_2_1
);
1437 versioned_symbol (libc
, _IO_new_file_underflow
, _IO_file_underflow
, GLIBC_2_1
);
1438 versioned_symbol (libc
, _IO_new_file_write
, _IO_file_write
, GLIBC_2_1
);
1439 versioned_symbol (libc
, _IO_new_file_xsputn
, _IO_file_xsputn
, GLIBC_2_1
);
1441 const struct _IO_jump_t _IO_file_jumps libio_vtable
=
1444 JUMP_INIT(finish
, _IO_file_finish
),
1445 JUMP_INIT(overflow
, _IO_file_overflow
),
1446 JUMP_INIT(underflow
, _IO_file_underflow
),
1447 JUMP_INIT(uflow
, _IO_default_uflow
),
1448 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
1449 JUMP_INIT(xsputn
, _IO_file_xsputn
),
1450 JUMP_INIT(xsgetn
, _IO_file_xsgetn
),
1451 JUMP_INIT(seekoff
, _IO_new_file_seekoff
),
1452 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1453 JUMP_INIT(setbuf
, _IO_new_file_setbuf
),
1454 JUMP_INIT(sync
, _IO_new_file_sync
),
1455 JUMP_INIT(doallocate
, _IO_file_doallocate
),
1456 JUMP_INIT(read
, _IO_file_read
),
1457 JUMP_INIT(write
, _IO_new_file_write
),
1458 JUMP_INIT(seek
, _IO_file_seek
),
1459 JUMP_INIT(close
, _IO_file_close
),
1460 JUMP_INIT(stat
, _IO_file_stat
),
1461 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1462 JUMP_INIT(imbue
, _IO_default_imbue
)
1464 libc_hidden_data_def (_IO_file_jumps
)
1466 const struct _IO_jump_t _IO_file_jumps_mmap libio_vtable
=
1469 JUMP_INIT(finish
, _IO_file_finish
),
1470 JUMP_INIT(overflow
, _IO_file_overflow
),
1471 JUMP_INIT(underflow
, _IO_file_underflow_mmap
),
1472 JUMP_INIT(uflow
, _IO_default_uflow
),
1473 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
1474 JUMP_INIT(xsputn
, _IO_new_file_xsputn
),
1475 JUMP_INIT(xsgetn
, _IO_file_xsgetn_mmap
),
1476 JUMP_INIT(seekoff
, _IO_file_seekoff_mmap
),
1477 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1478 JUMP_INIT(setbuf
, (_IO_setbuf_t
) _IO_file_setbuf_mmap
),
1479 JUMP_INIT(sync
, _IO_file_sync_mmap
),
1480 JUMP_INIT(doallocate
, _IO_file_doallocate
),
1481 JUMP_INIT(read
, _IO_file_read
),
1482 JUMP_INIT(write
, _IO_new_file_write
),
1483 JUMP_INIT(seek
, _IO_file_seek
),
1484 JUMP_INIT(close
, _IO_file_close_mmap
),
1485 JUMP_INIT(stat
, _IO_file_stat
),
1486 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1487 JUMP_INIT(imbue
, _IO_default_imbue
)
1490 const struct _IO_jump_t _IO_file_jumps_maybe_mmap libio_vtable
=
1493 JUMP_INIT(finish
, _IO_file_finish
),
1494 JUMP_INIT(overflow
, _IO_file_overflow
),
1495 JUMP_INIT(underflow
, _IO_file_underflow_maybe_mmap
),
1496 JUMP_INIT(uflow
, _IO_default_uflow
),
1497 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
1498 JUMP_INIT(xsputn
, _IO_new_file_xsputn
),
1499 JUMP_INIT(xsgetn
, _IO_file_xsgetn_maybe_mmap
),
1500 JUMP_INIT(seekoff
, _IO_file_seekoff_maybe_mmap
),
1501 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1502 JUMP_INIT(setbuf
, (_IO_setbuf_t
) _IO_file_setbuf_mmap
),
1503 JUMP_INIT(sync
, _IO_new_file_sync
),
1504 JUMP_INIT(doallocate
, _IO_file_doallocate
),
1505 JUMP_INIT(read
, _IO_file_read
),
1506 JUMP_INIT(write
, _IO_new_file_write
),
1507 JUMP_INIT(seek
, _IO_file_seek
),
1508 JUMP_INIT(close
, _IO_file_close
),
1509 JUMP_INIT(stat
, _IO_file_stat
),
1510 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1511 JUMP_INIT(imbue
, _IO_default_imbue
)