Fix large-file macro usage in bits/statvfs.h
[kopensolaris-gnu/glibc.git] / libio / genops.c
index 4286eef..7005fdb 100644 (file)
@@ -1,27 +1,30 @@
-/* Copyright (C) 1993, 1995, 1997, 1998 Free Software Foundation, Inc.
-   This file is part of the GNU IO Library.
+/* Copyright (C) 1993,1995,1997-2002, 2003, 2004, 2006, 2007
+   Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
 
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License as
-   published by the Free Software Foundation; either version 2, or (at
-   your option) any later version.
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
-   This library is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this library; see the file COPYING.  If not, write to
-   the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-   MA 02111-1307, USA.
-
-   As a special exception, if you link this library with files
-   compiled with a GNU compiler to produce an executable, this does
-   not cause the resulting executable to be covered by the GNU General
-   Public License.  This exception does not however invalidate any
-   other reasons why the executable file might be covered by the GNU
-   General Public License.  */
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.
+
+   As a special exception, if you link the code in this file with
+   files compiled with a GNU compiler to produce an executable,
+   that does not cause the resulting executable to be covered by
+   the GNU Lesser General Public License.  This exception does not
+   however invalidate any other reasons why the executable file
+   might be covered by the GNU Lesser General Public License.
+   This exception applies to code released by its copyright holders
+   in files containing the exception.  */
 
 /* Generic or default I/O operations. */
 
 #include <stdlib.h>
 #endif
 #include <string.h>
+#include <stdbool.h>
+#ifdef _LIBC
+#include <sched.h>
+#endif
+
+#ifdef _IO_MTSAFE_IO
+static _IO_lock_t list_all_lock = _IO_lock_initializer;
+#endif
+
+/* Used to signal modifications to the list of FILE decriptors.  */
+static int _IO_list_all_stamp;
+
+
+static _IO_FILE *run_fp;
+
+static void
+flush_cleanup (void *not_used)
+{
+  if (run_fp != NULL)
+    _IO_funlockfile (run_fp);
+#ifdef _IO_MTSAFE_IO
+  _IO_lock_unlock (list_all_lock);
+#endif
+}
 
 void
 _IO_un_link (fp)
-     _IO_FILE *fp;
+     struct _IO_FILE_plus *fp;
 {
-  if (fp->_flags & _IO_LINKED)
+  if (fp->file._flags & _IO_LINKED)
     {
-      _IO_FILE **f;
-      for (f = &_IO_list_all; *f != NULL; f = &(*f)->_chain)
+      struct _IO_FILE **f;
+#ifdef _IO_MTSAFE_IO
+      _IO_cleanup_region_start_noarg (flush_cleanup);
+      _IO_lock_lock (list_all_lock);
+      run_fp = (_IO_FILE *) fp;
+      _IO_flockfile ((_IO_FILE *) fp);
+#endif
+      if (INTUSE(_IO_list_all) == NULL)
+       ;
+      else if (fp == INTUSE(_IO_list_all))
        {
-         if (*f == fp)
+         INTUSE(_IO_list_all)
+           = (struct _IO_FILE_plus *) INTUSE(_IO_list_all)->file._chain;
+         ++_IO_list_all_stamp;
+       }
+      else
+       for (f = &INTUSE(_IO_list_all)->file._chain; *f; f = &(*f)->_chain)
+         if (*f == (_IO_FILE *) fp)
            {
-             *f = fp->_chain;
+             *f = fp->file._chain;
+             ++_IO_list_all_stamp;
              break;
            }
-       }
-      fp->_flags &= ~_IO_LINKED;
+      fp->file._flags &= ~_IO_LINKED;
+#ifdef _IO_MTSAFE_IO
+      _IO_funlockfile ((_IO_FILE *) fp);
+      run_fp = NULL;
+      _IO_lock_unlock (list_all_lock);
+      _IO_cleanup_region_end (0);
+#endif
     }
 }
+INTDEF(_IO_un_link)
 
 void
 _IO_link_in (fp)
-     _IO_FILE *fp;
+     struct _IO_FILE_plus *fp;
 {
-    if ((fp->_flags & _IO_LINKED) == 0)
-      {
-       fp->_flags |= _IO_LINKED;
-       fp->_chain = _IO_list_all;
-       _IO_list_all = fp;
-      }
+  if ((fp->file._flags & _IO_LINKED) == 0)
+    {
+      fp->file._flags |= _IO_LINKED;
+#ifdef _IO_MTSAFE_IO
+      _IO_cleanup_region_start_noarg (flush_cleanup);
+      _IO_lock_lock (list_all_lock);
+      run_fp = (_IO_FILE *) fp;
+      _IO_flockfile ((_IO_FILE *) fp);
+#endif
+      fp->file._chain = (_IO_FILE *) INTUSE(_IO_list_all);
+      INTUSE(_IO_list_all) = fp;
+      ++_IO_list_all_stamp;
+#ifdef _IO_MTSAFE_IO
+      _IO_funlockfile ((_IO_FILE *) fp);
+      run_fp = NULL;
+      _IO_lock_unlock (list_all_lock);
+      _IO_cleanup_region_end (0);
+#endif
+    }
 }
+INTDEF(_IO_link_in)
 
 /* Return minimum _pos markers
    Assumes the current get area is the main get area. */
-static _IO_size_t _IO_least_marker __P ((_IO_FILE *fp));
+_IO_ssize_t _IO_least_marker (_IO_FILE *fp, char *end_p);
 
-static _IO_size_t
-_IO_least_marker (fp)
+_IO_ssize_t
+_IO_least_marker (fp, end_p)
      _IO_FILE *fp;
+     char *end_p;
 {
-  _IO_ssize_t least_so_far = fp->_IO_read_end - fp->_IO_read_base;
+  _IO_ssize_t least_so_far = end_p - fp->_IO_read_base;
   struct _IO_marker *mark;
   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
     if (mark->_pos < least_so_far)
@@ -94,7 +157,7 @@ _IO_switch_to_main_get_area (fp)
   tmp = fp->_IO_read_base;
   fp->_IO_read_base = fp->_IO_save_base;
   fp->_IO_save_base = tmp;
-
+  /* Set _IO_read_ptr. */
   fp->_IO_read_ptr = fp->_IO_read_base;
 }
 
@@ -110,11 +173,11 @@ _IO_switch_to_backup_area (fp)
   tmp = fp->_IO_read_end;
   fp->_IO_read_end = fp->_IO_save_end;
   fp->_IO_save_end = tmp;
-  /* Swap _gbase and _IO_save_base. */
+  /* Swap _IO_read_base and _IO_save_base. */
   tmp = fp->_IO_read_base;
   fp->_IO_read_base = fp->_IO_save_base;
   fp->_IO_save_base = tmp;
-
+  /* Set _IO_read_ptr.  */
   fp->_IO_read_ptr = fp->_IO_read_end;
 }
 
@@ -140,6 +203,7 @@ _IO_switch_to_get_mode (fp)
   fp->_flags &= ~_IO_CURRENTLY_PUTTING;
   return 0;
 }
+INTDEF(_IO_switch_to_get_mode)
 
 void
 _IO_free_backup_area (fp)
@@ -152,6 +216,7 @@ _IO_free_backup_area (fp)
   fp->_IO_save_end = NULL;
   fp->_IO_backup_base = NULL;
 }
+INTDEF(_IO_free_backup_area)
 
 #if 0
 int
@@ -177,29 +242,35 @@ __overflow (f, ch)
      _IO_FILE *f;
      int ch;
 {
+  /* This is a single-byte stream.  */
+  if (f->_mode == 0)
+    _IO_fwide (f, -1);
   return _IO_OVERFLOW (f, ch);
 }
+libc_hidden_def (__overflow)
 
-static int save_for_backup __P ((_IO_FILE *fp))
+static int save_for_backup (_IO_FILE *fp, char *end_p)
 #ifdef _LIBC
      internal_function
 #endif
      ;
 
-     static int
+static int
 #ifdef _LIBC
-     internal_function
+internal_function
 #endif
-save_for_backup (fp)
+save_for_backup (fp, end_p)
      _IO_FILE *fp;
+     char *end_p;
 {
-  /* Append [_IO_read_base.._IO_read_end] to backup area. */
-  int least_mark = _IO_least_marker (fp);
+  /* Append [_IO_read_base..end_p] to backup area. */
+  _IO_ssize_t least_mark = _IO_least_marker (fp, end_p);
   /* needed_size is how much space we need in the backup area. */
-  int needed_size = (fp->_IO_read_end - fp->_IO_read_base) - least_mark;
-  int current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
-  int avail; /* Extra space available for future expansion. */
-  int delta;
+  _IO_size_t needed_size = (end_p - fp->_IO_read_base) - least_mark;
+  /* FIXME: Dubious arithmetic if pointers are NULL */
+  _IO_size_t current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
+  _IO_size_t avail; /* Extra space available for future expansion. */
+  _IO_ssize_t delta;
   struct _IO_marker *mark;
   if (needed_size > current_Bsize)
     {
@@ -215,14 +286,14 @@ save_for_backup (fp)
                                fp->_IO_save_end + least_mark,
                                -least_mark),
                     fp->_IO_read_base,
-                    fp->_IO_read_end - fp->_IO_read_base);
+                    end_p - fp->_IO_read_base);
 #else
          memcpy (new_buffer + avail,
                  fp->_IO_save_end + least_mark,
                  -least_mark);
          memcpy (new_buffer + avail - least_mark,
                  fp->_IO_read_base,
-                 fp->_IO_read_end - fp->_IO_read_base);
+                 end_p - fp->_IO_read_base);
 #endif
        }
       else
@@ -244,17 +315,16 @@ save_for_backup (fp)
                   -least_mark);
          memcpy (fp->_IO_save_base + avail - least_mark,
                  fp->_IO_read_base,
-                 fp->_IO_read_end - fp->_IO_read_base);
+                 end_p - fp->_IO_read_base);
        }
       else if (needed_size > 0)
        memcpy (fp->_IO_save_base + avail,
                fp->_IO_read_base + least_mark,
                needed_size);
     }
-  /* FIXME: Dubious arithmetic if pointers are NULL */
   fp->_IO_backup_base = fp->_IO_save_base + avail;
   /* Adjust all the streammarkers. */
-  delta = fp->_IO_read_end - fp->_IO_read_base;
+  delta = end_p - fp->_IO_read_base;
   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
     mark->_pos -= delta;
   return 0;
@@ -264,8 +334,15 @@ int
 __underflow (fp)
      _IO_FILE *fp;
 {
+#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
+  if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1)
+    return EOF;
+#endif
+
+  if (fp->_mode == 0)
+    _IO_fwide (fp, -1);
   if (_IO_in_put_mode (fp))
-    if (_IO_switch_to_get_mode (fp) == EOF)
+    if (INTUSE(_IO_switch_to_get_mode) (fp) == EOF)
       return EOF;
   if (fp->_IO_read_ptr < fp->_IO_read_end)
     return *(unsigned char *) fp->_IO_read_ptr;
@@ -277,20 +354,28 @@ __underflow (fp)
     }
   if (_IO_have_markers (fp))
     {
-      if (save_for_backup (fp))
+      if (save_for_backup (fp, fp->_IO_read_end))
        return EOF;
     }
   else if (_IO_have_backup (fp))
-    _IO_free_backup_area (fp);
+    INTUSE(_IO_free_backup_area) (fp);
   return _IO_UNDERFLOW (fp);
 }
+libc_hidden_def (__underflow)
 
 int
 __uflow (fp)
      _IO_FILE *fp;
 {
+#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
+  if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1)
+    return EOF;
+#endif
+
+  if (fp->_mode == 0)
+    _IO_fwide (fp, -1);
   if (_IO_in_put_mode (fp))
-    if (_IO_switch_to_get_mode (fp) == EOF)
+    if (INTUSE(_IO_switch_to_get_mode) (fp) == EOF)
       return EOF;
   if (fp->_IO_read_ptr < fp->_IO_read_end)
     return *(unsigned char *) fp->_IO_read_ptr++;
@@ -302,18 +387,19 @@ __uflow (fp)
     }
   if (_IO_have_markers (fp))
     {
-      if (save_for_backup (fp))
+      if (save_for_backup (fp, fp->_IO_read_end))
        return EOF;
     }
   else if (_IO_have_backup (fp))
-    _IO_free_backup_area (fp);
+    INTUSE(_IO_free_backup_area) (fp);
   return _IO_UFLOW (fp);
 }
+libc_hidden_def (__uflow)
 
 void
 _IO_setb (f, b, eb, a)
      _IO_FILE *f;
-      char *b;
+     char *b;
      char *eb;
      int a;
 {
@@ -326,6 +412,7 @@ _IO_setb (f, b, eb, a)
   else
     f->_flags |= _IO_USER_BUF;
 }
+INTDEF(_IO_setb)
 
 void
 _IO_doallocbuf (fp)
@@ -333,11 +420,12 @@ _IO_doallocbuf (fp)
 {
   if (fp->_IO_buf_base)
     return;
-  if (!(fp->_flags & _IO_UNBUFFERED))
+  if (!(fp->_flags & _IO_UNBUFFERED) || fp->_mode > 0)
     if (_IO_DOALLOCATE (fp) != EOF)
       return;
-  _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
+  INTUSE(_IO_setb) (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
 }
+INTDEF(_IO_doallocbuf)
 
 int
 _IO_default_underflow (fp)
@@ -355,6 +443,7 @@ _IO_default_uflow (fp)
     return EOF;
   return *(unsigned char *) fp->_IO_read_ptr++;
 }
+INTDEF(_IO_default_uflow)
 
 _IO_size_t
 _IO_default_xsputn (f, data, n)
@@ -369,10 +458,10 @@ _IO_default_xsputn (f, data, n)
   for (;;)
     {
       /* Space available. */
-      _IO_ssize_t count = f->_IO_write_end - f->_IO_write_ptr;
-      if (count > 0)
+      if (f->_IO_write_ptr < f->_IO_write_end)
        {
-         if ((_IO_size_t) count > more)
+         _IO_size_t count = f->_IO_write_end - f->_IO_write_ptr;
+         if (count > more)
            count = more;
          if (count > 20)
            {
@@ -384,9 +473,7 @@ _IO_default_xsputn (f, data, n)
 #endif
              s += count;
             }
-         else if (count <= 0)
-           count = 0;
-         else
+         else if (count)
            {
              char *p = f->_IO_write_ptr;
              _IO_ssize_t i;
@@ -396,12 +483,13 @@ _IO_default_xsputn (f, data, n)
             }
          more -= count;
         }
-      if (more == 0 || __overflow (f, (unsigned char) *s++) == EOF)
+      if (more == 0 || _IO_OVERFLOW (f, (unsigned char) *s++) == EOF)
        break;
       more--;
     }
   return n - more;
 }
+INTDEF(_IO_default_xsputn)
 
 _IO_size_t
 _IO_sgetn (fp, data, n)
@@ -412,6 +500,7 @@ _IO_sgetn (fp, data, n)
   /* FIXME handle putback buffer here! */
   return _IO_XSGETN (fp, data, n);
 }
+INTDEF(_IO_sgetn)
 
 _IO_size_t
 _IO_default_xsgetn (fp, data, n)
@@ -424,10 +513,10 @@ _IO_default_xsgetn (fp, data, n)
   for (;;)
     {
       /* Data available. */
-      _IO_ssize_t count = fp->_IO_read_end - fp->_IO_read_ptr;
-      if (count > 0)
+      if (fp->_IO_read_ptr < fp->_IO_read_end)
        {
-         if ((_IO_size_t) count > more)
+         _IO_size_t count = fp->_IO_read_end - fp->_IO_read_ptr;
+         if (count > more)
            count = more;
          if (count > 20)
            {
@@ -439,9 +528,7 @@ _IO_default_xsgetn (fp, data, n)
 #endif
              fp->_IO_read_ptr += count;
            }
-         else if (count <= 0)
-           count = 0;
-         else
+         else if (count)
            {
              char *p = fp->_IO_read_ptr;
              int i = (int) count;
@@ -456,6 +543,7 @@ _IO_default_xsgetn (fp, data, n)
     }
   return n - more;
 }
+INTDEF(_IO_default_xsgetn)
 
 #if 0
 /* Seems not to be needed. --drepper */
@@ -478,25 +566,25 @@ _IO_default_setbuf (fp, p, len)
     if (p == NULL || len == 0)
       {
        fp->_flags |= _IO_UNBUFFERED;
-       _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
+       INTUSE(_IO_setb) (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
       }
     else
       {
        fp->_flags &= ~_IO_UNBUFFERED;
-       _IO_setb (fp, p, p+len, 0);
+       INTUSE(_IO_setb) (fp, p, p+len, 0);
       }
     fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = 0;
     fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end = 0;
     return fp;
 }
 
-_IO_fpos64_t
+_IO_off64_t
 _IO_default_seekpos (fp, pos, mode)
      _IO_FILE *fp;
-     _IO_fpos64_t pos;
+     _IO_off64_t pos;
      int mode;
 {
-  return _IO_SEEKOFF (fp, _IO_pos_as_off (pos), 0, mode);
+  return _IO_SEEKOFF (fp, pos, 0, mode);
 }
 
 int
@@ -506,16 +594,27 @@ _IO_default_doallocate (fp)
   char *buf;
 
   ALLOC_BUF (buf, _IO_BUFSIZ, EOF);
-  _IO_setb (fp, buf, buf+_IO_BUFSIZ, 1);
+  INTUSE(_IO_setb) (fp, buf, buf+_IO_BUFSIZ, 1);
   return 1;
 }
+INTDEF(_IO_default_doallocate)
 
 void
 _IO_init (fp, flags)
      _IO_FILE *fp;
      int flags;
 {
+  _IO_no_init (fp, flags, -1, NULL, NULL);
+}
+INTDEF(_IO_init)
+
+void
+_IO_old_init (fp, flags)
+     _IO_FILE *fp;
+     int flags;
+{
   fp->_flags = _IO_MAGIC|flags;
+  fp->_flags2 = 0;
   fp->_IO_buf_base = NULL;
   fp->_IO_buf_end = NULL;
   fp->_IO_read_base = NULL;
@@ -535,8 +634,41 @@ _IO_init (fp, flags)
   fp->_vtable_offset = 0;
 #endif
 #ifdef _IO_MTSAFE_IO
-  _IO_lock_init (*fp->_lock);
+  if (fp->_lock != NULL)
+    _IO_lock_init (*fp->_lock);
+#endif
+}
+
+void
+_IO_no_init (fp, flags, orientation, wd, jmp)
+     _IO_FILE *fp;
+     int flags;
+     int orientation;
+     struct _IO_wide_data *wd;
+     const struct _IO_jump_t *jmp;
+{
+  _IO_old_init (fp, flags);
+  fp->_mode = orientation;
+#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
+  if (orientation >= 0)
+    {
+      fp->_wide_data = wd;
+      fp->_wide_data->_IO_buf_base = NULL;
+      fp->_wide_data->_IO_buf_end = NULL;
+      fp->_wide_data->_IO_read_base = NULL;
+      fp->_wide_data->_IO_read_ptr = NULL;
+      fp->_wide_data->_IO_read_end = NULL;
+      fp->_wide_data->_IO_write_base = NULL;
+      fp->_wide_data->_IO_write_ptr = NULL;
+      fp->_wide_data->_IO_write_end = NULL;
+      fp->_wide_data->_IO_save_base = NULL;
+      fp->_wide_data->_IO_backup_base = NULL;
+      fp->_wide_data->_IO_save_end = NULL;
+
+      fp->_wide_data->_wide_vtable = jmp;
+    }
 #endif
+  fp->_freeres_list = NULL;
 }
 
 int
@@ -570,21 +702,23 @@ _IO_default_finish (fp, dummy)
       fp->_IO_save_base = NULL;
     }
 
+  INTUSE(_IO_un_link) ((struct _IO_FILE_plus *) fp);
+
 #ifdef _IO_MTSAFE_IO
-  _IO_lock_fini (*fp->_lock);
+  if (fp->_lock != NULL)
+    _IO_lock_fini (*fp->_lock);
 #endif
-
-  _IO_un_link (fp);
 }
+INTDEF(_IO_default_finish)
 
-_IO_fpos64_t
+_IO_off64_t
 _IO_default_seekoff (fp, offset, dir, mode)
      _IO_FILE *fp;
      _IO_off64_t offset;
      int dir;
      int mode;
 {
-    return _IO_pos_BAD;
+  return _IO_pos_BAD;
 }
 
 int
@@ -608,6 +742,7 @@ _IO_sputbackc (fp, c)
 
   return result;
 }
+INTDEF(_IO_sputbackc)
 
 int
 _IO_sungetc (fp)
@@ -667,6 +802,7 @@ _IO_adjust_column (start, line, count)
       return line + count - ptr - 1;
   return start + count;
 }
+INTDEF(_IO_adjust_column)
 
 #if 0
 /* Seems not to be needed. --drepper */
@@ -682,42 +818,197 @@ _IO_get_column (fp)
 }
 #endif
 
+
 int
-_IO_flush_all ()
+_IO_flush_all_lockp (int do_lock)
 {
   int result = 0;
-  _IO_FILE *fp;
-  for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
-    if (fp->_IO_write_ptr > fp->_IO_write_base
-       && _IO_OVERFLOW (fp, EOF) == EOF)
-      result = EOF;
+  struct _IO_FILE *fp;
+  int last_stamp;
+
+#ifdef _IO_MTSAFE_IO
+  _IO_cleanup_region_start_noarg (flush_cleanup);
+  if (do_lock)
+    _IO_lock_lock (list_all_lock);
+#endif
+
+  last_stamp = _IO_list_all_stamp;
+  fp = (_IO_FILE *) INTUSE(_IO_list_all);
+  while (fp != NULL)
+    {
+      run_fp = fp;
+      if (do_lock)
+       _IO_flockfile (fp);
+
+      if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
+#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
+          || (_IO_vtable_offset (fp) == 0
+              && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
+                                   > fp->_wide_data->_IO_write_base))
+#endif
+          )
+         && _IO_OVERFLOW (fp, EOF) == EOF)
+       result = EOF;
+
+      if (do_lock)
+       _IO_funlockfile (fp);
+      run_fp = NULL;
+
+      if (last_stamp != _IO_list_all_stamp)
+       {
+         /* Something was added to the list.  Start all over again.  */
+         fp = (_IO_FILE *) INTUSE(_IO_list_all);
+         last_stamp = _IO_list_all_stamp;
+       }
+      else
+       fp = fp->_chain;
+    }
+
+#ifdef _IO_MTSAFE_IO
+  if (do_lock)
+    _IO_lock_unlock (list_all_lock);
+  _IO_cleanup_region_end (0);
+#endif
+
   return result;
 }
 
+
+int
+_IO_flush_all ()
+{
+  /* We want locking.  */
+  return _IO_flush_all_lockp (1);
+}
+INTDEF(_IO_flush_all)
+
 void
 _IO_flush_all_linebuffered ()
 {
-  _IO_FILE *fp;
-  for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
-    if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF)
-      _IO_OVERFLOW (fp, EOF);
+  struct _IO_FILE *fp;
+  int last_stamp;
+
+#ifdef _IO_MTSAFE_IO
+  _IO_cleanup_region_start_noarg (flush_cleanup);
+  _IO_lock_lock (list_all_lock);
+#endif
+
+  last_stamp = _IO_list_all_stamp;
+  fp = (_IO_FILE *) INTUSE(_IO_list_all);
+  while (fp != NULL)
+    {
+      run_fp = fp;
+      _IO_flockfile (fp);
+
+      if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF)
+       _IO_OVERFLOW (fp, EOF);
+
+      _IO_funlockfile (fp);
+      run_fp = NULL;
+
+      if (last_stamp != _IO_list_all_stamp)
+       {
+         /* Something was added to the list.  Start all over again.  */
+         fp = (_IO_FILE *) INTUSE(_IO_list_all);
+         last_stamp = _IO_list_all_stamp;
+       }
+      else
+       fp = fp->_chain;
+    }
+
+#ifdef _IO_MTSAFE_IO
+  _IO_lock_unlock (list_all_lock);
+  _IO_cleanup_region_end (0);
+#endif
 }
+INTDEF(_IO_flush_all_linebuffered)
+#ifdef _LIBC
+weak_alias (_IO_flush_all_linebuffered, _flushlbf)
+#endif
+
 
-static void _IO_unbuffer_all __P ((void));
+/* The following is a bit tricky.  In general, we want to unbuffer the
+   streams so that all output which follows is seen.  If we are not
+   looking for memory leaks it does not make much sense to free the
+   actual buffer because this will happen anyway once the program
+   terminated.  If we do want to look for memory leaks we have to free
+   the buffers.  Whether something is freed is determined by the
+   function sin the libc_freeres section.  Those are called as part of
+   the atexit routine, just like _IO_cleanup.  The problem is we do
+   not know whether the freeres code is called first or _IO_cleanup.
+   if the former is the case, we set the DEALLOC_BUFFER variable to
+   true and _IO_unbuffer_write will take care of the rest.  If
+   _IO_unbuffer_write is called first we add the streams to a list
+   which the freeres function later can walk through.  */
+static void _IO_unbuffer_write (void);
+
+static bool dealloc_buffers;
+static _IO_FILE *freeres_list;
 
 static void
-_IO_unbuffer_all ()
+_IO_unbuffer_write (void)
 {
-  _IO_FILE *fp;
-  for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
-    if (! (fp->_flags & _IO_UNBUFFERED))
-      _IO_SETBUF (fp, NULL, 0);
+  struct _IO_FILE *fp;
+  for (fp = (_IO_FILE *) INTUSE(_IO_list_all); fp; fp = fp->_chain)
+    {
+      if (! (fp->_flags & _IO_UNBUFFERED)
+         && (! (fp->_flags & _IO_NO_WRITES)
+             || (fp->_flags & _IO_IS_APPENDING))
+         /* Iff stream is un-orientated, it wasn't used. */
+         && fp->_mode != 0)
+       {
+         int cnt;
+#define MAXTRIES 2
+         for (cnt = 0; cnt < MAXTRIES; ++cnt)
+           if (_IO_lock_trylock (*fp->_lock) == 0)
+             break;
+           else
+             /* Give the other thread time to finish up its use of the
+                stream.  */
+             __sched_yield ();
+
+         if (! dealloc_buffers && !(fp->_flags & _IO_USER_BUF))
+           {
+             fp->_flags |= _IO_USER_BUF;
+
+             fp->_freeres_list = freeres_list;
+             freeres_list = fp;
+             fp->_freeres_buf = fp->_IO_buf_base;
+             fp->_freeres_size = _IO_blen (fp);
+           }
+
+         _IO_SETBUF (fp, NULL, 0);
+
+         if (cnt < MAXTRIES)
+           _IO_lock_unlock (*fp->_lock);
+       }
+
+      /* Make sure that never again the wide char functions can be
+        used.  */
+      fp->_mode = -1;
+    }
 }
 
+
+libc_freeres_fn (buffer_free)
+{
+  dealloc_buffers = true;
+
+  while (freeres_list != NULL)
+    {
+      FREE_BUF (freeres_list->_freeres_buf, freeres_list->_freeres_size);
+
+      freeres_list = freeres_list->_freeres_list;
+    }
+}
+
+
 int
 _IO_cleanup ()
 {
-  int result = _IO_flush_all ();
+  /* We do *not* want locking.  Some threads might use streams but
+     that is their problem, we flush them underneath them.  */
+  int result = _IO_flush_all_lockp (0);
 
   /* We currently don't have a reliable mechanism for making sure that
      C++ static destructors are executed in the correct order.
@@ -726,7 +1017,7 @@ _IO_cleanup ()
 
      The following will make the standard streambufs be unbuffered,
      which forces any output from late destructors to be written out. */
-  _IO_unbuffer_all ();
+  _IO_unbuffer_write ();
 
   return result;
 }
@@ -739,7 +1030,7 @@ _IO_init_marker (marker, fp)
 {
   marker->_sbuf = fp;
   if (_IO_in_put_mode (fp))
-    _IO_switch_to_get_mode (fp);
+    INTUSE(_IO_switch_to_get_mode) (fp);
   if (_IO_in_backup (fp))
     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end;
   else
@@ -845,8 +1136,9 @@ _IO_unsave_markers (fp)
     }
 
   if (_IO_have_backup (fp))
-    _IO_free_backup_area (fp);
+    INTUSE(_IO_free_backup_area) (fp);
 }
+INTDEF(_IO_unsave_markers)
 
 #if 0
 /* Seems not to be needed. --drepper */
@@ -868,23 +1160,34 @@ _IO_default_pbackfail (fp, c)
      _IO_FILE *fp;
      int c;
 {
-  if (fp->_IO_read_ptr <= fp->_IO_read_base)
+  if (fp->_IO_read_ptr > fp->_IO_read_base && !_IO_in_backup (fp)
+      && (unsigned char) fp->_IO_read_ptr[-1] == c)
+    --fp->_IO_read_ptr;
+  else
     {
       /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
-      if (_IO_have_backup (fp) && !_IO_in_backup (fp))
-       _IO_switch_to_backup_area (fp);
-
-      if (!_IO_have_backup (fp))
+      if (!_IO_in_backup (fp))
        {
-         /* No backup buffer: allocate one. */
-         /* Use nshort buffer, if unused? (probably not)  FIXME */
-         int backup_size = 128;
-         char *bbuf = (char *) malloc (backup_size);
-         if (bbuf == NULL)
-           return EOF;
-         fp->_IO_save_base = bbuf;
-         fp->_IO_save_end = fp->_IO_save_base + backup_size;
-         fp->_IO_backup_base = fp->_IO_save_end;
+         /* We need to keep the invariant that the main get area
+            logically follows the backup area.  */
+         if (fp->_IO_read_ptr > fp->_IO_read_base && _IO_have_backup (fp))
+           {
+             if (save_for_backup (fp, fp->_IO_read_ptr))
+               return EOF;
+           }
+         else if (!_IO_have_backup (fp))
+           {
+             /* No backup buffer: allocate one. */
+             /* Use nshort buffer, if unused? (probably not)  FIXME */
+             int backup_size = 128;
+             char *bbuf = (char *) malloc (backup_size);
+             if (bbuf == NULL)
+               return EOF;
+             fp->_IO_save_base = bbuf;
+             fp->_IO_save_end = fp->_IO_save_base + backup_size;
+             fp->_IO_backup_base = fp->_IO_save_end;
+           }
+         fp->_IO_read_base = fp->_IO_read_ptr;
          _IO_switch_to_backup_area (fp);
        }
       else if (fp->_IO_read_ptr <= fp->_IO_read_base)
@@ -904,14 +1207,14 @@ _IO_default_pbackfail (fp, c)
                    new_buf + new_size);
          fp->_IO_backup_base = fp->_IO_read_ptr;
        }
+
+      *--fp->_IO_read_ptr = c;
     }
-  --fp->_IO_read_ptr;
-  if (c != EOF && *fp->_IO_read_ptr != c)
-    *fp->_IO_read_ptr = c;
-  return (unsigned char) *fp->_IO_read_ptr;
+  return (unsigned char) c;
 }
+INTDEF(_IO_default_pbackfail)
 
-_IO_fpos64_t
+_IO_off64_t
 _IO_default_seek (fp, offset, dir)
      _IO_FILE *fp;
      _IO_off64_t offset;
@@ -960,6 +1263,63 @@ _IO_default_imbue (fp, locale)
 {
 }
 
+_IO_ITER
+_IO_iter_begin()
+{
+  return (_IO_ITER) INTUSE(_IO_list_all);
+}
+libc_hidden_def (_IO_iter_begin)
+
+_IO_ITER
+_IO_iter_end()
+{
+  return NULL;
+}
+libc_hidden_def (_IO_iter_end)
+
+_IO_ITER
+_IO_iter_next(iter)
+    _IO_ITER iter;
+{
+  return iter->_chain;
+}
+libc_hidden_def (_IO_iter_next)
+
+_IO_FILE *
+_IO_iter_file(iter)
+    _IO_ITER iter;
+{
+  return iter;
+}
+libc_hidden_def (_IO_iter_file)
+
+void
+_IO_list_lock()
+{
+#ifdef _IO_MTSAFE_IO
+  _IO_lock_lock (list_all_lock);
+#endif
+}
+libc_hidden_def (_IO_list_lock)
+
+void
+_IO_list_unlock()
+{
+#ifdef _IO_MTSAFE_IO
+  _IO_lock_unlock (list_all_lock);
+#endif
+}
+libc_hidden_def (_IO_list_unlock)
+
+void
+_IO_list_resetlock()
+{
+#ifdef _IO_MTSAFE_IO
+  _IO_lock_init (list_all_lock);
+#endif
+}
+libc_hidden_def (_IO_list_resetlock)
+
 
 #ifdef TODO
 #if defined(linux)
@@ -978,10 +1338,6 @@ __io_defs io_defs__;
 
 #endif /* TODO */
 
-#ifdef weak_alias
-weak_alias (_IO_cleanup, _cleanup)
-#endif
-
 #ifdef text_set_element
-text_set_element(__libc_atexit, _cleanup);
+text_set_element(__libc_atexit, _IO_cleanup);
 #endif