1 /* Copyright (C) 1993-2014 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_buf_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)
159 if (!_IO_file_is_open (fp))
162 if ((fp->_flags & _IO_NO_WRITES) == 0
163 && (fp->_flags & _IO_CURRENTLY_PUTTING) != 0)
164 write_status = _IO_do_flush (fp);
168 _IO_unsave_markers (fp);
170 int close_status = ((fp->_flags2 & _IO_FLAGS2_NOCLOSE) == 0
171 ? _IO_SYSCLOSE (fp) : 0);
174 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
177 if (_IO_have_wbackup (fp))
178 _IO_free_wbackup_area (fp);
179 _IO_wsetb (fp, NULL, NULL, 0);
180 _IO_wsetg (fp, NULL, NULL, NULL);
181 _IO_wsetp (fp, NULL, NULL);
184 _IO_setb (fp, NULL, NULL, 0);
185 _IO_setg (fp, NULL, NULL, NULL);
186 _IO_setp (fp, NULL, NULL);
188 _IO_un_link ((struct _IO_FILE_plus *) fp);
189 fp->_flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
191 fp->_offset = _IO_pos_BAD;
193 return close_status ? close_status : write_status;
195 libc_hidden_ver (_IO_new_file_close_it, _IO_file_close_it)
198 _IO_new_file_finish (fp, dummy)
202 if (_IO_file_is_open (fp))
205 if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
208 _IO_default_finish (fp, 0);
210 libc_hidden_ver (_IO_new_file_finish, _IO_file_finish)
213 _IO_file_open (fp, filename, posix_mode, prot, read_write, is32not64)
215 const char *filename;
223 if (__glibc_unlikely (fp->_flags2 & _IO_FLAGS2_NOTCANCEL))
224 fdesc = open_not_cancel (filename,
225 posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
227 fdesc = open (filename, posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
229 fdesc = open (filename, posix_mode, prot);
234 _IO_mask_flags (fp, read_write,_IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
235 /* For append mode, send the file offset to the end of the file. Don't
236 update the offset cache though, since the file handle is not active. */
237 if ((read_write & (_IO_IS_APPENDING | _IO_NO_READS))
238 == (_IO_IS_APPENDING | _IO_NO_READS))
240 _IO_off64_t new_pos = _IO_SYSSEEK (fp, 0, _IO_seek_end);
241 if (new_pos == _IO_pos_BAD && errno != ESPIPE)
243 close_not_cancel (fdesc);
247 _IO_link_in ((struct _IO_FILE_plus *) fp);
250 libc_hidden_def (_IO_file_open)
253 _IO_new_file_fopen (fp, filename, mode, is32not64)
255 const char *filename;
259 int oflags = 0, omode;
266 const char *last_recognized;
269 if (_IO_file_is_open (fp))
275 read_write = _IO_NO_WRITES;
279 oflags = O_CREAT|O_TRUNC;
280 read_write = _IO_NO_READS;
284 oflags = O_CREAT|O_APPEND;
285 read_write = _IO_NO_READS|_IO_IS_APPENDING;
288 __set_errno (EINVAL);
292 last_recognized = mode;
294 for (i = 1; i < 7; ++i)
302 read_write &= _IO_IS_APPENDING;
304 last_recognized = mode;
310 last_recognized = mode;
315 last_recognized = mode;
319 fp->_flags2 |= _IO_FLAGS2_MMAP;
322 fp->_flags2 |= _IO_FLAGS2_NOTCANCEL;
328 fp->_flags2 |= _IO_FLAGS2_CLOEXEC;
337 result = _IO_file_open (fp, filename, omode|oflags, oprot, read_write,
342 #ifndef __ASSUME_O_CLOEXEC
343 if ((fp->_flags2 & _IO_FLAGS2_CLOEXEC) != 0 && __have_o_cloexec <= 0)
345 int fd = _IO_fileno (fp);
346 if (__have_o_cloexec == 0)
348 int flags = __fcntl (fd, F_GETFD);
349 __have_o_cloexec = (flags & FD_CLOEXEC) == 0 ? -1 : 1;
351 if (__have_o_cloexec < 0)
352 __fcntl (fd, F_SETFD, FD_CLOEXEC);
356 /* Test whether the mode string specifies the conversion. */
357 cs = strstr (last_recognized + 1, ",ccs=");
360 /* Yep. Load the appropriate conversions and set the orientation
362 struct gconv_fcts fcts;
363 struct _IO_codecvt *cc;
364 char *endp = __strchrnul (cs + 5, ',');
365 char ccs[endp - (cs + 5) + 3];
367 *((char *) __mempcpy (ccs, cs + 5, endp - (cs + 5))) = '\0';
370 if (__wcsmbs_named_conv (&fcts, ccs[2] == '\0'
371 ? upstr (ccs, cs + 5) : ccs) != 0)
373 /* Something went wrong, we cannot load the conversion modules.
374 This means we cannot proceed since the user explicitly asked
376 (void) _IO_file_close_it (fp);
377 __set_errno (EINVAL);
381 assert (fcts.towc_nsteps == 1);
382 assert (fcts.tomb_nsteps == 1);
384 fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end;
385 fp->_wide_data->_IO_write_ptr = fp->_wide_data->_IO_write_base;
387 /* Clear the state. We start all over again. */
388 memset (&fp->_wide_data->_IO_state, '\0', sizeof (__mbstate_t));
389 memset (&fp->_wide_data->_IO_last_state, '\0', sizeof (__mbstate_t));
391 cc = fp->_codecvt = &fp->_wide_data->_codecvt;
393 /* The functions are always the same. */
394 *cc = __libio_codecvt;
396 cc->__cd_in.__cd.__nsteps = fcts.towc_nsteps;
397 cc->__cd_in.__cd.__steps = fcts.towc;
399 cc->__cd_in.__cd.__data[0].__invocation_counter = 0;
400 cc->__cd_in.__cd.__data[0].__internal_use = 1;
401 cc->__cd_in.__cd.__data[0].__flags = __GCONV_IS_LAST;
402 cc->__cd_in.__cd.__data[0].__statep = &result->_wide_data->_IO_state;
404 /* XXX For now no transliteration. */
405 cc->__cd_in.__cd.__data[0].__trans = NULL;
407 cc->__cd_out.__cd.__nsteps = fcts.tomb_nsteps;
408 cc->__cd_out.__cd.__steps = fcts.tomb;
410 cc->__cd_out.__cd.__data[0].__invocation_counter = 0;
411 cc->__cd_out.__cd.__data[0].__internal_use = 1;
412 cc->__cd_out.__cd.__data[0].__flags = __GCONV_IS_LAST;
413 cc->__cd_out.__cd.__data[0].__statep =
414 &result->_wide_data->_IO_state;
416 /* And now the transliteration. */
417 cc->__cd_out.__cd.__data[0].__trans = &__libio_translit;
419 /* From now on use the wide character callback functions. */
420 ((struct _IO_FILE_plus *) fp)->vtable = fp->_wide_data->_wide_vtable;
422 /* Set the mode now. */
429 libc_hidden_ver (_IO_new_file_fopen, _IO_file_fopen)
432 _IO_new_file_attach (fp, fd)
436 if (_IO_file_is_open (fp))
439 fp->_flags &= ~(_IO_NO_READS+_IO_NO_WRITES);
440 fp->_flags |= _IO_DELETE_DONT_CLOSE;
441 /* Get the current position of the file. */
442 /* We have to do that since that may be junk. */
443 fp->_offset = _IO_pos_BAD;
444 int save_errno = errno;
445 if (_IO_SEEKOFF (fp, (_IO_off64_t)0, _IO_seek_cur, _IOS_INPUT|_IOS_OUTPUT)
446 == _IO_pos_BAD && errno != ESPIPE)
448 __set_errno (save_errno);
451 libc_hidden_ver (_IO_new_file_attach, _IO_file_attach)
454 _IO_new_file_setbuf (fp, p, len)
459 if (_IO_default_setbuf (fp, p, len) == NULL)
462 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
464 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
468 libc_hidden_ver (_IO_new_file_setbuf, _IO_file_setbuf)
472 _IO_file_setbuf_mmap (fp, p, len)
479 /* Change the function table. */
480 _IO_JUMPS ((struct _IO_FILE_plus *) fp) = &_IO_file_jumps;
481 fp->_wide_data->_wide_vtable = &_IO_wfile_jumps;
483 /* And perform the normal operation. */
484 result = _IO_new_file_setbuf (fp, p, len);
486 /* If the call failed, restore to using mmap. */
489 _IO_JUMPS ((struct _IO_FILE_plus *) fp) = &_IO_file_jumps_mmap;
490 fp->_wide_data->_wide_vtable = &_IO_wfile_jumps_mmap;
496 static _IO_size_t new_do_write (_IO_FILE *, const char *, _IO_size_t);
498 /* Write TO_DO bytes from DATA to FP.
499 Then mark FP as having empty buffers. */
502 _IO_new_do_write (fp, data, to_do)
508 || (_IO_size_t) new_do_write (fp, data, to_do) == to_do) ? 0 : EOF;
510 libc_hidden_ver (_IO_new_do_write, _IO_do_write)
514 new_do_write (fp, data, to_do)
520 if (fp->_flags & _IO_IS_APPENDING)
521 /* On a system without a proper O_APPEND implementation,
522 you would need to sys_seek(0, SEEK_END) here, but is
523 not needed nor desirable for Unix- or Posix-like systems.
524 Instead, just indicate that offset (before and after) is
526 fp->_offset = _IO_pos_BAD;
527 else if (fp->_IO_read_end != fp->_IO_write_base)
530 = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
531 if (new_pos == _IO_pos_BAD)
533 fp->_offset = new_pos;
535 count = _IO_SYSWRITE (fp, data, to_do);
536 if (fp->_cur_column && count)
537 fp->_cur_column = _IO_adjust_column (fp->_cur_column - 1, data, count) + 1;
538 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
539 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
540 fp->_IO_write_end = (fp->_mode <= 0
541 && (fp->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
542 ? fp->_IO_buf_base : fp->_IO_buf_end);
547 _IO_new_file_underflow (fp)
552 /* SysV does not make this test; take it out for compatibility */
553 if (fp->_flags & _IO_EOF_SEEN)
557 if (fp->_flags & _IO_NO_READS)
559 fp->_flags |= _IO_ERR_SEEN;
563 if (fp->_IO_read_ptr < fp->_IO_read_end)
564 return *(unsigned char *) fp->_IO_read_ptr;
566 if (fp->_IO_buf_base == NULL)
568 /* Maybe we already have a push back pointer. */
569 if (fp->_IO_save_base != NULL)
571 free (fp->_IO_save_base);
572 fp->_flags &= ~_IO_IN_BACKUP;
577 /* Flush all line buffered files before reading. */
578 /* FIXME This can/should be moved to genops ?? */
579 if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
582 _IO_flush_all_linebuffered ();
584 /* We used to flush all line-buffered stream. This really isn't
585 required by any standard. My recollection is that
586 traditional Unix systems did this for stdout. stderr better
587 not be line buffered. So we do just that here
588 explicitly. --drepper */
589 _IO_acquire_lock (_IO_stdout);
591 if ((_IO_stdout->_flags & (_IO_LINKED | _IO_NO_WRITES | _IO_LINE_BUF))
592 == (_IO_LINKED | _IO_LINE_BUF))
593 _IO_OVERFLOW (_IO_stdout, EOF);
595 _IO_release_lock (_IO_stdout);
599 _IO_switch_to_get_mode (fp);
601 /* This is very tricky. We have to adjust those
602 pointers before we call _IO_SYSREAD () since
603 we may longjump () out while waiting for
604 input. Those pointers may be screwed up. H.J. */
605 fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
606 fp->_IO_read_end = fp->_IO_buf_base;
607 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
610 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
611 fp->_IO_buf_end - fp->_IO_buf_base);
615 fp->_flags |= _IO_EOF_SEEN;
617 fp->_flags |= _IO_ERR_SEEN, count = 0;
619 fp->_IO_read_end += count;
622 if (fp->_offset != _IO_pos_BAD)
623 _IO_pos_adjust (fp->_offset, count);
624 return *(unsigned char *) fp->_IO_read_ptr;
626 libc_hidden_ver (_IO_new_file_underflow, _IO_file_underflow)
628 /* Guts of underflow callback if we mmap the file. This stats the file and
629 updates the stream state to match. In the normal case we return zero.
630 If the file is no longer eligible for mmap, its jump tables are reset to
631 the vanilla ones and we return nonzero. */
633 mmap_remap_check (_IO_FILE *fp)
637 if (_IO_SYSSTAT (fp, &st) == 0
638 && S_ISREG (st.st_mode) && st.st_size != 0
639 /* Limit the file size to 1MB for 32-bit machines. */
640 && (sizeof (ptrdiff_t) > 4 || st.st_size < 1*1024*1024))
642 const size_t pagesize = __getpagesize ();
643 # define ROUNDED(x) (((x) + pagesize - 1) & ~(pagesize - 1))
644 if (ROUNDED (st.st_size) < ROUNDED (fp->_IO_buf_end
647 /* We can trim off some pages past the end of the file. */
648 (void) __munmap (fp->_IO_buf_base + ROUNDED (st.st_size),
649 ROUNDED (fp->_IO_buf_end - fp->_IO_buf_base)
650 - ROUNDED (st.st_size));
651 fp->_IO_buf_end = fp->_IO_buf_base + st.st_size;
653 else if (ROUNDED (st.st_size) > ROUNDED (fp->_IO_buf_end
656 /* The file added some pages. We need to remap it. */
658 #ifdef _G_HAVE_MREMAP
659 p = __mremap (fp->_IO_buf_base, ROUNDED (fp->_IO_buf_end
661 ROUNDED (st.st_size), MREMAP_MAYMOVE);
664 (void) __munmap (fp->_IO_buf_base,
665 fp->_IO_buf_end - fp->_IO_buf_base);
669 (void) __munmap (fp->_IO_buf_base,
670 fp->_IO_buf_end - fp->_IO_buf_base);
671 p = __mmap64 (NULL, st.st_size, PROT_READ, MAP_SHARED,
676 fp->_IO_buf_base = p;
677 fp->_IO_buf_end = fp->_IO_buf_base + st.st_size;
681 /* The number of pages didn't change. */
682 fp->_IO_buf_end = fp->_IO_buf_base + st.st_size;
686 fp->_offset -= fp->_IO_read_end - fp->_IO_read_ptr;
687 _IO_setg (fp, fp->_IO_buf_base,
688 fp->_offset < fp->_IO_buf_end - fp->_IO_buf_base
689 ? fp->_IO_buf_base + fp->_offset : fp->_IO_buf_end,
692 /* If we are already positioned at or past the end of the file, don't
693 change the current offset. If not, seek past what we have mapped,
694 mimicking the position left by a normal underflow reading into its
697 if (fp->_offset < fp->_IO_buf_end - fp->_IO_buf_base)
699 if (__lseek64 (fp->_fileno, fp->_IO_buf_end - fp->_IO_buf_base,
701 != fp->_IO_buf_end - fp->_IO_buf_base)
702 fp->_flags |= _IO_ERR_SEEN;
704 fp->_offset = fp->_IO_buf_end - fp->_IO_buf_base;
711 /* Life is no longer good for mmap. Punt it. */
712 (void) __munmap (fp->_IO_buf_base,
713 fp->_IO_buf_end - fp->_IO_buf_base);
715 fp->_IO_buf_base = fp->_IO_buf_end = NULL;
716 _IO_setg (fp, NULL, NULL, NULL);
718 _IO_JUMPS ((struct _IO_FILE_plus *) fp) = &_IO_file_jumps;
720 _IO_JUMPS ((struct _IO_FILE_plus *) fp) = &_IO_wfile_jumps;
721 fp->_wide_data->_wide_vtable = &_IO_wfile_jumps;
727 /* Special callback replacing the underflow callbacks if we mmap the file. */
729 _IO_file_underflow_mmap (_IO_FILE *fp)
731 if (fp->_IO_read_ptr < fp->_IO_read_end)
732 return *(unsigned char *) fp->_IO_read_ptr;
734 if (__glibc_unlikely (mmap_remap_check (fp)))
735 /* We punted to the regular file functions. */
736 return _IO_UNDERFLOW (fp);
738 if (fp->_IO_read_ptr < fp->_IO_read_end)
739 return *(unsigned char *) fp->_IO_read_ptr;
741 fp->_flags |= _IO_EOF_SEEN;
746 decide_maybe_mmap (_IO_FILE *fp)
748 /* We use the file in read-only mode. This could mean we can
749 mmap the file and use it without any copying. But not all
750 file descriptors are for mmap-able objects and on 32-bit
751 machines we don't want to map files which are too large since
752 this would require too much virtual memory. */
755 if (_IO_SYSSTAT (fp, &st) == 0
756 && S_ISREG (st.st_mode) && st.st_size != 0
757 /* Limit the file size to 1MB for 32-bit machines. */
758 && (sizeof (ptrdiff_t) > 4 || st.st_size < 1*1024*1024)
760 && (fp->_offset == _IO_pos_BAD || fp->_offset <= st.st_size))
762 /* Try to map the file. */
765 p = __mmap64 (NULL, st.st_size, PROT_READ, MAP_SHARED, fp->_fileno, 0);
768 /* OK, we managed to map the file. Set the buffer up and use a
769 special jump table with simplified underflow functions which
770 never tries to read anything from the file. */
772 if (__lseek64 (fp->_fileno, st.st_size, SEEK_SET) != st.st_size)
774 (void) __munmap (p, st.st_size);
775 fp->_offset = _IO_pos_BAD;
779 _IO_setb (fp, p, (char *) p + st.st_size, 0);
781 if (fp->_offset == _IO_pos_BAD)
784 _IO_setg (fp, p, p + fp->_offset, p + st.st_size);
785 fp->_offset = st.st_size;
788 _IO_JUMPS ((struct _IO_FILE_plus *)fp) = &_IO_file_jumps_mmap;
790 _IO_JUMPS ((struct _IO_FILE_plus *)fp) = &_IO_wfile_jumps_mmap;
791 fp->_wide_data->_wide_vtable = &_IO_wfile_jumps_mmap;
798 /* We couldn't use mmap, so revert to the vanilla file operations. */
801 _IO_JUMPS ((struct _IO_FILE_plus *) fp) = &_IO_file_jumps;
803 _IO_JUMPS ((struct _IO_FILE_plus *) fp) = &_IO_wfile_jumps;
804 fp->_wide_data->_wide_vtable = &_IO_wfile_jumps;
808 _IO_file_underflow_maybe_mmap (_IO_FILE *fp)
810 /* This is the first read attempt. Choose mmap or vanilla operations
811 and then punt to the chosen underflow routine. */
812 decide_maybe_mmap (fp);
813 return _IO_UNDERFLOW (fp);
818 _IO_new_file_overflow (f, ch)
822 if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
824 f->_flags |= _IO_ERR_SEEN;
828 /* If currently reading or no buffer allocated. */
829 if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL)
831 /* Allocate a buffer if needed. */
832 if (f->_IO_write_base == NULL)
835 _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
837 /* Otherwise must be currently reading.
838 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
839 logically slide the buffer forwards one block (by setting the
840 read pointers to all point at the beginning of the block). This
841 makes room for subsequent output.
842 Otherwise, set the read pointers to _IO_read_end (leaving that
843 alone, so it can continue to correspond to the external position). */
844 if (__glibc_unlikely (_IO_in_backup (f)))
846 size_t nbackup = f->_IO_read_end - f->_IO_read_ptr;
847 _IO_free_backup_area (f);
848 f->_IO_read_base -= MIN (nbackup,
849 f->_IO_read_base - f->_IO_buf_base);
850 f->_IO_read_ptr = f->_IO_read_base;
853 if (f->_IO_read_ptr == f->_IO_buf_end)
854 f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
855 f->_IO_write_ptr = f->_IO_read_ptr;
856 f->_IO_write_base = f->_IO_write_ptr;
857 f->_IO_write_end = f->_IO_buf_end;
858 f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
860 f->_flags |= _IO_CURRENTLY_PUTTING;
861 if (f->_mode <= 0 && f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
862 f->_IO_write_end = f->_IO_write_ptr;
865 return _IO_do_write (f, f->_IO_write_base,
866 f->_IO_write_ptr - f->_IO_write_base);
867 if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
868 if (_IO_do_flush (f) == EOF)
870 *f->_IO_write_ptr++ = ch;
871 if ((f->_flags & _IO_UNBUFFERED)
872 || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
873 if (_IO_do_write (f, f->_IO_write_base,
874 f->_IO_write_ptr - f->_IO_write_base) == EOF)
876 return (unsigned char) ch;
878 libc_hidden_ver (_IO_new_file_overflow, _IO_file_overflow)
881 _IO_new_file_sync (fp)
887 /* char* ptr = cur_ptr(); */
888 if (fp->_IO_write_ptr > fp->_IO_write_base)
889 if (_IO_do_flush(fp)) return EOF;
890 delta = fp->_IO_read_ptr - fp->_IO_read_end;
894 if (_IO_in_backup (fp))
895 delta -= eGptr () - Gbase ();
897 _IO_off64_t new_pos = _IO_SYSSEEK (fp, delta, 1);
898 if (new_pos != (_IO_off64_t) EOF)
899 fp->_IO_read_end = fp->_IO_read_ptr;
901 else if (errno == ESPIPE)
902 ; /* Ignore error from unseekable devices. */
908 fp->_offset = _IO_pos_BAD;
909 /* FIXME: Cleanup - can this be shared? */
910 /* setg(base(), ptr, ptr); */
913 libc_hidden_ver (_IO_new_file_sync, _IO_file_sync)
916 _IO_file_sync_mmap (_IO_FILE *fp)
918 if (fp->_IO_read_ptr != fp->_IO_read_end)
921 if (_IO_in_backup (fp))
922 delta -= eGptr () - Gbase ();
924 if (__lseek64 (fp->_fileno, fp->_IO_read_ptr - fp->_IO_buf_base,
926 != fp->_IO_read_ptr - fp->_IO_buf_base)
928 fp->_flags |= _IO_ERR_SEEN;
932 fp->_offset = fp->_IO_read_ptr - fp->_IO_buf_base;
933 fp->_IO_read_end = fp->_IO_read_ptr = fp->_IO_read_base;
937 /* ftell{,o} implementation. The only time we modify the state of the stream
938 is when we have unflushed writes. In that case we seek to the end and
939 record that offset in the stream object. */
941 do_ftell (_IO_FILE *fp)
943 _IO_off64_t result, offset = 0;
945 /* No point looking at unflushed data if we haven't allocated buffers
947 if (fp->_IO_buf_base != NULL)
949 bool was_writing = (fp->_IO_write_ptr > fp->_IO_write_base
950 || _IO_in_put_mode (fp));
952 bool append_mode = (fp->_flags & _IO_IS_APPENDING) == _IO_IS_APPENDING;
954 /* When we have unflushed writes in append mode, seek to the end of the
955 file and record that offset. This is the only time we change the file
956 stream state and it is safe since the file handle is active. */
957 if (was_writing && append_mode)
959 result = _IO_SYSSEEK (fp, 0, _IO_seek_end);
960 if (result == _IO_pos_BAD)
963 fp->_offset = result;
966 /* Adjust for unflushed data. */
968 offset -= fp->_IO_read_end - fp->_IO_read_ptr;
970 offset += fp->_IO_write_ptr - fp->_IO_read_end;
973 if (fp->_offset != _IO_pos_BAD)
974 result = fp->_offset;
976 result = _IO_SYSSEEK (fp, 0, _IO_seek_cur);
985 __set_errno (EINVAL);
993 _IO_new_file_seekoff (fp, offset, dir, mode)
1000 _IO_off64_t delta, new_offset;
1003 /* Short-circuit into a separate function. We don't want to mix any
1004 functionality and we don't want to touch anything inside the FILE
1007 return do_ftell (fp);
1009 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
1010 offset of the underlying file must be exact. */
1011 int must_be_exact = (fp->_IO_read_base == fp->_IO_read_end
1012 && fp->_IO_write_base == fp->_IO_write_ptr);
1014 bool was_writing = (fp->_IO_write_ptr > fp->_IO_write_base
1015 || _IO_in_put_mode (fp));
1017 /* Flush unwritten characters.
1018 (This may do an unneeded write if we seek within the buffer.
1019 But to be able to switch to reading, we would need to set
1020 egptr to pptr. That can't be done in the current design,
1021 which assumes file_ptr() is eGptr. Anyway, since we probably
1022 end up flushing when we close(), it doesn't make much difference.)
1023 FIXME: simulate mem-mapped files. */
1024 if (was_writing && _IO_switch_to_get_mode (fp))
1027 if (fp->_IO_buf_base == NULL)
1029 /* It could be that we already have a pushback buffer. */
1030 if (fp->_IO_read_base != NULL)
1032 free (fp->_IO_read_base);
1033 fp->_flags &= ~_IO_IN_BACKUP;
1035 _IO_doallocbuf (fp);
1036 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
1037 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
1043 /* Adjust for read-ahead (bytes is buffer). */
1044 offset -= fp->_IO_read_end - fp->_IO_read_ptr;
1046 if (fp->_offset == _IO_pos_BAD)
1048 /* Make offset absolute, assuming current pointer is file_ptr(). */
1049 offset += fp->_offset;
1052 __set_errno (EINVAL);
1063 if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
1065 offset += st.st_size;
1072 /* At this point, dir==_IO_seek_set. */
1074 /* If destination is within current buffer, optimize: */
1075 if (fp->_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
1076 && !_IO_in_backup (fp))
1078 _IO_off64_t start_offset = (fp->_offset
1079 - (fp->_IO_read_end - fp->_IO_buf_base));
1080 if (offset >= start_offset && offset < fp->_offset)
1082 _IO_setg (fp, fp->_IO_buf_base,
1083 fp->_IO_buf_base + (offset - start_offset),
1085 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
1087 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
1092 if (fp->_flags & _IO_NO_READS)
1095 /* Try to seek to a block boundary, to improve kernel page management. */
1096 new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
1097 delta = offset - new_offset;
1098 if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
1100 new_offset = offset;
1103 result = _IO_SYSSEEK (fp, new_offset, 0);
1110 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
1112 ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
1115 /* We weren't allowed to read, but try to seek the remainder. */
1116 offset = count == EOF ? delta : delta-count;
1121 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
1122 fp->_IO_buf_base + count);
1123 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
1124 fp->_offset = result + count;
1125 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
1129 _IO_unsave_markers (fp);
1130 result = _IO_SYSSEEK (fp, offset, dir);
1133 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
1134 fp->_offset = result;
1135 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
1136 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
1141 /* We need to do it since it is possible that the file offset in
1142 the kernel may be changed behind our back. It may happen when
1143 we fopen a file and then do a fork. One process may access the
1144 file and the kernel file offset will be changed. */
1145 if (fp->_offset >= 0)
1146 _IO_SYSSEEK (fp, fp->_offset, 0);
1150 libc_hidden_ver (_IO_new_file_seekoff, _IO_file_seekoff)
1153 _IO_file_seekoff_mmap (fp, offset, dir, mode)
1161 /* If we are only interested in the current position, calculate it and
1162 return right now. This calculation does the right thing when we are
1163 using a pushback buffer, but in the usual case has the same value as
1164 (fp->_IO_read_ptr - fp->_IO_buf_base). */
1166 return fp->_offset - (fp->_IO_read_end - fp->_IO_read_ptr);
1171 /* Adjust for read-ahead (bytes is buffer). */
1172 offset += fp->_IO_read_ptr - fp->_IO_read_base;
1177 offset += fp->_IO_buf_end - fp->_IO_buf_base;
1180 /* At this point, dir==_IO_seek_set. */
1184 /* No negative offsets are valid. */
1185 __set_errno (EINVAL);
1189 result = _IO_SYSSEEK (fp, offset, 0);
1193 if (offset > fp->_IO_buf_end - fp->_IO_buf_base)
1194 /* One can fseek arbitrarily past the end of the file
1195 and it is meaningless until one attempts to read.
1196 Leave the buffer pointers in EOF state until underflow. */
1197 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_end, fp->_IO_buf_end);
1199 /* Adjust the read pointers to match the file position,
1200 but so the next read attempt will call underflow. */
1201 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + offset,
1202 fp->_IO_buf_base + offset);
1204 fp->_offset = result;
1206 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
1212 _IO_file_seekoff_maybe_mmap (_IO_FILE *fp, _IO_off64_t offset, int dir,
1215 /* We only get here when we haven't tried to read anything yet.
1216 So there is nothing more useful for us to do here than just
1217 the underlying lseek call. */
1219 _IO_off64_t result = _IO_SYSSEEK (fp, offset, dir);
1223 fp->_offset = result;
1228 _IO_file_read (fp, buf, size)
1233 return (__builtin_expect (fp->_flags2 & _IO_FLAGS2_NOTCANCEL, 0)
1234 ? read_not_cancel (fp->_fileno, buf, size)
1235 : read (fp->_fileno, buf, size));
1237 libc_hidden_def (_IO_file_read)
1240 _IO_file_seek (fp, offset, dir)
1245 return __lseek64 (fp->_fileno, offset, dir);
1247 libc_hidden_def (_IO_file_seek)
1250 _IO_file_stat (fp, st)
1254 return __fxstat64 (_STAT_VER, fp->_fileno, (struct stat64 *) st);
1256 libc_hidden_def (_IO_file_stat)
1259 _IO_file_close_mmap (fp)
1262 /* In addition to closing the file descriptor we have to unmap the file. */
1263 (void) __munmap (fp->_IO_buf_base, fp->_IO_buf_end - fp->_IO_buf_base);
1264 fp->_IO_buf_base = fp->_IO_buf_end = NULL;
1265 /* Cancelling close should be avoided if possible since it leaves an
1266 unrecoverable state behind. */
1267 return close_not_cancel (fp->_fileno);
1274 /* Cancelling close should be avoided if possible since it leaves an
1275 unrecoverable state behind. */
1276 return close_not_cancel (fp->_fileno);
1278 libc_hidden_def (_IO_file_close)
1281 _IO_new_file_write (f, data, n)
1286 _IO_ssize_t to_do = n;
1289 _IO_ssize_t count = (__builtin_expect (f->_flags2
1290 & _IO_FLAGS2_NOTCANCEL, 0)
1291 ? write_not_cancel (f->_fileno, data, to_do)
1292 : write (f->_fileno, data, to_do));
1295 f->_flags |= _IO_ERR_SEEN;
1299 data = (void *) ((char *) data + count);
1302 if (f->_offset >= 0)
1308 _IO_new_file_xsputn (f, data, n)
1313 const char *s = (const char *) data;
1314 _IO_size_t to_do = n;
1316 _IO_size_t count = 0;
1320 /* This is an optimized implementation.
1321 If the amount to be written straddles a block boundary
1322 (or the filebuf is unbuffered), use sys_write directly. */
1324 /* First figure out how much space is available in the buffer. */
1325 if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
1327 count = f->_IO_buf_end - f->_IO_write_ptr;
1331 for (p = s + n; p > s; )
1342 else if (f->_IO_write_end > f->_IO_write_ptr)
1343 count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
1345 /* Then fill the buffer. */
1351 f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
1353 memcpy (f->_IO_write_ptr, s, count);
1354 f->_IO_write_ptr += count;
1359 if (to_do + must_flush > 0)
1361 _IO_size_t block_size, do_write;
1362 /* Next flush the (full) buffer. */
1363 if (_IO_OVERFLOW (f, EOF) == EOF)
1364 /* If nothing else has to be written we must not signal the
1365 caller that everything has been written. */
1366 return to_do == 0 ? EOF : n - to_do;
1368 /* Try to maintain alignment: write a whole number of blocks. */
1369 block_size = f->_IO_buf_end - f->_IO_buf_base;
1370 do_write = to_do - (block_size >= 128 ? to_do % block_size : 0);
1374 count = new_do_write (f, s, do_write);
1376 if (count < do_write)
1380 /* Now write out the remainder. Normally, this will fit in the
1381 buffer, but it's somewhat messier for line-buffered files,
1382 so we let _IO_default_xsputn handle the general case. */
1384 to_do -= _IO_default_xsputn (f, s+do_write, to_do);
1388 libc_hidden_ver (_IO_new_file_xsputn, _IO_file_xsputn)
1391 _IO_file_xsgetn (fp, data, n)
1396 _IO_size_t want, have;
1402 if (fp->_IO_buf_base == NULL)
1404 /* Maybe we already have a push back pointer. */
1405 if (fp->_IO_save_base != NULL)
1407 free (fp->_IO_save_base);
1408 fp->_flags &= ~_IO_IN_BACKUP;
1410 _IO_doallocbuf (fp);
1415 have = fp->_IO_read_end - fp->_IO_read_ptr;
1418 memcpy (s, fp->_IO_read_ptr, want);
1419 fp->_IO_read_ptr += want;
1427 s = __mempcpy (s, fp->_IO_read_ptr, have);
1429 memcpy (s, fp->_IO_read_ptr, have);
1433 fp->_IO_read_ptr += have;
1436 /* Check for backup and repeat */
1437 if (_IO_in_backup (fp))
1439 _IO_switch_to_main_get_area (fp);
1443 /* If we now want less than a buffer, underflow and repeat
1444 the copy. Otherwise, _IO_SYSREAD directly to
1446 if (fp->_IO_buf_base
1447 && want < (size_t) (fp->_IO_buf_end - fp->_IO_buf_base))
1449 if (__underflow (fp) == EOF)
1455 /* These must be set before the sysread as we might longjmp out
1456 waiting for input. */
1457 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
1458 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
1460 /* Try to maintain alignment: read a whole number of blocks. */
1462 if (fp->_IO_buf_base)
1464 _IO_size_t block_size = fp->_IO_buf_end - fp->_IO_buf_base;
1465 if (block_size >= 128)
1466 count -= want % block_size;
1469 count = _IO_SYSREAD (fp, s, count);
1473 fp->_flags |= _IO_EOF_SEEN;
1475 fp->_flags |= _IO_ERR_SEEN;
1482 if (fp->_offset != _IO_pos_BAD)
1483 _IO_pos_adjust (fp->_offset, count);
1489 libc_hidden_def (_IO_file_xsgetn)
1491 static _IO_size_t _IO_file_xsgetn_mmap (_IO_FILE *, void *, _IO_size_t);
1493 _IO_file_xsgetn_mmap (fp, data, n)
1499 char *read_ptr = fp->_IO_read_ptr;
1500 char *s = (char *) data;
1502 have = fp->_IO_read_end - fp->_IO_read_ptr;
1506 if (__glibc_unlikely (_IO_in_backup (fp)))
1509 s = __mempcpy (s, read_ptr, have);
1511 memcpy (s, read_ptr, have);
1515 _IO_switch_to_main_get_area (fp);
1516 read_ptr = fp->_IO_read_ptr;
1517 have = fp->_IO_read_end - fp->_IO_read_ptr;
1522 /* Check that we are mapping all of the file, in case it grew. */
1523 if (__glibc_unlikely (mmap_remap_check (fp)))
1524 /* We punted mmap, so complete with the vanilla code. */
1525 return s - (char *) data + _IO_XSGETN (fp, data, n);
1527 read_ptr = fp->_IO_read_ptr;
1528 have = fp->_IO_read_end - read_ptr;
1533 fp->_flags |= _IO_EOF_SEEN;
1537 have = MIN (have, n);
1539 s = __mempcpy (s, read_ptr, have);
1541 memcpy (s, read_ptr, have);
1544 fp->_IO_read_ptr = read_ptr + have;
1547 return s - (char *) data;
1550 static _IO_size_t _IO_file_xsgetn_maybe_mmap (_IO_FILE *, void *, _IO_size_t);
1552 _IO_file_xsgetn_maybe_mmap (fp, data, n)
1557 /* We only get here if this is the first attempt to read something.
1558 Decide which operations to use and then punt to the chosen one. */
1560 decide_maybe_mmap (fp);
1561 return _IO_XSGETN (fp, data, n);
1565 versioned_symbol (libc, _IO_new_do_write, _IO_do_write, GLIBC_2_1);
1566 versioned_symbol (libc, _IO_new_file_attach, _IO_file_attach, GLIBC_2_1);
1567 versioned_symbol (libc, _IO_new_file_close_it, _IO_file_close_it, GLIBC_2_1);
1568 versioned_symbol (libc, _IO_new_file_finish, _IO_file_finish, GLIBC_2_1);
1569 versioned_symbol (libc, _IO_new_file_fopen, _IO_file_fopen, GLIBC_2_1);
1570 versioned_symbol (libc, _IO_new_file_init, _IO_file_init, GLIBC_2_1);
1571 versioned_symbol (libc, _IO_new_file_setbuf, _IO_file_setbuf, GLIBC_2_1);
1572 versioned_symbol (libc, _IO_new_file_sync, _IO_file_sync, GLIBC_2_1);
1573 versioned_symbol (libc, _IO_new_file_overflow, _IO_file_overflow, GLIBC_2_1);
1574 versioned_symbol (libc, _IO_new_file_seekoff, _IO_file_seekoff, GLIBC_2_1);
1575 versioned_symbol (libc, _IO_new_file_underflow, _IO_file_underflow, GLIBC_2_1);
1576 versioned_symbol (libc, _IO_new_file_write, _IO_file_write, GLIBC_2_1);
1577 versioned_symbol (libc, _IO_new_file_xsputn, _IO_file_xsputn, GLIBC_2_1);
1580 const struct _IO_jump_t _IO_file_jumps =
1583 JUMP_INIT(finish, _IO_file_finish),
1584 JUMP_INIT(overflow, _IO_file_overflow),
1585 JUMP_INIT(underflow, _IO_file_underflow),
1586 JUMP_INIT(uflow, _IO_default_uflow),
1587 JUMP_INIT(pbackfail, _IO_default_pbackfail),
1588 JUMP_INIT(xsputn, _IO_file_xsputn),
1589 JUMP_INIT(xsgetn, _IO_file_xsgetn),
1590 JUMP_INIT(seekoff, _IO_new_file_seekoff),
1591 JUMP_INIT(seekpos, _IO_default_seekpos),
1592 JUMP_INIT(setbuf, _IO_new_file_setbuf),
1593 JUMP_INIT(sync, _IO_new_file_sync),
1594 JUMP_INIT(doallocate, _IO_file_doallocate),
1595 JUMP_INIT(read, _IO_file_read),
1596 JUMP_INIT(write, _IO_new_file_write),
1597 JUMP_INIT(seek, _IO_file_seek),
1598 JUMP_INIT(close, _IO_file_close),
1599 JUMP_INIT(stat, _IO_file_stat),
1600 JUMP_INIT(showmanyc, _IO_default_showmanyc),
1601 JUMP_INIT(imbue, _IO_default_imbue)
1603 libc_hidden_data_def (_IO_file_jumps)
1605 const struct _IO_jump_t _IO_file_jumps_mmap =
1608 JUMP_INIT(finish, _IO_file_finish),
1609 JUMP_INIT(overflow, _IO_file_overflow),
1610 JUMP_INIT(underflow, _IO_file_underflow_mmap),
1611 JUMP_INIT(uflow, _IO_default_uflow),
1612 JUMP_INIT(pbackfail, _IO_default_pbackfail),
1613 JUMP_INIT(xsputn, _IO_new_file_xsputn),
1614 JUMP_INIT(xsgetn, _IO_file_xsgetn_mmap),
1615 JUMP_INIT(seekoff, _IO_file_seekoff_mmap),
1616 JUMP_INIT(seekpos, _IO_default_seekpos),
1617 JUMP_INIT(setbuf, (_IO_setbuf_t) _IO_file_setbuf_mmap),
1618 JUMP_INIT(sync, _IO_file_sync_mmap),
1619 JUMP_INIT(doallocate, _IO_file_doallocate),
1620 JUMP_INIT(read, _IO_file_read),
1621 JUMP_INIT(write, _IO_new_file_write),
1622 JUMP_INIT(seek, _IO_file_seek),
1623 JUMP_INIT(close, _IO_file_close_mmap),
1624 JUMP_INIT(stat, _IO_file_stat),
1625 JUMP_INIT(showmanyc, _IO_default_showmanyc),
1626 JUMP_INIT(imbue, _IO_default_imbue)
1629 const struct _IO_jump_t _IO_file_jumps_maybe_mmap =
1632 JUMP_INIT(finish, _IO_file_finish),
1633 JUMP_INIT(overflow, _IO_file_overflow),
1634 JUMP_INIT(underflow, _IO_file_underflow_maybe_mmap),
1635 JUMP_INIT(uflow, _IO_default_uflow),
1636 JUMP_INIT(pbackfail, _IO_default_pbackfail),
1637 JUMP_INIT(xsputn, _IO_new_file_xsputn),
1638 JUMP_INIT(xsgetn, _IO_file_xsgetn_maybe_mmap),
1639 JUMP_INIT(seekoff, _IO_file_seekoff_maybe_mmap),
1640 JUMP_INIT(seekpos, _IO_default_seekpos),
1641 JUMP_INIT(setbuf, (_IO_setbuf_t) _IO_file_setbuf_mmap),
1642 JUMP_INIT(sync, _IO_new_file_sync),
1643 JUMP_INIT(doallocate, _IO_file_doallocate),
1644 JUMP_INIT(read, _IO_file_read),
1645 JUMP_INIT(write, _IO_new_file_write),
1646 JUMP_INIT(seek, _IO_file_seek),
1647 JUMP_INIT(close, _IO_file_close),
1648 JUMP_INIT(stat, _IO_file_stat),
1649 JUMP_INIT(showmanyc, _IO_default_showmanyc),
1650 JUMP_INIT(imbue, _IO_default_imbue)