1/* Copyright (C) 1993-2017 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Written by Per Bothner <bothner@cygnus.com>.
4
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.
9
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.
14
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/>.
18
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. */
27
28
29#ifndef _POSIX_SOURCE
30# define _POSIX_SOURCE
31#endif
32#include "libioP.h"
33#include <assert.h>
34#include <fcntl.h>
35#include <sys/mman.h>
36#include <sys/param.h>
37#include <sys/types.h>
38#include <sys/stat.h>
39#include <string.h>
40#include <errno.h>
41#include <unistd.h>
42#include <stdlib.h>
43#if _LIBC
44# include "../wcsmbs/wcsmbsload.h"
45# include "../iconv/gconv_charset.h"
46# include "../iconv/gconv_int.h"
47# include <shlib-compat.h>
48# include <not-cancel.h>
49# include <kernel-features.h>
50#endif
51#ifndef errno
52extern int errno;
53#endif
54#ifndef __set_errno
55# define __set_errno(Val) errno = (Val)
56#endif
57
58
59#ifdef _LIBC
60# define open(Name, Flags, Prot) __open (Name, Flags, Prot)
61# define lseek(FD, Offset, Whence) __lseek (FD, Offset, Whence)
62# define read(FD, Buf, NBytes) __read (FD, Buf, NBytes)
63# define write(FD, Buf, NBytes) __write (FD, Buf, NBytes)
64#else
65# define _IO_new_do_write _IO_do_write
66# define _IO_new_file_attach _IO_file_attach
67# define _IO_new_file_close_it _IO_file_close_it
68# define _IO_new_file_finish _IO_file_finish
69# define _IO_new_file_fopen _IO_file_fopen
70# define _IO_new_file_init _IO_file_init
71# define _IO_new_file_setbuf _IO_file_setbuf
72# define _IO_new_file_sync _IO_file_sync
73# define _IO_new_file_overflow _IO_file_overflow
74# define _IO_new_file_seekoff _IO_file_seekoff
75# define _IO_new_file_underflow _IO_file_underflow
76# define _IO_new_file_write _IO_file_write
77# define _IO_new_file_xsputn _IO_file_xsputn
78#endif
79
80
81#ifdef _LIBC
82extern struct __gconv_trans_data __libio_translit attribute_hidden;
83#endif
84
85
86/* An fstream can be in at most one of put mode, get mode, or putback mode.
87 Putback mode is a variant of get mode.
88
89 In a filebuf, there is only one current position, instead of two
90 separate get and put pointers. In get mode, the current position
91 is that of gptr(); in put mode that of pptr().
92
93 The position in the buffer that corresponds to the position
94 in external file system is normally _IO_read_end, except in putback
95 mode, when it is _IO_save_end and also when the file is in append mode,
96 since switching from read to write mode automatically sends the position in
97 the external file system to the end of file.
98 If the field _fb._offset is >= 0, it gives the offset in
99 the file as a whole corresponding to eGptr(). (?)
100
101 PUT MODE:
102 If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
103 and _IO_read_base are equal to each other. These are usually equal
104 to _IO_buf_base, though not necessarily if we have switched from
105 get mode to put mode. (The reason is to maintain the invariant
106 that _IO_read_end corresponds to the external file position.)
107 _IO_write_base is non-NULL and usually equal to _IO_buf_base.
108 We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
109 The un-flushed character are those between _IO_write_base and _IO_write_ptr.
110
111 GET MODE:
112 If a filebuf is in get or putback mode, eback() != egptr().
113 In get mode, the unread characters are between gptr() and egptr().
114 The OS file position corresponds to that of egptr().
115
116 PUTBACK MODE:
117 Putback mode is used to remember "excess" characters that have
118 been sputbackc'd in a separate putback buffer.
119 In putback mode, the get buffer points to the special putback buffer.
120 The unread characters are the characters between gptr() and egptr()
121 in the putback buffer, as well as the area between save_gptr()
122 and save_egptr(), which point into the original reserve buffer.
123 (The pointers save_gptr() and save_egptr() are the values
124 of gptr() and egptr() at the time putback mode was entered.)
125 The OS position corresponds to that of save_egptr().
126
127 LINE BUFFERED OUTPUT:
128 During line buffered output, _IO_write_base==base() && epptr()==base().
129 However, ptr() may be anywhere between base() and ebuf().
130 This forces a call to filebuf::overflow(int C) on every put.
131 If there is more space in the buffer, and C is not a '\n',
132 then C is inserted, and pptr() incremented.
133
134 UNBUFFERED STREAMS:
135 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
136*/
137
138#define CLOSED_FILEBUF_FLAGS \
139 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
140
141
142void
143_IO_new_file_init_internal (struct _IO_FILE_plus *fp)
144{
145 /* POSIX.1 allows another file handle to be used to change the position
146 of our file descriptor. Hence we actually don't know the actual
147 position before we do the first fseek (and until a following fflush). */
148 fp->file._offset = _IO_pos_BAD;
149 fp->file._IO_file_flags |= CLOSED_FILEBUF_FLAGS;
150
151 _IO_link_in (fp);
152 fp->file._fileno = -1;
153}
154
155/* External version of _IO_new_file_init_internal which switches off
156 vtable validation. */
157void
158_IO_new_file_init (struct _IO_FILE_plus *fp)
159{
160 IO_set_accept_foreign_vtables (&_IO_vtable_check);
161 _IO_new_file_init_internal (fp);
162}
163
164int
165_IO_new_file_close_it (_IO_FILE *fp)
166{
167 int write_status;
168 if (!_IO_file_is_open (fp))
169 return EOF;
170
171 if ((fp->_flags & _IO_NO_WRITES) == 0
172 && (fp->_flags & _IO_CURRENTLY_PUTTING) != 0)
173 write_status = _IO_do_flush (fp);
174 else
175 write_status = 0;
176
177 _IO_unsave_markers (fp);
178
179 int close_status = ((fp->_flags2 & _IO_FLAGS2_NOCLOSE) == 0
180 ? _IO_SYSCLOSE (fp) : 0);
181
182 /* Free buffer. */
183#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
184 if (fp->_mode > 0)
185 {
186 if (_IO_have_wbackup (fp))
187 _IO_free_wbackup_area (fp);
188 _IO_wsetb (fp, NULL, NULL, 0);
189 _IO_wsetg (fp, NULL, NULL, NULL);
190 _IO_wsetp (fp, NULL, NULL);
191 }
192#endif
193 _IO_setb (fp, NULL, NULL, 0);
194 _IO_setg (fp, NULL, NULL, NULL);
195 _IO_setp (fp, NULL, NULL);
196
197 _IO_un_link ((struct _IO_FILE_plus *) fp);
198 fp->_flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
199 fp->_fileno = -1;
200 fp->_offset = _IO_pos_BAD;
201
202 return close_status ? close_status : write_status;
203}
204libc_hidden_ver (_IO_new_file_close_it, _IO_file_close_it)
205
206void
207_IO_new_file_finish (_IO_FILE *fp, int dummy)
208{
209 if (_IO_file_is_open (fp))
210 {
211 _IO_do_flush (fp);
212 if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
213 _IO_SYSCLOSE (fp);
214 }
215 _IO_default_finish (fp, 0);
216}
217libc_hidden_ver (_IO_new_file_finish, _IO_file_finish)
218
219_IO_FILE *
220_IO_file_open (_IO_FILE *fp, const char *filename, int posix_mode, int prot,
221 int read_write, int is32not64)
222{
223 int fdesc;
224#ifdef _LIBC
225 if (__glibc_unlikely (fp->_flags2 & _IO_FLAGS2_NOTCANCEL))
226 fdesc = open_not_cancel (filename,
227 posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
228 else
229 fdesc = open (filename, posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
230#else
231 fdesc = open (filename, posix_mode, prot);
232#endif
233 if (fdesc < 0)
234 return NULL;
235 fp->_fileno = fdesc;
236 _IO_mask_flags (fp, read_write,_IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
237 /* For append mode, send the file offset to the end of the file. Don't
238 update the offset cache though, since the file handle is not active. */
239 if ((read_write & (_IO_IS_APPENDING | _IO_NO_READS))
240 == (_IO_IS_APPENDING | _IO_NO_READS))
241 {
242 _IO_off64_t new_pos = _IO_SYSSEEK (fp, 0, _IO_seek_end);
243 if (new_pos == _IO_pos_BAD && errno != ESPIPE)
244 {
245 close_not_cancel (fdesc);
246 return NULL;
247 }
248 }
249 _IO_link_in ((struct _IO_FILE_plus *) fp);
250 return fp;
251}
252libc_hidden_def (_IO_file_open)
253
254_IO_FILE *
255_IO_new_file_fopen (_IO_FILE *fp, const char *filename, const char *mode,
256 int is32not64)
257{
258 int oflags = 0, omode;
259 int read_write;
260 int oprot = 0666;
261 int i;
262 _IO_FILE *result;
263#ifdef _LIBC
264 const char *cs;
265 const char *last_recognized;
266#endif
267
268 if (_IO_file_is_open (fp))
269 return 0;
270 switch (*mode)
271 {
272 case 'r':
273 omode = O_RDONLY;
274 read_write = _IO_NO_WRITES;
275 break;
276 case 'w':
277 omode = O_WRONLY;
278 oflags = O_CREAT|O_TRUNC;
279 read_write = _IO_NO_READS;
280 break;
281 case 'a':
282 omode = O_WRONLY;
283 oflags = O_CREAT|O_APPEND;
284 read_write = _IO_NO_READS|_IO_IS_APPENDING;
285 break;
286 default:
287 __set_errno (EINVAL);
288 return NULL;
289 }
290#ifdef _LIBC
291 last_recognized = mode;
292#endif
293 for (i = 1; i < 7; ++i)
294 {
295 switch (*++mode)
296 {
297 case '\0':
298 break;
299 case '+':
300 omode = O_RDWR;
301 read_write &= _IO_IS_APPENDING;
302#ifdef _LIBC
303 last_recognized = mode;
304#endif
305 continue;
306 case 'x':
307 oflags |= O_EXCL;
308#ifdef _LIBC
309 last_recognized = mode;
310#endif
311 continue;
312 case 'b':
313#ifdef _LIBC
314 last_recognized = mode;
315#endif
316 continue;
317 case 'm':
318 fp->_flags2 |= _IO_FLAGS2_MMAP;
319 continue;
320 case 'c':
321 fp->_flags2 |= _IO_FLAGS2_NOTCANCEL;
322 continue;
323 case 'e':
324 oflags |= O_CLOEXEC;
325 fp->_flags2 |= _IO_FLAGS2_CLOEXEC;
326 continue;
327 default:
328 /* Ignore. */
329 continue;
330 }
331 break;
332 }
333
334 result = _IO_file_open (fp, filename, omode|oflags, oprot, read_write,
335 is32not64);
336
337 if (result != NULL)
338 {
339 /* Test whether the mode string specifies the conversion. */
340 cs = strstr (last_recognized + 1, ",ccs=");
341 if (cs != NULL)
342 {
343 /* Yep. Load the appropriate conversions and set the orientation
344 to wide. */
345 struct gconv_fcts fcts;
346 struct _IO_codecvt *cc;
347 char *endp = __strchrnul (cs + 5, ',');
348 char *ccs = malloc (endp - (cs + 5) + 3);
349
350 if (ccs == NULL)
351 {
352 int malloc_err = errno; /* Whatever malloc failed with. */
353 (void) _IO_file_close_it (fp);
354 __set_errno (malloc_err);
355 return NULL;
356 }
357
358 *((char *) __mempcpy (ccs, cs + 5, endp - (cs + 5))) = '\0';
359 strip (ccs, ccs);
360
361 if (__wcsmbs_named_conv (&fcts, ccs[2] == '\0'
362 ? upstr (ccs, cs + 5) : ccs) != 0)
363 {
364 /* Something went wrong, we cannot load the conversion modules.
365 This means we cannot proceed since the user explicitly asked
366 for these. */
367 (void) _IO_file_close_it (fp);
368 free (ccs);
369 __set_errno (EINVAL);
370 return NULL;
371 }
372
373 free (ccs);
374
375 assert (fcts.towc_nsteps == 1);
376 assert (fcts.tomb_nsteps == 1);
377
378 fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end;
379 fp->_wide_data->_IO_write_ptr = fp->_wide_data->_IO_write_base;
380
381 /* Clear the state. We start all over again. */
382 memset (&fp->_wide_data->_IO_state, '\0', sizeof (__mbstate_t));
383 memset (&fp->_wide_data->_IO_last_state, '\0', sizeof (__mbstate_t));
384
385 cc = fp->_codecvt = &fp->_wide_data->_codecvt;
386
387 /* The functions are always the same. */
388 *cc = __libio_codecvt;
389
390 cc->__cd_in.__cd.__nsteps = fcts.towc_nsteps;
391 cc->__cd_in.__cd.__steps = fcts.towc;
392
393 cc->__cd_in.__cd.__data[0].__invocation_counter = 0;
394 cc->__cd_in.__cd.__data[0].__internal_use = 1;
395 cc->__cd_in.__cd.__data[0].__flags = __GCONV_IS_LAST;
396 cc->__cd_in.__cd.__data[0].__statep = &result->_wide_data->_IO_state;
397
398 cc->__cd_out.__cd.__nsteps = fcts.tomb_nsteps;
399 cc->__cd_out.__cd.__steps = fcts.tomb;
400
401 cc->__cd_out.__cd.__data[0].__invocation_counter = 0;
402 cc->__cd_out.__cd.__data[0].__internal_use = 1;
403 cc->__cd_out.__cd.__data[0].__flags
404 = __GCONV_IS_LAST | __GCONV_TRANSLIT;
405 cc->__cd_out.__cd.__data[0].__statep =
406 &result->_wide_data->_IO_state;
407
408 /* From now on use the wide character callback functions. */
409 _IO_JUMPS_FILE_plus (fp) = fp->_wide_data->_wide_vtable;
410
411 /* Set the mode now. */
412 result->_mode = 1;
413 }
414 }
415
416 return result;
417}
418libc_hidden_ver (_IO_new_file_fopen, _IO_file_fopen)
419
420_IO_FILE *
421_IO_new_file_attach (_IO_FILE *fp, int fd)
422{
423 if (_IO_file_is_open (fp))
424 return NULL;
425 fp->_fileno = fd;
426 fp->_flags &= ~(_IO_NO_READS+_IO_NO_WRITES);
427 fp->_flags |= _IO_DELETE_DONT_CLOSE;
428 /* Get the current position of the file. */
429 /* We have to do that since that may be junk. */
430 fp->_offset = _IO_pos_BAD;
431 int save_errno = errno;
432 if (_IO_SEEKOFF (fp, (_IO_off64_t)0, _IO_seek_cur, _IOS_INPUT|_IOS_OUTPUT)
433 == _IO_pos_BAD && errno != ESPIPE)
434 return NULL;
435 __set_errno (save_errno);
436 return fp;
437}
438libc_hidden_ver (_IO_new_file_attach, _IO_file_attach)
439
440_IO_FILE *
441_IO_new_file_setbuf (_IO_FILE *fp, char *p, _IO_ssize_t len)
442{
443 if (_IO_default_setbuf (fp, p, len) == NULL)
444 return NULL;
445
446 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
447 = fp->_IO_buf_base;
448 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
449
450 return fp;
451}
452libc_hidden_ver (_IO_new_file_setbuf, _IO_file_setbuf)
453
454
455_IO_FILE *
456_IO_file_setbuf_mmap (_IO_FILE *fp, char *p, _IO_ssize_t len)
457{
458 _IO_FILE *result;
459
460 /* Change the function table. */
461 _IO_JUMPS_FILE_plus (fp) = &_IO_file_jumps;
462 fp->_wide_data->_wide_vtable = &_IO_wfile_jumps;
463
464 /* And perform the normal operation. */
465 result = _IO_new_file_setbuf (fp, p, len);
466
467 /* If the call failed, restore to using mmap. */
468 if (result == NULL)
469 {
470 _IO_JUMPS_FILE_plus (fp) = &_IO_file_jumps_mmap;
471 fp->_wide_data->_wide_vtable = &_IO_wfile_jumps_mmap;
472 }
473
474 return result;
475}
476
477static _IO_size_t new_do_write (_IO_FILE *, const char *, _IO_size_t);
478
479/* Write TO_DO bytes from DATA to FP.
480 Then mark FP as having empty buffers. */
481
482int
483_IO_new_do_write (_IO_FILE *fp, const char *data, _IO_size_t to_do)
484{
485 return (to_do == 0
486 || (_IO_size_t) new_do_write (fp, data, to_do) == to_do) ? 0 : EOF;
487}
488libc_hidden_ver (_IO_new_do_write, _IO_do_write)
489
490static
491_IO_size_t
492new_do_write (_IO_FILE *fp, const char *data, _IO_size_t to_do)
493{
494 _IO_size_t count;
495 if (fp->_flags & _IO_IS_APPENDING)
496 /* On a system without a proper O_APPEND implementation,
497 you would need to sys_seek(0, SEEK_END) here, but is
498 not needed nor desirable for Unix- or Posix-like systems.
499 Instead, just indicate that offset (before and after) is
500 unpredictable. */
501 fp->_offset = _IO_pos_BAD;
502 else if (fp->_IO_read_end != fp->_IO_write_base)
503 {
504 _IO_off64_t new_pos
505 = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
506 if (new_pos == _IO_pos_BAD)
507 return 0;
508 fp->_offset = new_pos;
509 }
510 count = _IO_SYSWRITE (fp, data, to_do);
511 if (fp->_cur_column && count)
512 fp->_cur_column = _IO_adjust_column (fp->_cur_column - 1, data, count) + 1;
513 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
514 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
515 fp->_IO_write_end = (fp->_mode <= 0
516 && (fp->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
517 ? fp->_IO_buf_base : fp->_IO_buf_end);
518 return count;
519}
520
521int
522_IO_new_file_underflow (_IO_FILE *fp)
523{
524 _IO_ssize_t count;
525#if 0
526 /* SysV does not make this test; take it out for compatibility */
527 if (fp->_flags & _IO_EOF_SEEN)
528 return (EOF);
529#endif
530
531 if (fp->_flags & _IO_NO_READS)
532 {
533 fp->_flags |= _IO_ERR_SEEN;
534 __set_errno (EBADF);
535 return EOF;
536 }
537 if (fp->_IO_read_ptr < fp->_IO_read_end)
538 return *(unsigned char *) fp->_IO_read_ptr;
539
540 if (fp->_IO_buf_base == NULL)
541 {
542 /* Maybe we already have a push back pointer. */
543 if (fp->_IO_save_base != NULL)
544 {
545 free (fp->_IO_save_base);
546 fp->_flags &= ~_IO_IN_BACKUP;
547 }
548 _IO_doallocbuf (fp);
549 }
550
551 /* Flush all line buffered files before reading. */
552 /* FIXME This can/should be moved to genops ?? */
553 if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
554 {
555#if 0
556 _IO_flush_all_linebuffered ();
557#else
558 /* We used to flush all line-buffered stream. This really isn't
559 required by any standard. My recollection is that
560 traditional Unix systems did this for stdout. stderr better
561 not be line buffered. So we do just that here
562 explicitly. --drepper */
563 _IO_acquire_lock (_IO_stdout);
564
565 if ((_IO_stdout->_flags & (_IO_LINKED | _IO_NO_WRITES | _IO_LINE_BUF))
566 == (_IO_LINKED | _IO_LINE_BUF))
567 _IO_OVERFLOW (_IO_stdout, EOF);
568
569 _IO_release_lock (_IO_stdout);
570#endif
571 }
572
573 _IO_switch_to_get_mode (fp);
574
575 /* This is very tricky. We have to adjust those
576 pointers before we call _IO_SYSREAD () since
577 we may longjump () out while waiting for
578 input. Those pointers may be screwed up. H.J. */
579 fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
580 fp->_IO_read_end = fp->_IO_buf_base;
581 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
582 = fp->_IO_buf_base;
583
584 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
585 fp->_IO_buf_end - fp->_IO_buf_base);
586 if (count <= 0)
587 {
588 if (count == 0)
589 fp->_flags |= _IO_EOF_SEEN;
590 else
591 fp->_flags |= _IO_ERR_SEEN, count = 0;
592 }
593 fp->_IO_read_end += count;
594 if (count == 0)
595 {
596 /* If a stream is read to EOF, the calling application may switch active
597 handles. As a result, our offset cache would no longer be valid, so
598 unset it. */
599 fp->_offset = _IO_pos_BAD;
600 return EOF;
601 }
602 if (fp->_offset != _IO_pos_BAD)
603 _IO_pos_adjust (fp->_offset, count);
604 return *(unsigned char *) fp->_IO_read_ptr;
605}
606libc_hidden_ver (_IO_new_file_underflow, _IO_file_underflow)
607
608/* Guts of underflow callback if we mmap the file. This stats the file and
609 updates the stream state to match. In the normal case we return zero.
610 If the file is no longer eligible for mmap, its jump tables are reset to
611 the vanilla ones and we return nonzero. */
612static int
613mmap_remap_check (_IO_FILE *fp)
614{
615 struct stat64 st;
616
617 if (_IO_SYSSTAT (fp, &st) == 0
618 && S_ISREG (st.st_mode) && st.st_size != 0
619 /* Limit the file size to 1MB for 32-bit machines. */
620 && (sizeof (ptrdiff_t) > 4 || st.st_size < 1*1024*1024))
621 {
622 const size_t pagesize = __getpagesize ();
623# define ROUNDED(x) (((x) + pagesize - 1) & ~(pagesize - 1))
624 if (ROUNDED (st.st_size) < ROUNDED (fp->_IO_buf_end
625 - fp->_IO_buf_base))
626 {
627 /* We can trim off some pages past the end of the file. */
628 (void) __munmap (fp->_IO_buf_base + ROUNDED (st.st_size),
629 ROUNDED (fp->_IO_buf_end - fp->_IO_buf_base)
630 - ROUNDED (st.st_size));
631 fp->_IO_buf_end = fp->_IO_buf_base + st.st_size;
632 }
633 else if (ROUNDED (st.st_size) > ROUNDED (fp->_IO_buf_end
634 - fp->_IO_buf_base))
635 {
636 /* The file added some pages. We need to remap it. */
637 void *p;
638#ifdef _G_HAVE_MREMAP
639 p = __mremap (fp->_IO_buf_base, ROUNDED (fp->_IO_buf_end
640 - fp->_IO_buf_base),
641 ROUNDED (st.st_size), MREMAP_MAYMOVE);
642 if (p == MAP_FAILED)
643 {
644 (void) __munmap (fp->_IO_buf_base,
645 fp->_IO_buf_end - fp->_IO_buf_base);
646 goto punt;
647 }
648#else
649 (void) __munmap (fp->_IO_buf_base,
650 fp->_IO_buf_end - fp->_IO_buf_base);
651 p = __mmap64 (NULL, st.st_size, PROT_READ, MAP_SHARED,
652 fp->_fileno, 0);
653 if (p == MAP_FAILED)
654 goto punt;
655#endif
656 fp->_IO_buf_base = p;
657 fp->_IO_buf_end = fp->_IO_buf_base + st.st_size;
658 }
659 else
660 {
661 /* The number of pages didn't change. */
662 fp->_IO_buf_end = fp->_IO_buf_base + st.st_size;
663 }
664# undef ROUNDED
665
666 fp->_offset -= fp->_IO_read_end - fp->_IO_read_ptr;
667 _IO_setg (fp, fp->_IO_buf_base,
668 fp->_offset < fp->_IO_buf_end - fp->_IO_buf_base
669 ? fp->_IO_buf_base + fp->_offset : fp->_IO_buf_end,
670 fp->_IO_buf_end);
671
672 /* If we are already positioned at or past the end of the file, don't
673 change the current offset. If not, seek past what we have mapped,
674 mimicking the position left by a normal underflow reading into its
675 buffer until EOF. */
676
677 if (fp->_offset < fp->_IO_buf_end - fp->_IO_buf_base)
678 {
679 if (__lseek64 (fp->_fileno, fp->_IO_buf_end - fp->_IO_buf_base,
680 SEEK_SET)
681 != fp->_IO_buf_end - fp->_IO_buf_base)
682 fp->_flags |= _IO_ERR_SEEN;
683 else
684 fp->_offset = fp->_IO_buf_end - fp->_IO_buf_base;
685 }
686
687 return 0;
688 }
689 else
690 {
691 /* Life is no longer good for mmap. Punt it. */
692 (void) __munmap (fp->_IO_buf_base,
693 fp->_IO_buf_end - fp->_IO_buf_base);
694 punt:
695 fp->_IO_buf_base = fp->_IO_buf_end = NULL;
696 _IO_setg (fp, NULL, NULL, NULL);
697 if (fp->_mode <= 0)
698 _IO_JUMPS_FILE_plus (fp) = &_IO_file_jumps;
699 else
700 _IO_JUMPS_FILE_plus (fp) = &_IO_wfile_jumps;
701 fp->_wide_data->_wide_vtable = &_IO_wfile_jumps;
702
703 return 1;
704 }
705}
706
707/* Special callback replacing the underflow callbacks if we mmap the file. */
708int
709_IO_file_underflow_mmap (_IO_FILE *fp)
710{
711 if (fp->_IO_read_ptr < fp->_IO_read_end)
712 return *(unsigned char *) fp->_IO_read_ptr;
713
714 if (__glibc_unlikely (mmap_remap_check (fp)))
715 /* We punted to the regular file functions. */
716 return _IO_UNDERFLOW (fp);
717
718 if (fp->_IO_read_ptr < fp->_IO_read_end)
719 return *(unsigned char *) fp->_IO_read_ptr;
720
721 fp->_flags |= _IO_EOF_SEEN;
722 return EOF;
723}
724
725static void
726decide_maybe_mmap (_IO_FILE *fp)
727{
728 /* We use the file in read-only mode. This could mean we can
729 mmap the file and use it without any copying. But not all
730 file descriptors are for mmap-able objects and on 32-bit
731 machines we don't want to map files which are too large since
732 this would require too much virtual memory. */
733 struct stat64 st;
734
735 if (_IO_SYSSTAT (fp, &st) == 0
736 && S_ISREG (st.st_mode) && st.st_size != 0
737 /* Limit the file size to 1MB for 32-bit machines. */
738 && (sizeof (ptrdiff_t) > 4 || st.st_size < 1*1024*1024)
739 /* Sanity check. */
740 && (fp->_offset == _IO_pos_BAD || fp->_offset <= st.st_size))
741 {
742 /* Try to map the file. */
743 void *p;
744
745 p = __mmap64 (NULL, st.st_size, PROT_READ, MAP_SHARED, fp->_fileno, 0);
746 if (p != MAP_FAILED)
747 {
748 /* OK, we managed to map the file. Set the buffer up and use a
749 special jump table with simplified underflow functions which
750 never tries to read anything from the file. */
751
752 if (__lseek64 (fp->_fileno, st.st_size, SEEK_SET) != st.st_size)
753 {
754 (void) __munmap (p, st.st_size);
755 fp->_offset = _IO_pos_BAD;
756 }
757 else
758 {
759 _IO_setb (fp, p, (char *) p + st.st_size, 0);
760
761 if (fp->_offset == _IO_pos_BAD)
762 fp->_offset = 0;
763
764 _IO_setg (fp, p, p + fp->_offset, p + st.st_size);
765 fp->_offset = st.st_size;
766
767 if (fp->_mode <= 0)
768 _IO_JUMPS_FILE_plus (fp) = &_IO_file_jumps_mmap;
769 else
770 _IO_JUMPS_FILE_plus (fp) = &_IO_wfile_jumps_mmap;
771 fp->_wide_data->_wide_vtable = &_IO_wfile_jumps_mmap;
772
773 return;
774 }
775 }
776 }
777
778 /* We couldn't use mmap, so revert to the vanilla file operations. */
779
780 if (fp->_mode <= 0)
781 _IO_JUMPS_FILE_plus (fp) = &_IO_file_jumps;
782 else
783 _IO_JUMPS_FILE_plus (fp) = &_IO_wfile_jumps;
784 fp->_wide_data->_wide_vtable = &_IO_wfile_jumps;
785}
786
787int
788_IO_file_underflow_maybe_mmap (_IO_FILE *fp)
789{
790 /* This is the first read attempt. Choose mmap or vanilla operations
791 and then punt to the chosen underflow routine. */
792 decide_maybe_mmap (fp);
793 return _IO_UNDERFLOW (fp);
794}
795
796
797int
798_IO_new_file_overflow (_IO_FILE *f, int ch)
799{
800 if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
801 {
802 f->_flags |= _IO_ERR_SEEN;
803 __set_errno (EBADF);
804 return EOF;
805 }
806 /* If currently reading or no buffer allocated. */
807 if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL)
808 {
809 /* Allocate a buffer if needed. */
810 if (f->_IO_write_base == NULL)
811 {
812 _IO_doallocbuf (f);
813 _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
814 }
815 /* Otherwise must be currently reading.
816 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
817 logically slide the buffer forwards one block (by setting the
818 read pointers to all point at the beginning of the block). This
819 makes room for subsequent output.
820 Otherwise, set the read pointers to _IO_read_end (leaving that
821 alone, so it can continue to correspond to the external position). */
822 if (__glibc_unlikely (_IO_in_backup (f)))
823 {
824 size_t nbackup = f->_IO_read_end - f->_IO_read_ptr;
825 _IO_free_backup_area (f);
826 f->_IO_read_base -= MIN (nbackup,
827 f->_IO_read_base - f->_IO_buf_base);
828 f->_IO_read_ptr = f->_IO_read_base;
829 }
830
831 if (f->_IO_read_ptr == f->_IO_buf_end)
832 f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
833 f->_IO_write_ptr = f->_IO_read_ptr;
834 f->_IO_write_base = f->_IO_write_ptr;
835 f->_IO_write_end = f->_IO_buf_end;
836 f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
837
838 f->_flags |= _IO_CURRENTLY_PUTTING;
839 if (f->_mode <= 0 && f->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
840 f->_IO_write_end = f->_IO_write_ptr;
841 }
842 if (ch == EOF)
843 return _IO_do_write (f, f->_IO_write_base,
844 f->_IO_write_ptr - f->_IO_write_base);
845 if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
846 if (_IO_do_flush (f) == EOF)
847 return EOF;
848 *f->_IO_write_ptr++ = ch;
849 if ((f->_flags & _IO_UNBUFFERED)
850 || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
851 if (_IO_do_write (f, f->_IO_write_base,
852 f->_IO_write_ptr - f->_IO_write_base) == EOF)
853 return EOF;
854 return (unsigned char) ch;
855}
856libc_hidden_ver (_IO_new_file_overflow, _IO_file_overflow)
857
858int
859_IO_new_file_sync (_IO_FILE *fp)
860{
861 _IO_ssize_t delta;
862 int retval = 0;
863
864 /* char* ptr = cur_ptr(); */
865 if (fp->_IO_write_ptr > fp->_IO_write_base)
866 if (_IO_do_flush(fp)) return EOF;
867 delta = fp->_IO_read_ptr - fp->_IO_read_end;
868 if (delta != 0)
869 {
870#ifdef TODO
871 if (_IO_in_backup (fp))
872 delta -= eGptr () - Gbase ();
873#endif
874 _IO_off64_t new_pos = _IO_SYSSEEK (fp, delta, 1);
875 if (new_pos != (_IO_off64_t) EOF)
876 fp->_IO_read_end = fp->_IO_read_ptr;
877#ifdef ESPIPE
878 else if (errno == ESPIPE)
879 ; /* Ignore error from unseekable devices. */
880#endif
881 else
882 retval = EOF;
883 }
884 if (retval != EOF)
885 fp->_offset = _IO_pos_BAD;
886 /* FIXME: Cleanup - can this be shared? */
887 /* setg(base(), ptr, ptr); */
888 return retval;
889}
890libc_hidden_ver (_IO_new_file_sync, _IO_file_sync)
891
892static int
893_IO_file_sync_mmap (_IO_FILE *fp)
894{
895 if (fp->_IO_read_ptr != fp->_IO_read_end)
896 {
897#ifdef TODO
898 if (_IO_in_backup (fp))
899 delta -= eGptr () - Gbase ();
900#endif
901 if (__lseek64 (fp->_fileno, fp->_IO_read_ptr - fp->_IO_buf_base,
902 SEEK_SET)
903 != fp->_IO_read_ptr - fp->_IO_buf_base)
904 {
905 fp->_flags |= _IO_ERR_SEEN;
906 return EOF;
907 }
908 }
909 fp->_offset = fp->_IO_read_ptr - fp->_IO_buf_base;
910 fp->_IO_read_end = fp->_IO_read_ptr = fp->_IO_read_base;
911 return 0;
912}
913
914/* ftell{,o} implementation. The only time we modify the state of the stream
915 is when we have unflushed writes. In that case we seek to the end and
916 record that offset in the stream object. */
917static _IO_off64_t
918do_ftell (_IO_FILE *fp)
919{
920 _IO_off64_t result, offset = 0;
921
922 /* No point looking at unflushed data if we haven't allocated buffers
923 yet. */
924 if (fp->_IO_buf_base != NULL)
925 {
926 bool unflushed_writes = fp->_IO_write_ptr > fp->_IO_write_base;
927
928 bool append_mode = (fp->_flags & _IO_IS_APPENDING) == _IO_IS_APPENDING;
929
930 /* When we have unflushed writes in append mode, seek to the end of the
931 file and record that offset. This is the only time we change the file
932 stream state and it is safe since the file handle is active. */
933 if (unflushed_writes && append_mode)
934 {
935 result = _IO_SYSSEEK (fp, 0, _IO_seek_end);
936 if (result == _IO_pos_BAD)
937 return EOF;
938 else
939 fp->_offset = result;
940 }
941
942 /* Adjust for unflushed data. */
943 if (!unflushed_writes)
944 offset -= fp->_IO_read_end - fp->_IO_read_ptr;
945 /* We don't trust _IO_read_end to represent the current file offset when
946 writing in append mode because the value would have to be shifted to
947 the end of the file during a flush. Use the write base instead, along
948 with the new offset we got above when we did a seek to the end of the
949 file. */
950 else if (append_mode)
951 offset += fp->_IO_write_ptr - fp->_IO_write_base;
952 /* For all other modes, _IO_read_end represents the file offset. */
953 else
954 offset += fp->_IO_write_ptr - fp->_IO_read_end;
955 }
956
957 if (fp->_offset != _IO_pos_BAD)
958 result = fp->_offset;
959 else
960 result = _IO_SYSSEEK (fp, 0, _IO_seek_cur);
961
962 if (result == EOF)
963 return result;
964
965 result += offset;
966
967 if (result < 0)
968 {
969 __set_errno (EINVAL);
970 return EOF;
971 }
972
973 return result;
974}
975
976_IO_off64_t
977_IO_new_file_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
978{
979 _IO_off64_t result;
980 _IO_off64_t delta, new_offset;
981 long count;
982
983 /* Short-circuit into a separate function. We don't want to mix any
984 functionality and we don't want to touch anything inside the FILE
985 object. */
986 if (mode == 0)
987 return do_ftell (fp);
988
989 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
990 offset of the underlying file must be exact. */
991 int must_be_exact = (fp->_IO_read_base == fp->_IO_read_end
992 && fp->_IO_write_base == fp->_IO_write_ptr);
993
994 bool was_writing = (fp->_IO_write_ptr > fp->_IO_write_base
995 || _IO_in_put_mode (fp));
996
997 /* Flush unwritten characters.
998 (This may do an unneeded write if we seek within the buffer.
999 But to be able to switch to reading, we would need to set
1000 egptr to pptr. That can't be done in the current design,
1001 which assumes file_ptr() is eGptr. Anyway, since we probably
1002 end up flushing when we close(), it doesn't make much difference.)
1003 FIXME: simulate mem-mapped files. */
1004 if (was_writing && _IO_switch_to_get_mode (fp))
1005 return EOF;
1006
1007 if (fp->_IO_buf_base == NULL)
1008 {
1009 /* It could be that we already have a pushback buffer. */
1010 if (fp->_IO_read_base != NULL)
1011 {
1012 free (fp->_IO_read_base);
1013 fp->_flags &= ~_IO_IN_BACKUP;
1014 }
1015 _IO_doallocbuf (fp);
1016 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
1017 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
1018 }
1019
1020 switch (dir)
1021 {
1022 case _IO_seek_cur:
1023 /* Adjust for read-ahead (bytes is buffer). */
1024 offset -= fp->_IO_read_end - fp->_IO_read_ptr;
1025
1026 if (fp->_offset == _IO_pos_BAD)
1027 goto dumb;
1028 /* Make offset absolute, assuming current pointer is file_ptr(). */
1029 offset += fp->_offset;
1030 if (offset < 0)
1031 {
1032 __set_errno (EINVAL);
1033 return EOF;
1034 }
1035
1036 dir = _IO_seek_set;
1037 break;
1038 case _IO_seek_set:
1039 break;
1040 case _IO_seek_end:
1041 {
1042 struct stat64 st;
1043 if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
1044 {
1045 offset += st.st_size;
1046 dir = _IO_seek_set;
1047 }
1048 else
1049 goto dumb;
1050 }
1051 }
1052 /* At this point, dir==_IO_seek_set. */
1053
1054 /* If destination is within current buffer, optimize: */
1055 if (fp->_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
1056 && !_IO_in_backup (fp))
1057 {
1058 _IO_off64_t start_offset = (fp->_offset
1059 - (fp->_IO_read_end - fp->_IO_buf_base));
1060 if (offset >= start_offset && offset < fp->_offset)
1061 {
1062 _IO_setg (fp, fp->_IO_buf_base,
1063 fp->_IO_buf_base + (offset - start_offset),
1064 fp->_IO_read_end);
1065 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
1066
1067 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
1068 goto resync;
1069 }
1070 }
1071
1072 if (fp->_flags & _IO_NO_READS)
1073 goto dumb;
1074
1075 /* Try to seek to a block boundary, to improve kernel page management. */
1076 new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
1077 delta = offset - new_offset;
1078 if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
1079 {
1080 new_offset = offset;
1081 delta = 0;
1082 }
1083 result = _IO_SYSSEEK (fp, new_offset, 0);
1084 if (result < 0)
1085 return EOF;
1086 if (delta == 0)
1087 count = 0;
1088 else
1089 {
1090 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
1091 (must_be_exact
1092 ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
1093 if (count < delta)
1094 {
1095 /* We weren't allowed to read, but try to seek the remainder. */
1096 offset = count == EOF ? delta : delta-count;
1097 dir = _IO_seek_cur;
1098 goto dumb;
1099 }
1100 }
1101 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
1102 fp->_IO_buf_base + count);
1103 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
1104 fp->_offset = result + count;
1105 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
1106 return offset;
1107 dumb:
1108
1109 _IO_unsave_markers (fp);
1110 result = _IO_SYSSEEK (fp, offset, dir);
1111 if (result != EOF)
1112 {
1113 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
1114 fp->_offset = result;
1115 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
1116 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
1117 }
1118 return result;
1119
1120resync:
1121 /* We need to do it since it is possible that the file offset in
1122 the kernel may be changed behind our back. It may happen when
1123 we fopen a file and then do a fork. One process may access the
1124 file and the kernel file offset will be changed. */
1125 if (fp->_offset >= 0)
1126 _IO_SYSSEEK (fp, fp->_offset, 0);
1127
1128 return offset;
1129}
1130libc_hidden_ver (_IO_new_file_seekoff, _IO_file_seekoff)
1131
1132_IO_off64_t
1133_IO_file_seekoff_mmap (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
1134{
1135 _IO_off64_t result;
1136
1137 /* If we are only interested in the current position, calculate it and
1138 return right now. This calculation does the right thing when we are
1139 using a pushback buffer, but in the usual case has the same value as
1140 (fp->_IO_read_ptr - fp->_IO_buf_base). */
1141 if (mode == 0)
1142 return fp->_offset - (fp->_IO_read_end - fp->_IO_read_ptr);
1143
1144 switch (dir)
1145 {
1146 case _IO_seek_cur:
1147 /* Adjust for read-ahead (bytes is buffer). */
1148 offset += fp->_IO_read_ptr - fp->_IO_read_base;
1149 break;
1150 case _IO_seek_set:
1151 break;
1152 case _IO_seek_end:
1153 offset += fp->_IO_buf_end - fp->_IO_buf_base;
1154 break;
1155 }
1156 /* At this point, dir==_IO_seek_set. */
1157
1158 if (offset < 0)
1159 {
1160 /* No negative offsets are valid. */
1161 __set_errno (EINVAL);
1162 return EOF;
1163 }
1164
1165 result = _IO_SYSSEEK (fp, offset, 0);
1166 if (result < 0)
1167 return EOF;
1168
1169 if (offset > fp->_IO_buf_end - fp->_IO_buf_base)
1170 /* One can fseek arbitrarily past the end of the file
1171 and it is meaningless until one attempts to read.
1172 Leave the buffer pointers in EOF state until underflow. */
1173 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_end, fp->_IO_buf_end);
1174 else
1175 /* Adjust the read pointers to match the file position,
1176 but so the next read attempt will call underflow. */
1177 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + offset,
1178 fp->_IO_buf_base + offset);
1179
1180 fp->_offset = result;
1181
1182 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
1183
1184 return offset;
1185}
1186
1187static _IO_off64_t
1188_IO_file_seekoff_maybe_mmap (_IO_FILE *fp, _IO_off64_t offset, int dir,
1189 int mode)
1190{
1191 /* We only get here when we haven't tried to read anything yet.
1192 So there is nothing more useful for us to do here than just
1193 the underlying lseek call. */
1194
1195 _IO_off64_t result = _IO_SYSSEEK (fp, offset, dir);
1196 if (result < 0)
1197 return EOF;
1198
1199 fp->_offset = result;
1200 return result;
1201}
1202
1203_IO_ssize_t
1204_IO_file_read (_IO_FILE *fp, void *buf, _IO_ssize_t size)
1205{
1206 return (__builtin_expect (fp->_flags2 & _IO_FLAGS2_NOTCANCEL, 0)
1207 ? read_not_cancel (fp->_fileno, buf, size)
1208 : read (fp->_fileno, buf, size));
1209}
1210libc_hidden_def (_IO_file_read)
1211
1212_IO_off64_t
1213_IO_file_seek (_IO_FILE *fp, _IO_off64_t offset, int dir)
1214{
1215 return __lseek64 (fp->_fileno, offset, dir);
1216}
1217libc_hidden_def (_IO_file_seek)
1218
1219int
1220_IO_file_stat (_IO_FILE *fp, void *st)
1221{
1222 return __fxstat64 (_STAT_VER, fp->_fileno, (struct stat64 *) st);
1223}
1224libc_hidden_def (_IO_file_stat)
1225
1226int
1227_IO_file_close_mmap (_IO_FILE *fp)
1228{
1229 /* In addition to closing the file descriptor we have to unmap the file. */
1230 (void) __munmap (fp->_IO_buf_base, fp->_IO_buf_end - fp->_IO_buf_base);
1231 fp->_IO_buf_base = fp->_IO_buf_end = NULL;
1232 /* Cancelling close should be avoided if possible since it leaves an
1233 unrecoverable state behind. */
1234 return close_not_cancel (fp->_fileno);
1235}
1236
1237int
1238_IO_file_close (_IO_FILE *fp)
1239{
1240 /* Cancelling close should be avoided if possible since it leaves an
1241 unrecoverable state behind. */
1242 return close_not_cancel (fp->_fileno);
1243}
1244libc_hidden_def (_IO_file_close)
1245
1246_IO_ssize_t
1247_IO_new_file_write (_IO_FILE *f, const void *data, _IO_ssize_t n)
1248{
1249 _IO_ssize_t to_do = n;
1250 while (to_do > 0)
1251 {
1252 _IO_ssize_t count = (__builtin_expect (f->_flags2
1253 & _IO_FLAGS2_NOTCANCEL, 0)
1254 ? write_not_cancel (f->_fileno, data, to_do)
1255 : write (f->_fileno, data, to_do));
1256 if (count < 0)
1257 {
1258 f->_flags |= _IO_ERR_SEEN;
1259 break;
1260 }
1261 to_do -= count;
1262 data = (void *) ((char *) data + count);
1263 }
1264 n -= to_do;
1265 if (f->_offset >= 0)
1266 f->_offset += n;
1267 return n;
1268}
1269
1270_IO_size_t
1271_IO_new_file_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
1272{
1273 const char *s = (const char *) data;
1274 _IO_size_t to_do = n;
1275 int must_flush = 0;
1276 _IO_size_t count = 0;
1277
1278 if (n <= 0)
1279 return 0;
1280 /* This is an optimized implementation.
1281 If the amount to be written straddles a block boundary
1282 (or the filebuf is unbuffered), use sys_write directly. */
1283
1284 /* First figure out how much space is available in the buffer. */
1285 if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
1286 {
1287 count = f->_IO_buf_end - f->_IO_write_ptr;
1288 if (count >= n)
1289 {
1290 const char *p;
1291 for (p = s + n; p > s; )
1292 {
1293 if (*--p == '\n')
1294 {
1295 count = p - s + 1;
1296 must_flush = 1;
1297 break;
1298 }
1299 }
1300 }
1301 }
1302 else if (f->_IO_write_end > f->_IO_write_ptr)
1303 count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
1304
1305 /* Then fill the buffer. */
1306 if (count > 0)
1307 {
1308 if (count > to_do)
1309 count = to_do;
1310#ifdef _LIBC
1311 f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
1312#else
1313 memcpy (f->_IO_write_ptr, s, count);
1314 f->_IO_write_ptr += count;
1315#endif
1316 s += count;
1317 to_do -= count;
1318 }
1319 if (to_do + must_flush > 0)
1320 {
1321 _IO_size_t block_size, do_write;
1322 /* Next flush the (full) buffer. */
1323 if (_IO_OVERFLOW (f, EOF) == EOF)
1324 /* If nothing else has to be written we must not signal the
1325 caller that everything has been written. */
1326 return to_do == 0 ? EOF : n - to_do;
1327
1328 /* Try to maintain alignment: write a whole number of blocks. */
1329 block_size = f->_IO_buf_end - f->_IO_buf_base;
1330 do_write = to_do - (block_size >= 128 ? to_do % block_size : 0);
1331
1332 if (do_write)
1333 {
1334 count = new_do_write (f, s, do_write);
1335 to_do -= count;
1336 if (count < do_write)
1337 return n - to_do;
1338 }
1339
1340 /* Now write out the remainder. Normally, this will fit in the
1341 buffer, but it's somewhat messier for line-buffered files,
1342 so we let _IO_default_xsputn handle the general case. */
1343 if (to_do)
1344 to_do -= _IO_default_xsputn (f, s+do_write, to_do);
1345 }
1346 return n - to_do;
1347}
1348libc_hidden_ver (_IO_new_file_xsputn, _IO_file_xsputn)
1349
1350_IO_size_t
1351_IO_file_xsgetn (_IO_FILE *fp, void *data, _IO_size_t n)
1352{
1353 _IO_size_t want, have;
1354 _IO_ssize_t count;
1355 char *s = data;
1356
1357 want = n;
1358
1359 if (fp->_IO_buf_base == NULL)
1360 {
1361 /* Maybe we already have a push back pointer. */
1362 if (fp->_IO_save_base != NULL)
1363 {
1364 free (fp->_IO_save_base);
1365 fp->_flags &= ~_IO_IN_BACKUP;
1366 }
1367 _IO_doallocbuf (fp);
1368 }
1369
1370 while (want > 0)
1371 {
1372 have = fp->_IO_read_end - fp->_IO_read_ptr;
1373 if (want <= have)
1374 {
1375 memcpy (s, fp->_IO_read_ptr, want);
1376 fp->_IO_read_ptr += want;
1377 want = 0;
1378 }
1379 else
1380 {
1381 if (have > 0)
1382 {
1383#ifdef _LIBC
1384 s = __mempcpy (s, fp->_IO_read_ptr, have);
1385#else
1386 memcpy (s, fp->_IO_read_ptr, have);
1387 s += have;
1388#endif
1389 want -= have;
1390 fp->_IO_read_ptr += have;
1391 }
1392
1393 /* Check for backup and repeat */
1394 if (_IO_in_backup (fp))
1395 {
1396 _IO_switch_to_main_get_area (fp);
1397 continue;
1398 }
1399
1400 /* If we now want less than a buffer, underflow and repeat
1401 the copy. Otherwise, _IO_SYSREAD directly to
1402 the user buffer. */
1403 if (fp->_IO_buf_base
1404 && want < (size_t) (fp->_IO_buf_end - fp->_IO_buf_base))
1405 {
1406 if (__underflow (fp) == EOF)
1407 break;
1408
1409 continue;
1410 }
1411
1412 /* These must be set before the sysread as we might longjmp out
1413 waiting for input. */
1414 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
1415 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
1416
1417 /* Try to maintain alignment: read a whole number of blocks. */
1418 count = want;
1419 if (fp->_IO_buf_base)
1420 {
1421 _IO_size_t block_size = fp->_IO_buf_end - fp->_IO_buf_base;
1422 if (block_size >= 128)
1423 count -= want % block_size;
1424 }
1425
1426 count = _IO_SYSREAD (fp, s, count);
1427 if (count <= 0)
1428 {
1429 if (count == 0)
1430 fp->_flags |= _IO_EOF_SEEN;
1431 else
1432 fp->_flags |= _IO_ERR_SEEN;
1433
1434 break;
1435 }
1436
1437 s += count;
1438 want -= count;
1439 if (fp->_offset != _IO_pos_BAD)
1440 _IO_pos_adjust (fp->_offset, count);
1441 }
1442 }
1443
1444 return n - want;
1445}
1446libc_hidden_def (_IO_file_xsgetn)
1447
1448static _IO_size_t
1449_IO_file_xsgetn_mmap (_IO_FILE *fp, void *data, _IO_size_t n)
1450{
1451 _IO_size_t have;
1452 char *read_ptr = fp->_IO_read_ptr;
1453 char *s = (char *) data;
1454
1455 have = fp->_IO_read_end - fp->_IO_read_ptr;
1456
1457 if (have < n)
1458 {
1459 if (__glibc_unlikely (_IO_in_backup (fp)))
1460 {
1461#ifdef _LIBC
1462 s = __mempcpy (s, read_ptr, have);
1463#else
1464 memcpy (s, read_ptr, have);
1465 s += have;
1466#endif
1467 n -= have;
1468 _IO_switch_to_main_get_area (fp);
1469 read_ptr = fp->_IO_read_ptr;
1470 have = fp->_IO_read_end - fp->_IO_read_ptr;
1471 }
1472
1473 if (have < n)
1474 {
1475 /* Check that we are mapping all of the file, in case it grew. */
1476 if (__glibc_unlikely (mmap_remap_check (fp)))
1477 /* We punted mmap, so complete with the vanilla code. */
1478 return s - (char *) data + _IO_XSGETN (fp, data, n);
1479
1480 read_ptr = fp->_IO_read_ptr;
1481 have = fp->_IO_read_end - read_ptr;
1482 }
1483 }
1484
1485 if (have < n)
1486 fp->_flags |= _IO_EOF_SEEN;
1487
1488 if (have != 0)
1489 {
1490 have = MIN (have, n);
1491#ifdef _LIBC
1492 s = __mempcpy (s, read_ptr, have);
1493#else
1494 memcpy (s, read_ptr, have);
1495 s += have;
1496#endif
1497 fp->_IO_read_ptr = read_ptr + have;
1498 }
1499
1500 return s - (char *) data;
1501}
1502
1503static _IO_size_t
1504_IO_file_xsgetn_maybe_mmap (_IO_FILE *fp, void *data, _IO_size_t n)
1505{
1506 /* We only get here if this is the first attempt to read something.
1507 Decide which operations to use and then punt to the chosen one. */
1508
1509 decide_maybe_mmap (fp);
1510 return _IO_XSGETN (fp, data, n);
1511}
1512
1513#ifdef _LIBC
1514versioned_symbol (libc, _IO_new_do_write, _IO_do_write, GLIBC_2_1);
1515versioned_symbol (libc, _IO_new_file_attach, _IO_file_attach, GLIBC_2_1);
1516versioned_symbol (libc, _IO_new_file_close_it, _IO_file_close_it, GLIBC_2_1);
1517versioned_symbol (libc, _IO_new_file_finish, _IO_file_finish, GLIBC_2_1);
1518versioned_symbol (libc, _IO_new_file_fopen, _IO_file_fopen, GLIBC_2_1);
1519versioned_symbol (libc, _IO_new_file_init, _IO_file_init, GLIBC_2_1);
1520versioned_symbol (libc, _IO_new_file_setbuf, _IO_file_setbuf, GLIBC_2_1);
1521versioned_symbol (libc, _IO_new_file_sync, _IO_file_sync, GLIBC_2_1);
1522versioned_symbol (libc, _IO_new_file_overflow, _IO_file_overflow, GLIBC_2_1);
1523versioned_symbol (libc, _IO_new_file_seekoff, _IO_file_seekoff, GLIBC_2_1);
1524versioned_symbol (libc, _IO_new_file_underflow, _IO_file_underflow, GLIBC_2_1);
1525versioned_symbol (libc, _IO_new_file_write, _IO_file_write, GLIBC_2_1);
1526versioned_symbol (libc, _IO_new_file_xsputn, _IO_file_xsputn, GLIBC_2_1);
1527#endif
1528
1529const struct _IO_jump_t _IO_file_jumps libio_vtable =
1530{
1531 JUMP_INIT_DUMMY,
1532 JUMP_INIT(finish, _IO_file_finish),
1533 JUMP_INIT(overflow, _IO_file_overflow),
1534 JUMP_INIT(underflow, _IO_file_underflow),
1535 JUMP_INIT(uflow, _IO_default_uflow),
1536 JUMP_INIT(pbackfail, _IO_default_pbackfail),
1537 JUMP_INIT(xsputn, _IO_file_xsputn),
1538 JUMP_INIT(xsgetn, _IO_file_xsgetn),
1539 JUMP_INIT(seekoff, _IO_new_file_seekoff),
1540 JUMP_INIT(seekpos, _IO_default_seekpos),
1541 JUMP_INIT(setbuf, _IO_new_file_setbuf),
1542 JUMP_INIT(sync, _IO_new_file_sync),
1543 JUMP_INIT(doallocate, _IO_file_doallocate),
1544 JUMP_INIT(read, _IO_file_read),
1545 JUMP_INIT(write, _IO_new_file_write),
1546 JUMP_INIT(seek, _IO_file_seek),
1547 JUMP_INIT(close, _IO_file_close),
1548 JUMP_INIT(stat, _IO_file_stat),
1549 JUMP_INIT(showmanyc, _IO_default_showmanyc),
1550 JUMP_INIT(imbue, _IO_default_imbue)
1551};
1552libc_hidden_data_def (_IO_file_jumps)
1553
1554const struct _IO_jump_t _IO_file_jumps_mmap libio_vtable =
1555{
1556 JUMP_INIT_DUMMY,
1557 JUMP_INIT(finish, _IO_file_finish),
1558 JUMP_INIT(overflow, _IO_file_overflow),
1559 JUMP_INIT(underflow, _IO_file_underflow_mmap),
1560 JUMP_INIT(uflow, _IO_default_uflow),
1561 JUMP_INIT(pbackfail, _IO_default_pbackfail),
1562 JUMP_INIT(xsputn, _IO_new_file_xsputn),
1563 JUMP_INIT(xsgetn, _IO_file_xsgetn_mmap),
1564 JUMP_INIT(seekoff, _IO_file_seekoff_mmap),
1565 JUMP_INIT(seekpos, _IO_default_seekpos),
1566 JUMP_INIT(setbuf, (_IO_setbuf_t) _IO_file_setbuf_mmap),
1567 JUMP_INIT(sync, _IO_file_sync_mmap),
1568 JUMP_INIT(doallocate, _IO_file_doallocate),
1569 JUMP_INIT(read, _IO_file_read),
1570 JUMP_INIT(write, _IO_new_file_write),
1571 JUMP_INIT(seek, _IO_file_seek),
1572 JUMP_INIT(close, _IO_file_close_mmap),
1573 JUMP_INIT(stat, _IO_file_stat),
1574 JUMP_INIT(showmanyc, _IO_default_showmanyc),
1575 JUMP_INIT(imbue, _IO_default_imbue)
1576};
1577
1578const struct _IO_jump_t _IO_file_jumps_maybe_mmap libio_vtable =
1579{
1580 JUMP_INIT_DUMMY,
1581 JUMP_INIT(finish, _IO_file_finish),
1582 JUMP_INIT(overflow, _IO_file_overflow),
1583 JUMP_INIT(underflow, _IO_file_underflow_maybe_mmap),
1584 JUMP_INIT(uflow, _IO_default_uflow),
1585 JUMP_INIT(pbackfail, _IO_default_pbackfail),
1586 JUMP_INIT(xsputn, _IO_new_file_xsputn),
1587 JUMP_INIT(xsgetn, _IO_file_xsgetn_maybe_mmap),
1588 JUMP_INIT(seekoff, _IO_file_seekoff_maybe_mmap),
1589 JUMP_INIT(seekpos, _IO_default_seekpos),
1590 JUMP_INIT(setbuf, (_IO_setbuf_t) _IO_file_setbuf_mmap),
1591 JUMP_INIT(sync, _IO_new_file_sync),
1592 JUMP_INIT(doallocate, _IO_file_doallocate),
1593 JUMP_INIT(read, _IO_file_read),
1594 JUMP_INIT(write, _IO_new_file_write),
1595 JUMP_INIT(seek, _IO_file_seek),
1596 JUMP_INIT(close, _IO_file_close),
1597 JUMP_INIT(stat, _IO_file_stat),
1598 JUMP_INIT(showmanyc, _IO_default_showmanyc),
1599 JUMP_INIT(imbue, _IO_default_imbue)
1600};
1601