1 /* Copyright (C) 1993-2012 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. */
30 # define _POSIX_SOURCE
35 #include <sys/param.h>
36 #include <sys/types.h>
43 # include "../wcsmbs/wcsmbsload.h"
44 # include "../iconv/gconv_charset.h"
45 # include "../iconv/gconv_int.h"
46 # include <shlib-compat.h>
47 # include <not-cancel.h>
48 # include <kernel-features.h>
54 # define __set_errno(Val) errno = (Val)
59 # define open(Name, Flags, Prot) __open (Name, Flags, Prot)
60 # define lseek(FD, Offset, Whence) __lseek (FD, Offset, Whence)
61 # define read(FD, Buf, NBytes) __read (FD, Buf, NBytes)
62 # define write(FD, Buf, NBytes) __write (FD, Buf, NBytes)
64 # define _IO_new_do_write _IO_do_write
65 # define _IO_new_file_attach _IO_file_attach
66 # define _IO_new_file_close_it _IO_file_close_it
67 # define _IO_new_file_finish _IO_file_finish
68 # define _IO_new_file_fopen _IO_file_fopen
69 # define _IO_new_file_init _IO_file_init
70 # define _IO_new_file_setbuf _IO_file_setbuf
71 # define _IO_new_file_sync _IO_file_sync
72 # define _IO_new_file_overflow _IO_file_overflow
73 # define _IO_new_file_seekoff _IO_file_seekoff
74 # define _IO_new_file_underflow _IO_file_underflow
75 # define _IO_new_file_write _IO_file_write
76 # define _IO_new_file_xsputn _IO_file_xsputn
81 extern struct __gconv_trans_data __libio_translit attribute_hidden
;
85 /* An fstream can be in at most one of put mode, get mode, or putback mode.
86 Putback mode is a variant of get mode.
88 In a filebuf, there is only one current position, instead of two
89 separate get and put pointers. In get mode, the current position
90 is that of gptr(); in put mode that of pptr().
92 The position in the buffer that corresponds to the position
93 in external file system is normally _IO_read_end, except in putback
94 mode, when it is _IO_save_end.
95 If the field _fb._offset is >= 0, it gives the offset in
96 the file as a whole corresponding to eGptr(). (?)
99 If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
100 and _IO_read_base are equal to each other. These are usually equal
101 to _IO_buf_base, though not necessarily if we have switched from
102 get mode to put mode. (The reason is to maintain the invariant
103 that _IO_read_end corresponds to the external file position.)
104 _IO_write_base is non-NULL and usually equal to _IO_base_base.
105 We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
106 The un-flushed character are those between _IO_write_base and _IO_write_ptr.
109 If a filebuf is in get or putback mode, eback() != egptr().
110 In get mode, the unread characters are between gptr() and egptr().
111 The OS file position corresponds to that of egptr().
114 Putback mode is used to remember "excess" characters that have
115 been sputbackc'd in a separate putback buffer.
116 In putback mode, the get buffer points to the special putback buffer.
117 The unread characters are the characters between gptr() and egptr()
118 in the putback buffer, as well as the area between save_gptr()
119 and save_egptr(), which point into the original reserve buffer.
120 (The pointers save_gptr() and save_egptr() are the values
121 of gptr() and egptr() at the time putback mode was entered.)
122 The OS position corresponds to that of save_egptr().
124 LINE BUFFERED OUTPUT:
125 During line buffered output, _IO_write_base==base() && epptr()==base().
126 However, ptr() may be anywhere between base() and ebuf().
127 This forces a call to filebuf::overflow(int C) on every put.
128 If there is more space in the buffer, and C is not a '\n',
129 then C is inserted, and pptr() incremented.
132 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
135 #define CLOSED_FILEBUF_FLAGS \
136 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
140 _IO_new_file_init (fp
)
141 struct _IO_FILE_plus
*fp
;
143 /* POSIX.1 allows another file handle to be used to change the position
144 of our file descriptor. Hence we actually don't know the actual
145 position before we do the first fseek (and until a following fflush). */
146 fp
->file
._offset
= _IO_pos_BAD
;
147 fp
->file
._IO_file_flags
|= CLOSED_FILEBUF_FLAGS
;
150 fp
->file
._fileno
= -1;
152 libc_hidden_ver (_IO_new_file_init
, _IO_file_init
)
155 _IO_new_file_close_it (fp
)
158 if (!_IO_file_is_open (fp
))
162 if (_IO_in_put_mode (fp
))
163 write_status
= _IO_do_flush (fp
);
164 else if (fp
->_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
165 && !_IO_in_backup (fp
))
167 off64_t o
= _IO_SEEKOFF (fp
, 0, _IO_seek_cur
, 0);
171 write_status
= _IO_SYSSEEK (fp
, o
, SEEK_SET
) < 0 ? EOF
: 0;
176 _IO_unsave_markers (fp
);
178 int close_status
= ((fp
->_flags2
& _IO_FLAGS2_NOCLOSE
) == 0
179 ? _IO_SYSCLOSE (fp
) : 0);
182 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
185 if (_IO_have_wbackup (fp
))
186 _IO_free_wbackup_area (fp
);
187 _IO_wsetb (fp
, NULL
, NULL
, 0);
188 _IO_wsetg (fp
, NULL
, NULL
, NULL
);
189 _IO_wsetp (fp
, NULL
, NULL
);
192 _IO_setb (fp
, NULL
, NULL
, 0);
193 _IO_setg (fp
, NULL
, NULL
, NULL
);
194 _IO_setp (fp
, NULL
, NULL
);
196 _IO_un_link ((struct _IO_FILE_plus
*) fp
);
197 fp
->_flags
= _IO_MAGIC
|CLOSED_FILEBUF_FLAGS
;
199 fp
->_offset
= _IO_pos_BAD
;
201 return close_status
? close_status
: write_status
;
203 libc_hidden_ver (_IO_new_file_close_it
, _IO_file_close_it
)
206 _IO_new_file_finish (fp
, dummy
)
210 if (_IO_file_is_open (fp
))
213 if (!(fp
->_flags
& _IO_DELETE_DONT_CLOSE
))
216 _IO_default_finish (fp
, 0);
218 libc_hidden_ver (_IO_new_file_finish
, _IO_file_finish
)
221 _IO_file_open (fp
, filename
, posix_mode
, prot
, read_write
, is32not64
)
223 const char *filename
;
231 if (__builtin_expect (fp
->_flags2
& _IO_FLAGS2_NOTCANCEL
, 0))
232 fdesc
= open_not_cancel (filename
,
233 posix_mode
| (is32not64
? 0 : O_LARGEFILE
), prot
);
235 fdesc
= open (filename
, posix_mode
| (is32not64
? 0 : O_LARGEFILE
), prot
);
237 fdesc
= open (filename
, posix_mode
, prot
);
242 _IO_mask_flags (fp
, read_write
,_IO_NO_READS
+_IO_NO_WRITES
+_IO_IS_APPENDING
);
243 if ((read_write
& _IO_IS_APPENDING
) && (read_write
& _IO_NO_READS
))
244 if (_IO_SEEKOFF (fp
, (_IO_off64_t
)0, _IO_seek_end
, _IOS_INPUT
|_IOS_OUTPUT
)
245 == _IO_pos_BAD
&& errno
!= ESPIPE
)
247 close_not_cancel (fdesc
);
250 _IO_link_in ((struct _IO_FILE_plus
*) fp
);
253 libc_hidden_def (_IO_file_open
)
256 _IO_new_file_fopen (fp
, filename
, mode
, is32not64
)
258 const char *filename
;
262 int oflags
= 0, omode
;
269 const char *last_recognized
;
272 if (_IO_file_is_open (fp
))
278 read_write
= _IO_NO_WRITES
;
282 oflags
= O_CREAT
|O_TRUNC
;
283 read_write
= _IO_NO_READS
;
287 oflags
= O_CREAT
|O_APPEND
;
288 read_write
= _IO_NO_READS
|_IO_IS_APPENDING
;
291 __set_errno (EINVAL
);
295 last_recognized
= mode
;
297 for (i
= 1; i
< 7; ++i
)
305 read_write
&= _IO_IS_APPENDING
;
307 last_recognized
= mode
;
313 last_recognized
= mode
;
318 last_recognized
= mode
;
322 fp
->_flags2
|= _IO_FLAGS2_MMAP
;
325 fp
->_flags2
|= _IO_FLAGS2_NOTCANCEL
;
331 fp
->_flags2
|= _IO_FLAGS2_CLOEXEC
;
340 result
= _IO_file_open (fp
, filename
, omode
|oflags
, oprot
, read_write
,
345 #ifndef __ASSUME_O_CLOEXEC
346 if ((fp
->_flags2
& _IO_FLAGS2_CLOEXEC
) != 0 && __have_o_cloexec
<= 0)
348 int fd
= _IO_fileno (fp
);
349 if (__have_o_cloexec
== 0)
351 int flags
= __fcntl (fd
, F_GETFD
);
352 __have_o_cloexec
= (flags
& FD_CLOEXEC
) == 0 ? -1 : 1;
354 if (__have_o_cloexec
< 0)
355 __fcntl (fd
, F_SETFD
, FD_CLOEXEC
);
359 /* Test whether the mode string specifies the conversion. */
360 cs
= strstr (last_recognized
+ 1, ",ccs=");
363 /* Yep. Load the appropriate conversions and set the orientation
365 struct gconv_fcts fcts
;
366 struct _IO_codecvt
*cc
;
367 char *endp
= __strchrnul (cs
+ 5, ',');
368 char ccs
[endp
- (cs
+ 5) + 3];
370 *((char *) __mempcpy (ccs
, cs
+ 5, endp
- (cs
+ 5))) = '\0';
373 if (__wcsmbs_named_conv (&fcts
, ccs
[2] == '\0'
374 ? upstr (ccs
, cs
+ 5) : ccs
) != 0)
376 /* Something went wrong, we cannot load the conversion modules.
377 This means we cannot proceed since the user explicitly asked
379 (void) _IO_file_close_it (fp
);
380 __set_errno (EINVAL
);
384 assert (fcts
.towc_nsteps
== 1);
385 assert (fcts
.tomb_nsteps
== 1);
387 fp
->_wide_data
->_IO_read_ptr
= fp
->_wide_data
->_IO_read_end
;
388 fp
->_wide_data
->_IO_write_ptr
= fp
->_wide_data
->_IO_write_base
;
390 /* Clear the state. We start all over again. */
391 memset (&fp
->_wide_data
->_IO_state
, '\0', sizeof (__mbstate_t
));
392 memset (&fp
->_wide_data
->_IO_last_state
, '\0', sizeof (__mbstate_t
));
394 cc
= fp
->_codecvt
= &fp
->_wide_data
->_codecvt
;
396 /* The functions are always the same. */
397 *cc
= __libio_codecvt
;
399 cc
->__cd_in
.__cd
.__nsteps
= fcts
.towc_nsteps
;
400 cc
->__cd_in
.__cd
.__steps
= fcts
.towc
;
402 cc
->__cd_in
.__cd
.__data
[0].__invocation_counter
= 0;
403 cc
->__cd_in
.__cd
.__data
[0].__internal_use
= 1;
404 cc
->__cd_in
.__cd
.__data
[0].__flags
= __GCONV_IS_LAST
;
405 cc
->__cd_in
.__cd
.__data
[0].__statep
= &result
->_wide_data
->_IO_state
;
407 /* XXX For now no transliteration. */
408 cc
->__cd_in
.__cd
.__data
[0].__trans
= NULL
;
410 cc
->__cd_out
.__cd
.__nsteps
= fcts
.tomb_nsteps
;
411 cc
->__cd_out
.__cd
.__steps
= fcts
.tomb
;
413 cc
->__cd_out
.__cd
.__data
[0].__invocation_counter
= 0;
414 cc
->__cd_out
.__cd
.__data
[0].__internal_use
= 1;
415 cc
->__cd_out
.__cd
.__data
[0].__flags
= __GCONV_IS_LAST
;
416 cc
->__cd_out
.__cd
.__data
[0].__statep
=
417 &result
->_wide_data
->_IO_state
;
419 /* And now the transliteration. */
420 cc
->__cd_out
.__cd
.__data
[0].__trans
= &__libio_translit
;
422 /* From now on use the wide character callback functions. */
423 ((struct _IO_FILE_plus
*) fp
)->vtable
= fp
->_wide_data
->_wide_vtable
;
425 /* Set the mode now. */
432 libc_hidden_ver (_IO_new_file_fopen
, _IO_file_fopen
)
435 _IO_new_file_attach (fp
, fd
)
439 if (_IO_file_is_open (fp
))
442 fp
->_flags
&= ~(_IO_NO_READS
+_IO_NO_WRITES
);
443 fp
->_flags
|= _IO_DELETE_DONT_CLOSE
;
444 /* Get the current position of the file. */
445 /* We have to do that since that may be junk. */
446 fp
->_offset
= _IO_pos_BAD
;
447 int save_errno
= errno
;
448 if (_IO_SEEKOFF (fp
, (_IO_off64_t
)0, _IO_seek_cur
, _IOS_INPUT
|_IOS_OUTPUT
)
449 == _IO_pos_BAD
&& errno
!= ESPIPE
)
451 __set_errno (save_errno
);
454 libc_hidden_ver (_IO_new_file_attach
, _IO_file_attach
)
457 _IO_new_file_setbuf (fp
, p
, len
)
462 if (_IO_default_setbuf (fp
, p
, len
) == NULL
)
465 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
467 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
471 libc_hidden_ver (_IO_new_file_setbuf
, _IO_file_setbuf
)
475 _IO_file_setbuf_mmap (fp
, p
, len
)
482 /* Change the function table. */
483 _IO_JUMPS ((struct _IO_FILE_plus
*) fp
) = &_IO_file_jumps
;
484 fp
->_wide_data
->_wide_vtable
= &_IO_wfile_jumps
;
486 /* And perform the normal operation. */
487 result
= _IO_new_file_setbuf (fp
, p
, len
);
489 /* If the call failed, restore to using mmap. */
492 _IO_JUMPS ((struct _IO_FILE_plus
*) fp
) = &_IO_file_jumps_mmap
;
493 fp
->_wide_data
->_wide_vtable
= &_IO_wfile_jumps_mmap
;
499 static _IO_size_t
new_do_write (_IO_FILE
*, const char *, _IO_size_t
);
501 /* Write TO_DO bytes from DATA to FP.
502 Then mark FP as having empty buffers. */
505 _IO_new_do_write (fp
, data
, to_do
)
511 || (_IO_size_t
) new_do_write (fp
, data
, to_do
) == to_do
) ? 0 : EOF
;
513 libc_hidden_ver (_IO_new_do_write
, _IO_do_write
)
517 new_do_write (fp
, data
, to_do
)
523 if (fp
->_flags
& _IO_IS_APPENDING
)
524 /* On a system without a proper O_APPEND implementation,
525 you would need to sys_seek(0, SEEK_END) here, but is
526 not needed nor desirable for Unix- or Posix-like systems.
527 Instead, just indicate that offset (before and after) is
529 fp
->_offset
= _IO_pos_BAD
;
530 else if (fp
->_IO_read_end
!= fp
->_IO_write_base
)
533 = _IO_SYSSEEK (fp
, fp
->_IO_write_base
- fp
->_IO_read_end
, 1);
534 if (new_pos
== _IO_pos_BAD
)
536 fp
->_offset
= new_pos
;
538 count
= _IO_SYSWRITE (fp
, data
, to_do
);
539 if (fp
->_cur_column
&& count
)
540 fp
->_cur_column
= _IO_adjust_column (fp
->_cur_column
- 1, data
, count
) + 1;
541 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
542 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_buf_base
;
543 fp
->_IO_write_end
= (fp
->_mode
<= 0
544 && (fp
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
545 ? fp
->_IO_buf_base
: fp
->_IO_buf_end
);
550 _IO_new_file_underflow (fp
)
555 /* SysV does not make this test; take it out for compatibility */
556 if (fp
->_flags
& _IO_EOF_SEEN
)
560 if (fp
->_flags
& _IO_NO_READS
)
562 fp
->_flags
|= _IO_ERR_SEEN
;
566 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
567 return *(unsigned char *) fp
->_IO_read_ptr
;
569 if (fp
->_IO_buf_base
== NULL
)
571 /* Maybe we already have a push back pointer. */
572 if (fp
->_IO_save_base
!= NULL
)
574 free (fp
->_IO_save_base
);
575 fp
->_flags
&= ~_IO_IN_BACKUP
;
580 /* Flush all line buffered files before reading. */
581 /* FIXME This can/should be moved to genops ?? */
582 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
585 _IO_flush_all_linebuffered ();
587 /* We used to flush all line-buffered stream. This really isn't
588 required by any standard. My recollection is that
589 traditional Unix systems did this for stdout. stderr better
590 not be line buffered. So we do just that here
591 explicitly. --drepper */
592 _IO_acquire_lock (_IO_stdout
);
594 if ((_IO_stdout
->_flags
& (_IO_LINKED
| _IO_NO_WRITES
| _IO_LINE_BUF
))
595 == (_IO_LINKED
| _IO_LINE_BUF
))
596 _IO_OVERFLOW (_IO_stdout
, EOF
);
598 _IO_release_lock (_IO_stdout
);
602 _IO_switch_to_get_mode (fp
);
604 /* This is very tricky. We have to adjust those
605 pointers before we call _IO_SYSREAD () since
606 we may longjump () out while waiting for
607 input. Those pointers may be screwed up. H.J. */
608 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
609 fp
->_IO_read_end
= fp
->_IO_buf_base
;
610 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
613 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
614 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
618 fp
->_flags
|= _IO_EOF_SEEN
;
620 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
622 fp
->_IO_read_end
+= count
;
625 if (fp
->_offset
!= _IO_pos_BAD
)
626 _IO_pos_adjust (fp
->_offset
, count
);
627 return *(unsigned char *) fp
->_IO_read_ptr
;
629 libc_hidden_ver (_IO_new_file_underflow
, _IO_file_underflow
)
631 /* Guts of underflow callback if we mmap the file. This stats the file and
632 updates the stream state to match. In the normal case we return zero.
633 If the file is no longer eligible for mmap, its jump tables are reset to
634 the vanilla ones and we return nonzero. */
636 mmap_remap_check (_IO_FILE
*fp
)
640 if (_IO_SYSSTAT (fp
, &st
) == 0
641 && S_ISREG (st
.st_mode
) && st
.st_size
!= 0
642 /* Limit the file size to 1MB for 32-bit machines. */
643 && (sizeof (ptrdiff_t) > 4 || st
.st_size
< 1*1024*1024))
645 const size_t pagesize
= __getpagesize ();
646 # define ROUNDED(x) (((x) + pagesize - 1) & ~(pagesize - 1))
647 if (ROUNDED (st
.st_size
) < ROUNDED (fp
->_IO_buf_end
650 /* We can trim off some pages past the end of the file. */
651 (void) __munmap (fp
->_IO_buf_base
+ ROUNDED (st
.st_size
),
652 ROUNDED (fp
->_IO_buf_end
- fp
->_IO_buf_base
)
653 - ROUNDED (st
.st_size
));
654 fp
->_IO_buf_end
= fp
->_IO_buf_base
+ st
.st_size
;
656 else if (ROUNDED (st
.st_size
) > ROUNDED (fp
->_IO_buf_end
659 /* The file added some pages. We need to remap it. */
661 #ifdef _G_HAVE_MREMAP
662 p
= __mremap (fp
->_IO_buf_base
, ROUNDED (fp
->_IO_buf_end
664 ROUNDED (st
.st_size
), MREMAP_MAYMOVE
);
667 (void) __munmap (fp
->_IO_buf_base
,
668 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
672 (void) __munmap (fp
->_IO_buf_base
,
673 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
675 p
= _G_MMAP64 (NULL
, st
.st_size
, PROT_READ
, MAP_SHARED
,
678 p
= __mmap (NULL
, st
.st_size
, PROT_READ
, MAP_SHARED
,
684 fp
->_IO_buf_base
= p
;
685 fp
->_IO_buf_end
= fp
->_IO_buf_base
+ st
.st_size
;
689 /* The number of pages didn't change. */
690 fp
->_IO_buf_end
= fp
->_IO_buf_base
+ st
.st_size
;
694 fp
->_offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
695 _IO_setg (fp
, fp
->_IO_buf_base
,
696 fp
->_offset
< fp
->_IO_buf_end
- fp
->_IO_buf_base
697 ? fp
->_IO_buf_base
+ fp
->_offset
: fp
->_IO_buf_end
,
700 /* If we are already positioned at or past the end of the file, don't
701 change the current offset. If not, seek past what we have mapped,
702 mimicking the position left by a normal underflow reading into its
705 if (fp
->_offset
< fp
->_IO_buf_end
- fp
->_IO_buf_base
)
713 (fp
->_fileno
, fp
->_IO_buf_end
- fp
->_IO_buf_base
, SEEK_SET
)
714 != fp
->_IO_buf_end
- fp
->_IO_buf_base
)
715 fp
->_flags
|= _IO_ERR_SEEN
;
717 fp
->_offset
= fp
->_IO_buf_end
- fp
->_IO_buf_base
;
724 /* Life is no longer good for mmap. Punt it. */
725 (void) __munmap (fp
->_IO_buf_base
,
726 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
728 fp
->_IO_buf_base
= fp
->_IO_buf_end
= NULL
;
729 _IO_setg (fp
, NULL
, NULL
, NULL
);
731 _IO_JUMPS ((struct _IO_FILE_plus
*) fp
) = &_IO_file_jumps
;
733 _IO_JUMPS ((struct _IO_FILE_plus
*) fp
) = &_IO_wfile_jumps
;
734 fp
->_wide_data
->_wide_vtable
= &_IO_wfile_jumps
;
740 /* Special callback replacing the underflow callbacks if we mmap the file. */
742 _IO_file_underflow_mmap (_IO_FILE
*fp
)
744 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
745 return *(unsigned char *) fp
->_IO_read_ptr
;
747 if (__builtin_expect (mmap_remap_check (fp
), 0))
748 /* We punted to the regular file functions. */
749 return _IO_UNDERFLOW (fp
);
751 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
752 return *(unsigned char *) fp
->_IO_read_ptr
;
754 fp
->_flags
|= _IO_EOF_SEEN
;
759 decide_maybe_mmap (_IO_FILE
*fp
)
761 /* We use the file in read-only mode. This could mean we can
762 mmap the file and use it without any copying. But not all
763 file descriptors are for mmap-able objects and on 32-bit
764 machines we don't want to map files which are too large since
765 this would require too much virtual memory. */
768 if (_IO_SYSSTAT (fp
, &st
) == 0
769 && S_ISREG (st
.st_mode
) && st
.st_size
!= 0
770 /* Limit the file size to 1MB for 32-bit machines. */
771 && (sizeof (ptrdiff_t) > 4 || st
.st_size
< 1*1024*1024)
773 && (fp
->_offset
== _IO_pos_BAD
|| fp
->_offset
<= st
.st_size
))
775 /* Try to map the file. */
779 p
= _G_MMAP64 (NULL
, st
.st_size
, PROT_READ
, MAP_SHARED
, fp
->_fileno
, 0);
781 p
= __mmap (NULL
, st
.st_size
, PROT_READ
, MAP_SHARED
, fp
->_fileno
, 0);
785 /* OK, we managed to map the file. Set the buffer up and use a
786 special jump table with simplified underflow functions which
787 never tries to read anything from the file. */
795 (fp
->_fileno
, st
.st_size
, SEEK_SET
) != st
.st_size
)
797 (void) __munmap (p
, st
.st_size
);
798 fp
->_offset
= _IO_pos_BAD
;
802 _IO_setb (fp
, p
, (char *) p
+ st
.st_size
, 0);
804 if (fp
->_offset
== _IO_pos_BAD
)
807 _IO_setg (fp
, p
, p
+ fp
->_offset
, p
+ st
.st_size
);
808 fp
->_offset
= st
.st_size
;
811 _IO_JUMPS ((struct _IO_FILE_plus
*)fp
) = &_IO_file_jumps_mmap
;
813 _IO_JUMPS ((struct _IO_FILE_plus
*)fp
) = &_IO_wfile_jumps_mmap
;
814 fp
->_wide_data
->_wide_vtable
= &_IO_wfile_jumps_mmap
;
821 /* We couldn't use mmap, so revert to the vanilla file operations. */
824 _IO_JUMPS ((struct _IO_FILE_plus
*) fp
) = &_IO_file_jumps
;
826 _IO_JUMPS ((struct _IO_FILE_plus
*) fp
) = &_IO_wfile_jumps
;
827 fp
->_wide_data
->_wide_vtable
= &_IO_wfile_jumps
;
831 _IO_file_underflow_maybe_mmap (_IO_FILE
*fp
)
833 /* This is the first read attempt. Choose mmap or vanilla operations
834 and then punt to the chosen underflow routine. */
835 decide_maybe_mmap (fp
);
836 return _IO_UNDERFLOW (fp
);
841 _IO_new_file_overflow (f
, ch
)
845 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
847 f
->_flags
|= _IO_ERR_SEEN
;
851 /* If currently reading or no buffer allocated. */
852 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0 || f
->_IO_write_base
== NULL
)
854 /* Allocate a buffer if needed. */
855 if (f
->_IO_write_base
== NULL
)
858 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
860 /* Otherwise must be currently reading.
861 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
862 logically slide the buffer forwards one block (by setting the
863 read pointers to all point at the beginning of the block). This
864 makes room for subsequent output.
865 Otherwise, set the read pointers to _IO_read_end (leaving that
866 alone, so it can continue to correspond to the external position). */
867 if (__builtin_expect (_IO_in_backup (f
), 0))
869 size_t nbackup
= f
->_IO_read_end
- f
->_IO_read_ptr
;
870 _IO_free_backup_area (f
);
871 f
->_IO_read_base
-= MIN (nbackup
,
872 f
->_IO_read_base
- f
->_IO_buf_base
);
873 f
->_IO_read_ptr
= f
->_IO_read_base
;
876 if (f
->_IO_read_ptr
== f
->_IO_buf_end
)
877 f
->_IO_read_end
= f
->_IO_read_ptr
= f
->_IO_buf_base
;
878 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
879 f
->_IO_write_base
= f
->_IO_write_ptr
;
880 f
->_IO_write_end
= f
->_IO_buf_end
;
881 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
883 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
884 if (f
->_mode
<= 0 && f
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
885 f
->_IO_write_end
= f
->_IO_write_ptr
;
888 return _IO_do_write (f
, f
->_IO_write_base
,
889 f
->_IO_write_ptr
- f
->_IO_write_base
);
890 if (f
->_IO_write_ptr
== f
->_IO_buf_end
) /* Buffer is really full */
891 if (_IO_do_flush (f
) == EOF
)
893 *f
->_IO_write_ptr
++ = ch
;
894 if ((f
->_flags
& _IO_UNBUFFERED
)
895 || ((f
->_flags
& _IO_LINE_BUF
) && ch
== '\n'))
896 if (_IO_do_write (f
, f
->_IO_write_base
,
897 f
->_IO_write_ptr
- f
->_IO_write_base
) == EOF
)
899 return (unsigned char) ch
;
901 libc_hidden_ver (_IO_new_file_overflow
, _IO_file_overflow
)
904 _IO_new_file_sync (fp
)
910 /* char* ptr = cur_ptr(); */
911 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
)
912 if (_IO_do_flush(fp
)) return EOF
;
913 delta
= fp
->_IO_read_ptr
- fp
->_IO_read_end
;
917 if (_IO_in_backup (fp
))
918 delta
-= eGptr () - Gbase ();
920 _IO_off64_t new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
921 if (new_pos
!= (_IO_off64_t
) EOF
)
922 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
924 else if (errno
== ESPIPE
)
925 ; /* Ignore error from unseekable devices. */
931 fp
->_offset
= _IO_pos_BAD
;
932 /* FIXME: Cleanup - can this be shared? */
933 /* setg(base(), ptr, ptr); */
936 libc_hidden_ver (_IO_new_file_sync
, _IO_file_sync
)
939 _IO_file_sync_mmap (_IO_FILE
*fp
)
941 if (fp
->_IO_read_ptr
!= fp
->_IO_read_end
)
944 if (_IO_in_backup (fp
))
945 delta
-= eGptr () - Gbase ();
953 (fp
->_fileno
, fp
->_IO_read_ptr
- fp
->_IO_buf_base
, SEEK_SET
)
954 != fp
->_IO_read_ptr
- fp
->_IO_buf_base
)
956 fp
->_flags
|= _IO_ERR_SEEN
;
960 fp
->_offset
= fp
->_IO_read_ptr
- fp
->_IO_buf_base
;
961 fp
->_IO_read_end
= fp
->_IO_read_ptr
= fp
->_IO_read_base
;
967 _IO_new_file_seekoff (fp
, offset
, dir
, mode
)
974 _IO_off64_t delta
, new_offset
;
976 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
977 offset of the underlying file must be exact. */
978 int must_be_exact
= (fp
->_IO_read_base
== fp
->_IO_read_end
979 && fp
->_IO_write_base
== fp
->_IO_write_ptr
);
982 dir
= _IO_seek_cur
, offset
= 0; /* Don't move any pointers. */
984 /* Flush unwritten characters.
985 (This may do an unneeded write if we seek within the buffer.
986 But to be able to switch to reading, we would need to set
987 egptr to ptr. That can't be done in the current design,
988 which assumes file_ptr() is eGptr. Anyway, since we probably
989 end up flushing when we close(), it doesn't make much difference.)
990 FIXME: simulate mem-papped files. */
992 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
|| _IO_in_put_mode (fp
))
993 if (_IO_switch_to_get_mode (fp
))
996 if (fp
->_IO_buf_base
== NULL
)
998 /* It could be that we already have a pushback buffer. */
999 if (fp
->_IO_read_base
!= NULL
)
1001 free (fp
->_IO_read_base
);
1002 fp
->_flags
&= ~_IO_IN_BACKUP
;
1004 _IO_doallocbuf (fp
);
1005 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1006 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1012 /* Adjust for read-ahead (bytes is buffer). */
1013 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
1014 if (fp
->_offset
== _IO_pos_BAD
)
1020 result
= _IO_SYSSEEK (fp
, 0, dir
);
1024 fp
->_offset
= result
;
1027 /* Make offset absolute, assuming current pointer is file_ptr(). */
1028 offset
+= fp
->_offset
;
1031 __set_errno (EINVAL
);
1041 struct _G_stat64 st
;
1042 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG (st
.st_mode
))
1044 offset
+= st
.st_size
;
1051 /* At this point, dir==_IO_seek_set. */
1053 /* If we are only interested in the current position we've found it now. */
1057 /* If destination is within current buffer, optimize: */
1058 if (fp
->_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
1059 && !_IO_in_backup (fp
))
1061 _IO_off64_t start_offset
= (fp
->_offset
1062 - (fp
->_IO_read_end
- fp
->_IO_buf_base
));
1063 if (offset
>= start_offset
&& offset
< fp
->_offset
)
1065 _IO_setg (fp
, fp
->_IO_buf_base
,
1066 fp
->_IO_buf_base
+ (offset
- start_offset
),
1068 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1070 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
1075 if (fp
->_flags
& _IO_NO_READS
)
1078 /* Try to seek to a block boundary, to improve kernel page management. */
1079 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
1080 delta
= offset
- new_offset
;
1081 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
1083 new_offset
= offset
;
1086 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
1093 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
1095 ? delta
: fp
->_IO_buf_end
- fp
->_IO_buf_base
));
1098 /* We weren't allowed to read, but try to seek the remainder. */
1099 offset
= count
== EOF
? delta
: delta
-count
;
1104 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ delta
,
1105 fp
->_IO_buf_base
+ count
);
1106 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1107 fp
->_offset
= result
+ count
;
1108 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
1112 _IO_unsave_markers (fp
);
1113 result
= _IO_SYSSEEK (fp
, offset
, dir
);
1116 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
1117 fp
->_offset
= result
;
1118 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1119 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1124 /* We need to do it since it is possible that the file offset in
1125 the kernel may be changed behind our back. It may happen when
1126 we fopen a file and then do a fork. One process may access the
1127 file and the kernel file offset will be changed. */
1128 if (fp
->_offset
>= 0)
1129 _IO_SYSSEEK (fp
, fp
->_offset
, 0);
1133 libc_hidden_ver (_IO_new_file_seekoff
, _IO_file_seekoff
)
1136 _IO_file_seekoff_mmap (fp
, offset
, dir
, mode
)
1144 /* If we are only interested in the current position, calculate it and
1145 return right now. This calculation does the right thing when we are
1146 using a pushback buffer, but in the usual case has the same value as
1147 (fp->_IO_read_ptr - fp->_IO_buf_base). */
1149 return fp
->_offset
- (fp
->_IO_read_end
- fp
->_IO_read_ptr
);
1154 /* Adjust for read-ahead (bytes is buffer). */
1155 offset
+= fp
->_IO_read_ptr
- fp
->_IO_read_base
;
1160 offset
+= fp
->_IO_buf_end
- fp
->_IO_buf_base
;
1163 /* At this point, dir==_IO_seek_set. */
1167 /* No negative offsets are valid. */
1168 __set_errno (EINVAL
);
1172 result
= _IO_SYSSEEK (fp
, offset
, 0);
1176 if (offset
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
1177 /* One can fseek arbitrarily past the end of the file
1178 and it is meaningless until one attempts to read.
1179 Leave the buffer pointers in EOF state until underflow. */
1180 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_end
, fp
->_IO_buf_end
);
1182 /* Adjust the read pointers to match the file position,
1183 but so the next read attempt will call underflow. */
1184 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ offset
,
1185 fp
->_IO_buf_base
+ offset
);
1187 fp
->_offset
= result
;
1189 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
1195 _IO_file_seekoff_maybe_mmap (_IO_FILE
*fp
, _IO_off64_t offset
, int dir
,
1198 /* We only get here when we haven't tried to read anything yet.
1199 So there is nothing more useful for us to do here than just
1200 the underlying lseek call. */
1202 _IO_off64_t result
= _IO_SYSSEEK (fp
, offset
, dir
);
1206 fp
->_offset
= result
;
1211 _IO_file_read (fp
, buf
, size
)
1216 return (__builtin_expect (fp
->_flags2
& _IO_FLAGS2_NOTCANCEL
, 0)
1217 ? read_not_cancel (fp
->_fileno
, buf
, size
)
1218 : read (fp
->_fileno
, buf
, size
));
1220 libc_hidden_def (_IO_file_read
)
1223 _IO_file_seek (fp
, offset
, dir
)
1229 return _G_LSEEK64 (fp
->_fileno
, offset
, dir
);
1231 return lseek (fp
->_fileno
, offset
, dir
);
1234 libc_hidden_def (_IO_file_seek
)
1237 _IO_file_stat (fp
, st
)
1242 return _G_FSTAT64 (fp
->_fileno
, (struct _G_stat64
*) st
);
1244 return fstat (fp
->_fileno
, (struct stat
*) st
);
1247 libc_hidden_def (_IO_file_stat
)
1250 _IO_file_close_mmap (fp
)
1253 /* In addition to closing the file descriptor we have to unmap the file. */
1254 (void) __munmap (fp
->_IO_buf_base
, fp
->_IO_buf_end
- fp
->_IO_buf_base
);
1255 fp
->_IO_buf_base
= fp
->_IO_buf_end
= NULL
;
1256 /* Cancelling close should be avoided if possible since it leaves an
1257 unrecoverable state behind. */
1258 return close_not_cancel (fp
->_fileno
);
1265 /* Cancelling close should be avoided if possible since it leaves an
1266 unrecoverable state behind. */
1267 return close_not_cancel (fp
->_fileno
);
1269 libc_hidden_def (_IO_file_close
)
1272 _IO_new_file_write (f
, data
, n
)
1277 _IO_ssize_t to_do
= n
;
1280 _IO_ssize_t count
= (__builtin_expect (f
->_flags2
1281 & _IO_FLAGS2_NOTCANCEL
, 0)
1282 ? write_not_cancel (f
->_fileno
, data
, to_do
)
1283 : write (f
->_fileno
, data
, to_do
));
1286 f
->_flags
|= _IO_ERR_SEEN
;
1290 data
= (void *) ((char *) data
+ count
);
1293 if (f
->_offset
>= 0)
1299 _IO_new_file_xsputn (f
, data
, n
)
1304 register const char *s
= (const char *) data
;
1305 _IO_size_t to_do
= n
;
1307 _IO_size_t count
= 0;
1311 /* This is an optimized implementation.
1312 If the amount to be written straddles a block boundary
1313 (or the filebuf is unbuffered), use sys_write directly. */
1315 /* First figure out how much space is available in the buffer. */
1316 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
1318 count
= f
->_IO_buf_end
- f
->_IO_write_ptr
;
1321 register const char *p
;
1322 for (p
= s
+ n
; p
> s
; )
1333 else if (f
->_IO_write_end
> f
->_IO_write_ptr
)
1334 count
= f
->_IO_write_end
- f
->_IO_write_ptr
; /* Space available. */
1336 /* Then fill the buffer. */
1342 f
->_IO_write_ptr
= __mempcpy (f
->_IO_write_ptr
, s
, count
);
1344 memcpy (f
->_IO_write_ptr
, s
, count
);
1345 f
->_IO_write_ptr
+= count
;
1350 if (to_do
+ must_flush
> 0)
1352 _IO_size_t block_size
, do_write
;
1353 /* Next flush the (full) buffer. */
1354 if (_IO_OVERFLOW (f
, EOF
) == EOF
)
1355 /* If nothing else has to be written we must not signal the
1356 caller that everything has been written. */
1357 return to_do
== 0 ? EOF
: n
- to_do
;
1359 /* Try to maintain alignment: write a whole number of blocks.
1360 dont_write is what gets left over. */
1361 block_size
= f
->_IO_buf_end
- f
->_IO_buf_base
;
1362 do_write
= to_do
- (block_size
>= 128 ? to_do
% block_size
: 0);
1366 count
= new_do_write (f
, s
, do_write
);
1368 if (count
< do_write
)
1372 /* Now write out the remainder. Normally, this will fit in the
1373 buffer, but it's somewhat messier for line-buffered files,
1374 so we let _IO_default_xsputn handle the general case. */
1376 to_do
-= _IO_default_xsputn (f
, s
+do_write
, to_do
);
1380 libc_hidden_ver (_IO_new_file_xsputn
, _IO_file_xsputn
)
1383 _IO_file_xsgetn (fp
, data
, n
)
1388 register _IO_size_t want
, have
;
1389 register _IO_ssize_t count
;
1390 register char *s
= data
;
1394 if (fp
->_IO_buf_base
== NULL
)
1396 /* Maybe we already have a push back pointer. */
1397 if (fp
->_IO_save_base
!= NULL
)
1399 free (fp
->_IO_save_base
);
1400 fp
->_flags
&= ~_IO_IN_BACKUP
;
1402 _IO_doallocbuf (fp
);
1407 have
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
1410 memcpy (s
, fp
->_IO_read_ptr
, want
);
1411 fp
->_IO_read_ptr
+= want
;
1419 s
= __mempcpy (s
, fp
->_IO_read_ptr
, have
);
1421 memcpy (s
, fp
->_IO_read_ptr
, have
);
1425 fp
->_IO_read_ptr
+= have
;
1428 /* Check for backup and repeat */
1429 if (_IO_in_backup (fp
))
1431 _IO_switch_to_main_get_area (fp
);
1435 /* If we now want less than a buffer, underflow and repeat
1436 the copy. Otherwise, _IO_SYSREAD directly to
1438 if (fp
->_IO_buf_base
1439 && want
< (size_t) (fp
->_IO_buf_end
- fp
->_IO_buf_base
))
1441 if (__underflow (fp
) == EOF
)
1447 /* These must be set before the sysread as we might longjmp out
1448 waiting for input. */
1449 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1450 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1452 /* Try to maintain alignment: read a whole number of blocks. */
1454 if (fp
->_IO_buf_base
)
1456 _IO_size_t block_size
= fp
->_IO_buf_end
- fp
->_IO_buf_base
;
1457 if (block_size
>= 128)
1458 count
-= want
% block_size
;
1461 count
= _IO_SYSREAD (fp
, s
, count
);
1465 fp
->_flags
|= _IO_EOF_SEEN
;
1467 fp
->_flags
|= _IO_ERR_SEEN
;
1474 if (fp
->_offset
!= _IO_pos_BAD
)
1475 _IO_pos_adjust (fp
->_offset
, count
);
1481 libc_hidden_def (_IO_file_xsgetn
)
1483 static _IO_size_t
_IO_file_xsgetn_mmap (_IO_FILE
*, void *, _IO_size_t
);
1485 _IO_file_xsgetn_mmap (fp
, data
, n
)
1490 register _IO_size_t have
;
1491 char *read_ptr
= fp
->_IO_read_ptr
;
1492 register char *s
= (char *) data
;
1494 have
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
1498 if (__builtin_expect (_IO_in_backup (fp
), 0))
1501 s
= __mempcpy (s
, read_ptr
, have
);
1503 memcpy (s
, read_ptr
, have
);
1507 _IO_switch_to_main_get_area (fp
);
1508 read_ptr
= fp
->_IO_read_ptr
;
1509 have
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
1514 /* Check that we are mapping all of the file, in case it grew. */
1515 if (__builtin_expect (mmap_remap_check (fp
), 0))
1516 /* We punted mmap, so complete with the vanilla code. */
1517 return s
- (char *) data
+ _IO_XSGETN (fp
, data
, n
);
1519 read_ptr
= fp
->_IO_read_ptr
;
1520 have
= fp
->_IO_read_end
- read_ptr
;
1525 fp
->_flags
|= _IO_EOF_SEEN
;
1529 have
= MIN (have
, n
);
1531 s
= __mempcpy (s
, read_ptr
, have
);
1533 memcpy (s
, read_ptr
, have
);
1536 fp
->_IO_read_ptr
= read_ptr
+ have
;
1539 return s
- (char *) data
;
1542 static _IO_size_t
_IO_file_xsgetn_maybe_mmap (_IO_FILE
*, void *, _IO_size_t
);
1544 _IO_file_xsgetn_maybe_mmap (fp
, data
, n
)
1549 /* We only get here if this is the first attempt to read something.
1550 Decide which operations to use and then punt to the chosen one. */
1552 decide_maybe_mmap (fp
);
1553 return _IO_XSGETN (fp
, data
, n
);
1557 versioned_symbol (libc
, _IO_new_do_write
, _IO_do_write
, GLIBC_2_1
);
1558 versioned_symbol (libc
, _IO_new_file_attach
, _IO_file_attach
, GLIBC_2_1
);
1559 versioned_symbol (libc
, _IO_new_file_close_it
, _IO_file_close_it
, GLIBC_2_1
);
1560 versioned_symbol (libc
, _IO_new_file_finish
, _IO_file_finish
, GLIBC_2_1
);
1561 versioned_symbol (libc
, _IO_new_file_fopen
, _IO_file_fopen
, GLIBC_2_1
);
1562 versioned_symbol (libc
, _IO_new_file_init
, _IO_file_init
, GLIBC_2_1
);
1563 versioned_symbol (libc
, _IO_new_file_setbuf
, _IO_file_setbuf
, GLIBC_2_1
);
1564 versioned_symbol (libc
, _IO_new_file_sync
, _IO_file_sync
, GLIBC_2_1
);
1565 versioned_symbol (libc
, _IO_new_file_overflow
, _IO_file_overflow
, GLIBC_2_1
);
1566 versioned_symbol (libc
, _IO_new_file_seekoff
, _IO_file_seekoff
, GLIBC_2_1
);
1567 versioned_symbol (libc
, _IO_new_file_underflow
, _IO_file_underflow
, GLIBC_2_1
);
1568 versioned_symbol (libc
, _IO_new_file_write
, _IO_file_write
, GLIBC_2_1
);
1569 versioned_symbol (libc
, _IO_new_file_xsputn
, _IO_file_xsputn
, GLIBC_2_1
);
1572 const struct _IO_jump_t _IO_file_jumps
=
1575 JUMP_INIT(finish
, _IO_file_finish
),
1576 JUMP_INIT(overflow
, _IO_file_overflow
),
1577 JUMP_INIT(underflow
, _IO_file_underflow
),
1578 JUMP_INIT(uflow
, _IO_default_uflow
),
1579 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
1580 JUMP_INIT(xsputn
, _IO_file_xsputn
),
1581 JUMP_INIT(xsgetn
, _IO_file_xsgetn
),
1582 JUMP_INIT(seekoff
, _IO_new_file_seekoff
),
1583 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1584 JUMP_INIT(setbuf
, _IO_new_file_setbuf
),
1585 JUMP_INIT(sync
, _IO_new_file_sync
),
1586 JUMP_INIT(doallocate
, _IO_file_doallocate
),
1587 JUMP_INIT(read
, _IO_file_read
),
1588 JUMP_INIT(write
, _IO_new_file_write
),
1589 JUMP_INIT(seek
, _IO_file_seek
),
1590 JUMP_INIT(close
, _IO_file_close
),
1591 JUMP_INIT(stat
, _IO_file_stat
),
1592 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1593 JUMP_INIT(imbue
, _IO_default_imbue
)
1595 libc_hidden_data_def (_IO_file_jumps
)
1597 const struct _IO_jump_t _IO_file_jumps_mmap
=
1600 JUMP_INIT(finish
, _IO_file_finish
),
1601 JUMP_INIT(overflow
, _IO_file_overflow
),
1602 JUMP_INIT(underflow
, _IO_file_underflow_mmap
),
1603 JUMP_INIT(uflow
, _IO_default_uflow
),
1604 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
1605 JUMP_INIT(xsputn
, _IO_new_file_xsputn
),
1606 JUMP_INIT(xsgetn
, _IO_file_xsgetn_mmap
),
1607 JUMP_INIT(seekoff
, _IO_file_seekoff_mmap
),
1608 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1609 JUMP_INIT(setbuf
, (_IO_setbuf_t
) _IO_file_setbuf_mmap
),
1610 JUMP_INIT(sync
, _IO_file_sync_mmap
),
1611 JUMP_INIT(doallocate
, _IO_file_doallocate
),
1612 JUMP_INIT(read
, _IO_file_read
),
1613 JUMP_INIT(write
, _IO_new_file_write
),
1614 JUMP_INIT(seek
, _IO_file_seek
),
1615 JUMP_INIT(close
, _IO_file_close_mmap
),
1616 JUMP_INIT(stat
, _IO_file_stat
),
1617 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1618 JUMP_INIT(imbue
, _IO_default_imbue
)
1621 const struct _IO_jump_t _IO_file_jumps_maybe_mmap
=
1624 JUMP_INIT(finish
, _IO_file_finish
),
1625 JUMP_INIT(overflow
, _IO_file_overflow
),
1626 JUMP_INIT(underflow
, _IO_file_underflow_maybe_mmap
),
1627 JUMP_INIT(uflow
, _IO_default_uflow
),
1628 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
1629 JUMP_INIT(xsputn
, _IO_new_file_xsputn
),
1630 JUMP_INIT(xsgetn
, _IO_file_xsgetn_maybe_mmap
),
1631 JUMP_INIT(seekoff
, _IO_file_seekoff_maybe_mmap
),
1632 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1633 JUMP_INIT(setbuf
, (_IO_setbuf_t
) _IO_file_setbuf_mmap
),
1634 JUMP_INIT(sync
, _IO_new_file_sync
),
1635 JUMP_INIT(doallocate
, _IO_file_doallocate
),
1636 JUMP_INIT(read
, _IO_file_read
),
1637 JUMP_INIT(write
, _IO_new_file_write
),
1638 JUMP_INIT(seek
, _IO_file_seek
),
1639 JUMP_INIT(close
, _IO_file_close
),
1640 JUMP_INIT(stat
, _IO_file_stat
),
1641 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1642 JUMP_INIT(imbue
, _IO_default_imbue
)