Fix large-file macro usage in bits/statvfs.h
[kopensolaris-gnu/glibc.git] / libio / genops.c
index 82c1c44..7005fdb 100644 (file)
@@ -1,27 +1,30 @@
-/* Copyright (C) 1993, 1995, 1997-1999, 2000 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)
      struct _IO_FILE_plus *fp;
 {
   if (fp->file._flags & _IO_LINKED)
     {
-      struct _IO_FILE_plus **f;
+      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
-      for (f = &_IO_list_all; *f; f = (struct _IO_FILE_plus **) &(*f)->file._chain)
+      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 = (struct _IO_FILE_plus *) fp->file._chain;
+             *f = fp->file._chain;
+             ++_IO_list_all_stamp;
              break;
            }
-       }
+      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
-      fp->file._flags &= ~_IO_LINKED;
     }
 }
+INTDEF(_IO_un_link)
 
 void
 _IO_link_in (fp)
      struct _IO_FILE_plus *fp;
 {
-    if ((fp->file._flags & _IO_LINKED) == 0)
-      {
-       fp->file._flags |= _IO_LINKED;
+  if ((fp->file._flags & _IO_LINKED) == 0)
+    {
+      fp->file._flags |= _IO_LINKED;
 #ifdef _IO_MTSAFE_IO
-       _IO_lock_lock (list_all_lock);
+      _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 *) _IO_list_all;
-       _IO_list_all = fp;
+      fp->file._chain = (_IO_FILE *) INTUSE(_IO_list_all);
+      INTUSE(_IO_list_all) = fp;
+      ++_IO_list_all_stamp;
 #ifdef _IO_MTSAFE_IO
-       _IO_lock_unlock (list_all_lock);
+      _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. */
-_IO_ssize_t _IO_least_marker __P ((_IO_FILE *fp, char *end_p));
+_IO_ssize_t _IO_least_marker (_IO_FILE *fp, char *end_p);
 
 _IO_ssize_t
 _IO_least_marker (fp, end_p)
@@ -157,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)
@@ -169,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
@@ -199,8 +247,9 @@ __overflow (f, ch)
     _IO_fwide (f, -1);
   return _IO_OVERFLOW (f, ch);
 }
+libc_hidden_def (__overflow)
 
-static int save_for_backup __P ((_IO_FILE *fp, char *end_p))
+static int save_for_backup (_IO_FILE *fp, char *end_p)
 #ifdef _LIBC
      internal_function
 #endif
@@ -285,13 +334,15 @@ int
 __underflow (fp)
      _IO_FILE *fp;
 {
-  if (fp->_vtable_offset == 0 && _IO_fwide (fp, -1) != -1)
+#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;
@@ -307,21 +358,24 @@ __underflow (fp)
        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 (fp->_vtable_offset == 0 && _IO_fwide (fp, -1) != -1)
+#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, -11);
+    _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++;
@@ -337,14 +391,15 @@ __uflow (fp)
        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;
 {
@@ -357,6 +412,7 @@ _IO_setb (f, b, eb, a)
   else
     f->_flags |= _IO_USER_BUF;
 }
+INTDEF(_IO_setb)
 
 void
 _IO_doallocbuf (fp)
@@ -364,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)
@@ -386,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)
@@ -400,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)
            {
@@ -415,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;
@@ -433,6 +489,7 @@ _IO_default_xsputn (f, data, n)
     }
   return n - more;
 }
+INTDEF(_IO_default_xsputn)
 
 _IO_size_t
 _IO_sgetn (fp, data, n)
@@ -443,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)
@@ -455,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)
            {
@@ -470,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;
@@ -487,6 +543,7 @@ _IO_default_xsgetn (fp, data, n)
     }
   return n - more;
 }
+INTDEF(_IO_default_xsgetn)
 
 #if 0
 /* Seems not to be needed. --drepper */
@@ -509,12 +566,12 @@ _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;
@@ -537,9 +594,10 @@ _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)
@@ -548,16 +606,15 @@ _IO_init (fp, flags)
 {
   _IO_no_init (fp, flags, -1, NULL, NULL);
 }
+INTDEF(_IO_init)
 
 void
-_IO_no_init (fp, flags, orientation, wd, jmp)
+_IO_old_init (fp, flags)
      _IO_FILE *fp;
      int flags;
-     int orientation;
-     struct _IO_wide_data *wd;
-     struct _IO_jump_t *jmp;
 {
   fp->_flags = _IO_MAGIC|flags;
+  fp->_flags2 = 0;
   fp->_IO_buf_base = NULL;
   fp->_IO_buf_end = NULL;
   fp->_IO_read_base = NULL;
@@ -577,9 +634,22 @@ _IO_no_init (fp, flags, orientation, wd, jmp)
   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;
@@ -597,6 +667,8 @@ _IO_no_init (fp, flags, orientation, wd, jmp)
 
       fp->_wide_data->_wide_vtable = jmp;
     }
+#endif
+  fp->_freeres_list = NULL;
 }
 
 int
@@ -630,12 +702,14 @@ _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 ((struct _IO_FILE_plus *) fp);
 }
+INTDEF(_IO_default_finish)
 
 _IO_off64_t
 _IO_default_seekoff (fp, offset, dir, mode)
@@ -644,7 +718,7 @@ _IO_default_seekoff (fp, offset, dir, mode)
      int dir;
      int mode;
 {
-    return _IO_pos_BAD;
+  return _IO_pos_BAD;
 }
 
 int
@@ -668,6 +742,7 @@ _IO_sputbackc (fp, c)
 
   return result;
 }
+INTDEF(_IO_sputbackc)
 
 int
 _IO_sungetc (fp)
@@ -727,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 */
@@ -742,47 +818,197 @@ _IO_get_column (fp)
 }
 #endif
 
+
 int
-_IO_flush_all ()
+_IO_flush_all_lockp (int do_lock)
 {
   int result = 0;
   struct _IO_FILE *fp;
-  for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
-    if (((fp->_mode < 0 && fp->_IO_write_ptr > fp->_IO_write_base)
-        || (fp->_vtable_offset == 0
-            && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
-                                 > fp->_wide_data->_IO_write_base)))
-       && _IO_OVERFLOW (fp, EOF) == EOF)
-      result = EOF;
+  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 ()
 {
   struct _IO_FILE *fp;
-  for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
-    if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF)
-      _IO_OVERFLOW (fp, EOF);
+  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_write __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_write ()
+_IO_unbuffer_write (void)
 {
   struct _IO_FILE *fp;
-  for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
-    if (! (fp->_flags & _IO_UNBUFFERED)
-       && (! (fp->_flags & _IO_NO_WRITES)
-           || (fp->_flags & _IO_IS_APPENDING)))
-      _IO_SETBUF (fp, NULL, 0);
+  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.
@@ -804,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
@@ -910,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 */
@@ -985,6 +1212,7 @@ _IO_default_pbackfail (fp, c)
     }
   return (unsigned char) c;
 }
+INTDEF(_IO_default_pbackfail)
 
 _IO_off64_t
 _IO_default_seek (fp, offset, dir)
@@ -1038,14 +1266,16 @@ _IO_default_imbue (fp, locale)
 _IO_ITER
 _IO_iter_begin()
 {
-  return (_IO_ITER) _IO_list_all;
+  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)
@@ -1053,6 +1283,7 @@ _IO_iter_next(iter)
 {
   return iter->_chain;
 }
+libc_hidden_def (_IO_iter_next)
 
 _IO_FILE *
 _IO_iter_file(iter)
@@ -1060,6 +1291,7 @@ _IO_iter_file(iter)
 {
   return iter;
 }
+libc_hidden_def (_IO_iter_file)
 
 void
 _IO_list_lock()
@@ -1068,6 +1300,7 @@ _IO_list_lock()
   _IO_lock_lock (list_all_lock);
 #endif
 }
+libc_hidden_def (_IO_list_lock)
 
 void
 _IO_list_unlock()
@@ -1076,6 +1309,7 @@ _IO_list_unlock()
   _IO_lock_unlock (list_all_lock);
 #endif
 }
+libc_hidden_def (_IO_list_unlock)
 
 void
 _IO_list_resetlock()
@@ -1084,6 +1318,7 @@ _IO_list_resetlock()
   _IO_lock_init (list_all_lock);
 #endif
 }
+libc_hidden_def (_IO_list_resetlock)
 
 
 #ifdef TODO
@@ -1103,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