Fix large-file macro usage in bits/statvfs.h
[kopensolaris-gnu/glibc.git] / libio / genops.c
index 5f16894..7005fdb 100644 (file)
@@ -1,4 +1,5 @@
-/* Copyright (C) 1993,1995,1997-2001,2002 Free Software Foundation, Inc.
+/* Copyright (C) 1993,1995,1997-2002, 2003, 2004, 2006, 2007
+   Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
 #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;
@@ -59,23 +64,29 @@ _IO_un_link (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 = &INTUSE(_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);
@@ -115,7 +126,7 @@ 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)
@@ -236,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
@@ -323,7 +335,7 @@ __underflow (fp)
      _IO_FILE *fp;
 {
 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
-  if (fp->_vtable_offset == 0 && _IO_fwide (fp, -1) != -1)
+  if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1)
     return EOF;
 #endif
 
@@ -349,18 +361,19 @@ __underflow (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 (fp->_vtable_offset == 0 && _IO_fwide (fp, -1) != -1)
+  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 (INTUSE(_IO_switch_to_get_mode) (fp) == EOF)
       return EOF;
@@ -381,11 +394,12 @@ __uflow (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;
 {
@@ -444,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)
            {
@@ -459,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;
@@ -501,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)
            {
@@ -516,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;
@@ -599,14 +609,12 @@ _IO_init (fp, flags)
 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;
@@ -629,6 +637,17 @@ _IO_no_init (fp, flags, orientation, wd, jmp)
   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)
@@ -649,6 +668,7 @@ _IO_no_init (fp, flags, orientation, wd, jmp)
       fp->_wide_data->_wide_vtable = jmp;
     }
 #endif
+  fp->_freeres_list = NULL;
 }
 
 int
@@ -682,12 +702,12 @@ _IO_default_finish (fp, dummy)
       fp->_IO_save_base = NULL;
     }
 
+  INTUSE(_IO_un_link) ((struct _IO_FILE_plus *) fp);
+
 #ifdef _IO_MTSAFE_IO
   if (fp->_lock != NULL)
     _IO_lock_fini (*fp->_lock);
 #endif
-
-  INTUSE(_IO_un_link) ((struct _IO_FILE_plus *) fp);
 }
 INTDEF(_IO_default_finish)
 
@@ -822,7 +842,7 @@ _IO_flush_all_lockp (int do_lock)
 
       if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
-          || (fp->_vtable_offset == 0
+          || (_IO_vtable_offset (fp) == 0
               && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
                                    > fp->_wide_data->_IO_write_base))
 #endif
@@ -906,10 +926,27 @@ INTDEF(_IO_flush_all_linebuffered)
 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 *) INTUSE(_IO_list_all); fp; fp = fp->_chain)
@@ -919,7 +956,32 @@ _IO_unbuffer_write ()
              || (fp->_flags & _IO_IS_APPENDING))
          /* Iff stream is un-orientated, it wasn't used. */
          && fp->_mode != 0)
-       _IO_SETBUF (fp, NULL, 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.  */
@@ -927,10 +989,26 @@ _IO_unbuffer_write ()
     }
 }
 
+
+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 = INTUSE(_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.
@@ -1190,12 +1268,14 @@ _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)
@@ -1203,6 +1283,7 @@ _IO_iter_next(iter)
 {
   return iter->_chain;
 }
+libc_hidden_def (_IO_iter_next)
 
 _IO_FILE *
 _IO_iter_file(iter)
@@ -1210,6 +1291,7 @@ _IO_iter_file(iter)
 {
   return iter;
 }
+libc_hidden_def (_IO_iter_file)
 
 void
 _IO_list_lock()
@@ -1218,6 +1300,7 @@ _IO_list_lock()
   _IO_lock_lock (list_all_lock);
 #endif
 }
+libc_hidden_def (_IO_list_lock)
 
 void
 _IO_list_unlock()
@@ -1226,6 +1309,7 @@ _IO_list_unlock()
   _IO_lock_unlock (list_all_lock);
 #endif
 }
+libc_hidden_def (_IO_list_unlock)
 
 void
 _IO_list_resetlock()
@@ -1234,6 +1318,7 @@ _IO_list_resetlock()
   _IO_lock_init (list_all_lock);
 #endif
 }
+libc_hidden_def (_IO_list_resetlock)
 
 
 #ifdef TODO
@@ -1253,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