Merge bk-internal.mysql.com:/home/bk/mysql-4.1

into  zippy.cornsilk.net:/home/cmiller/work/mysql/mysql-4.1-maint


configure.in:
  Auto merged
mysql-test/t/ps.test:
  Auto merged
sql/handler.cc:
  Auto merged
sql/sql_delete.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/table.cc:
  Auto merged
tests/mysql_client_test.c:
  Auto merged
myisam/sort.c:
  Manual merge.
mysql-test/r/innodb_mysql.result:
  Manual merge.
mysql-test/t/innodb_mysql.test:
  Manual merge.
mysys/mf_iocache.c:
  Manual merge.

11 files changed, 217 insertions, 42 deletions

diff --git a/mysys/charset.c b/mysys/charset.c
index 665f2efecd8..6f2d4d3c347 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -312,7 +312,7 @@ static my_bool my_read_charset_file(const char *filename, myf myflags)
 {
   char *buf;
   int  fd;
-  uint len;
+  uint len, tmp_len;
   MY_STAT stat_info;
   
   if (!my_stat(filename, &stat_info, MYF(myflags)) ||
@@ -321,12 +321,11 @@ static my_bool my_read_charset_file(const char *filename, myf myflags)
     return TRUE;
   
   if ((fd=my_open(filename,O_RDONLY,myflags)) < 0)
-  {
-    my_free(buf,myflags);
-    return TRUE;
-  }
-  len=read(fd,buf,len);
+    goto error;
+  tmp_len=my_read(fd, buf, len, myflags);
   my_close(fd,myflags);
+  if (tmp_len != len)
+    goto error;
   
   if (my_parse_charset_xml(buf,len,add_collation))
   {
@@ -340,6 +339,10 @@ static my_bool my_read_charset_file(const char *filename, myf myflags)
   
   my_free(buf, myflags);  
   return FALSE;
+
+error:
+  my_free(buf, myflags);
+  return TRUE;
 }
 
 
diff --git a/mysys/mf_iocache.c b/mysys/mf_iocache.c
index 58d4756b702..109d9fabda3 100644
--- a/mysys/mf_iocache.c
+++ b/mysys/mf_iocache.c
@@ -439,11 +439,24 @@ int _my_b_read(register IO_CACHE *info, byte *Buffer, uint Count)
 
   /* pos_in_file always point on where info->buffer was read */
   pos_in_file=info->pos_in_file+(uint) (info->read_end - info->buffer);
+
+  /* 
+    Whenever a function which operates on IO_CACHE flushes/writes
+    some part of the IO_CACHE to disk it will set the property
+    "seek_not_done" to indicate this to other functions operating
+    on the IO_CACHE.
+  */
   if (info->seek_not_done)
-  {					/* File touched, do seek */
-    VOID(my_seek(info->file,pos_in_file,MY_SEEK_SET,MYF(0)));
+  {
+    if (my_seek(info->file,pos_in_file,MY_SEEK_SET,MYF(0)) 
+        == MY_FILEPOS_ERROR)
+    {
+        info->error= -1;
+        DBUG_RETURN(1);
+    }
     info->seek_not_done=0;
   }
+
   diff_length=(uint) (pos_in_file & (IO_SIZE-1));
   if (Count >= (uint) (IO_SIZE+(IO_SIZE-diff_length)))
   {					/* Fill first intern buffer */
@@ -944,8 +957,22 @@ int _my_b_read_r(register IO_CACHE *cache, byte *Buffer, uint Count)
         len= 0;
       else
       {
-        if (cache->seek_not_done)             /* File touched, do seek */
-          VOID(my_seek(cache->file, pos_in_file, MY_SEEK_SET, MYF(0)));
+        /*
+          Whenever a function which operates on IO_CACHE flushes/writes
+          some part of the IO_CACHE to disk it will set the property
+          "seek_not_done" to indicate this to other functions operating
+          on the IO_CACHE.
+        */
+        if (info->seek_not_done)
+        {
+          if (my_seek(info->file,pos_in_file,MY_SEEK_SET,MYF(0))
+              == MY_FILEPOS_ERROR)
+          {
+            info->error= -1;
+            unlock_io_cache(info);
+            DBUG_RETURN(1);
+          }
+        }
         len= (int) my_read(cache->file, cache->buffer, length, cache->myflags);
       }
       DBUG_PRINT("io_cache_share", ("read %d bytes", len));
@@ -1047,11 +1074,16 @@ static void copy_to_read_buffer(IO_CACHE *write_cache,
 
 
 /*
-  Do sequential read from the SEQ_READ_APPEND cache
-  we do this in three stages:
+  Do sequential read from the SEQ_READ_APPEND cache.
+  
+  We do this in three stages:
    - first read from info->buffer
    - then if there are still data to read, try the file descriptor
    - afterwards, if there are still data to read, try append buffer
+
+  RETURNS
+    0  Success
+    1  Failed to read
 */
 
 int _my_b_seq_read(register IO_CACHE *info, byte *Buffer, uint Count)
@@ -1079,7 +1111,13 @@ int _my_b_seq_read(register IO_CACHE *info, byte *Buffer, uint Count)
     With read-append cache we must always do a seek before we read,
     because the write could have moved the file pointer astray
   */
-  VOID(my_seek(info->file,pos_in_file,MY_SEEK_SET,MYF(0)));
+  if (my_seek(info->file,pos_in_file,MY_SEEK_SET,MYF(0))
+      == MY_FILEPOS_ERROR)
+  {
+   info->error= -1;
+   unlock_append_buffer(info);
+   return (1);
+  }
   info->seek_not_done=0;
 
   diff_length=(uint) (pos_in_file & (IO_SIZE-1));
@@ -1195,6 +1233,21 @@ read_append_buffer:
 
 #ifdef HAVE_AIOWAIT
 
+/*
+  Read from the IO_CACHE into a buffer and feed asynchronously
+  from disk when needed.
+
+  SYNOPSIS
+    _my_b_async_read()
+      info                      IO_CACHE pointer
+      Buffer                    Buffer to retrieve count bytes from file
+      Count                     Number of bytes to read into Buffer
+
+  RETURN VALUE
+    -1          An error has occurred; my_errno is set.
+     0          Success
+     1          An error has occurred; IO_CACHE to error state.
+*/
 int _my_b_async_read(register IO_CACHE *info, byte *Buffer, uint Count)
 {
   uint length,read_length,diff_length,left_length,use_length,org_Count;
@@ -1285,13 +1338,20 @@ int _my_b_async_read(register IO_CACHE *info, byte *Buffer, uint Count)
       info->error=(int) (read_length+left_length);
       return 1;
     }
-    VOID(my_seek(info->file,next_pos_in_file,MY_SEEK_SET,MYF(0)));
+    
+    if (my_seek(info->file,next_pos_in_file,MY_SEEK_SET,MYF(0))
+        == MY_FILEPOS_ERROR)
+    {
+      info->error= -1;
+      return (1);
+    }
+
     read_length=IO_SIZE*2- (uint) (next_pos_in_file & (IO_SIZE-1));
     if (Count < read_length)
     {					/* Small block, read to cache */
       if ((read_length=my_read(info->file,info->request_pos,
 			       read_length, info->myflags)) == (uint) -1)
-	return info->error= -1;
+        return info->error= -1;
       use_length=min(Count,read_length);
       memcpy(Buffer,info->request_pos,(size_t) use_length);
       info->read_pos=info->request_pos+Count;
@@ -1378,7 +1438,15 @@ int _my_b_get(IO_CACHE *info)
   return (int) (uchar) buff;
 }
 
-	/* Returns != 0 if error on write */
+/* 
+   Write a byte buffer to IO_CACHE and flush to disk
+   if IO_CACHE is full.
+
+   RETURN VALUE
+    1 On error on write
+    0 On success
+   -1 On error; my_errno contains error code.
+*/
 
 int _my_b_write(register IO_CACHE *info, const byte *Buffer, uint Count)
 {
@@ -1402,8 +1470,18 @@ int _my_b_write(register IO_CACHE *info, const byte *Buffer, uint Count)
   {					/* Fill first intern buffer */
     length=Count & (uint) ~(IO_SIZE-1);
     if (info->seek_not_done)
-    {					/* File touched, do seek */
-      VOID(my_seek(info->file,info->pos_in_file,MY_SEEK_SET,MYF(0)));
+    {
+      /*
+        Whenever a function which operates on IO_CACHE flushes/writes
+        some part of the IO_CACHE to disk it will set the property
+        "seek_not_done" to indicate this to other functions operating
+        on the IO_CACHE.
+      */
+      if (my_seek(info->file,info->pos_in_file,MY_SEEK_SET,MYF(0)))
+      {
+        info->error= -1;
+        return (1);
+      }
       info->seek_not_done=0;
     }
     if (my_write(info->file,Buffer,(uint) length,info->myflags | MY_NABP))
diff --git a/mysys/my_chsize.c b/mysys/my_chsize.c
index efc19927183..149a5c81e08 100644
--- a/mysys/my_chsize.c
+++ b/mysys/my_chsize.c
@@ -90,7 +90,11 @@ int my_chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
       Fill space between requested length and true length with 'filler'
       We should never come here on any modern machine
     */
-    VOID(my_seek(fd, newlength, MY_SEEK_SET, MYF(MY_WME+MY_FAE)));
+    if (my_seek(fd, newlength, MY_SEEK_SET, MYF(MY_WME+MY_FAE))
+        == MY_FILEPOS_ERROR)
+    {
+      goto err;
+    }
     swap_variables(my_off_t, newlength, oldsize);
   }
 #endif
diff --git a/mysys/my_lock.c b/mysys/my_lock.c
index 8f915d6003a..b8307f366c0 100644
--- a/mysys/my_lock.c
+++ b/mysys/my_lock.c
@@ -35,7 +35,14 @@
 #include <nks/fsio.h>
 #endif
 
-	/* Lock a part of a file */
+/* 
+  Lock a part of a file 
+
+  RETURN VALUE
+    0   Success
+    -1  An error has occured and 'my_errno' is set
+        to indicate the actual error code.
+*/
 
 int my_lock(File fd, int locktype, my_off_t start, my_off_t length,
 	    myf MyFlags)
@@ -104,10 +111,22 @@ int my_lock(File fd, int locktype, my_off_t start, my_off_t length,
 #elif defined(HAVE_LOCKING)
   /* Windows */
   {
-    my_bool error;
+    my_bool error= FALSE;
     pthread_mutex_lock(&my_file_info[fd].mutex);
-    if (MyFlags & MY_SEEK_NOT_DONE)
-      VOID(my_seek(fd,start,MY_SEEK_SET,MYF(MyFlags & ~MY_SEEK_NOT_DONE)));
+    if (MyFlags & MY_SEEK_NOT_DONE) 
+    {
+      if( my_seek(fd,start,MY_SEEK_SET,MYF(MyFlags & ~MY_SEEK_NOT_DONE))
+           == MY_FILEPOS_ERROR )
+      {
+        /*
+          If my_seek fails my_errno will already contain an error code;
+          just unlock and return error code.
+         */
+        DBUG_PRINT("error",("my_errno: %d (%d)",my_errno,errno));
+        pthread_mutex_unlock(&my_file_info[fd].mutex);
+        DBUG_RETURN(-1);
+      }
+    }
     error= locking(fd,locktype,(ulong) length) && errno != EINVAL;
     pthread_mutex_unlock(&my_file_info[fd].mutex);
     if (!error)
@@ -145,7 +164,17 @@ int my_lock(File fd, int locktype, my_off_t start, my_off_t length,
   }
 #else
   if (MyFlags & MY_SEEK_NOT_DONE)
-    VOID(my_seek(fd,start,MY_SEEK_SET,MYF(MyFlags & ~MY_SEEK_NOT_DONE)));
+  {
+    if (my_seek(fd,start,MY_SEEK_SET,MYF(MyFlags & ~MY_SEEK_NOT_DONE))
+        == MY_FILEPOS_ERROR)
+    {
+      /*
+        If an error has occured in my_seek then we will already
+        have an error code in my_errno; Just return error code.
+      */
+      DBUG_RETURN(-1);
+    }
+  }
   if (lockf(fd,locktype,length) != -1)
     DBUG_RETURN(0);
 #endif /* HAVE_FCNTL */
diff --git a/mysys/my_lread.c b/mysys/my_lread.c
index 601d772b844..a96febe4474 100644
--- a/mysys/my_lread.c
+++ b/mysys/my_lread.c
@@ -30,6 +30,8 @@ uint32 my_lread(int Filedes, byte *Buffer, uint32 Count, myf MyFlags)
   DBUG_PRINT("my",("Fd: %d  Buffer: %ld  Count: %ld  MyFlags: %d",
 		   Filedes, Buffer, Count, MyFlags));
 
+  DBUG_PRINT("error", ("Deprecated my_lread() function should not be used."));
+
   /* Temp hack to get count to int32 while read wants int */
   if ((readbytes = (uint32) read(Filedes, Buffer, (uint) Count)) != Count)
   {
diff --git a/mysys/my_lwrite.c b/mysys/my_lwrite.c
index 3b9afdbd71f..02c56a69ba4 100644
--- a/mysys/my_lwrite.c
+++ b/mysys/my_lwrite.c
@@ -26,6 +26,8 @@ uint32 my_lwrite(int Filedes, const byte *Buffer, uint32 Count, myf MyFlags)
   DBUG_PRINT("my",("Fd: %d  Buffer: 0x%lx  Count: %ld  MyFlags: %d",
 		   Filedes, Buffer, Count, MyFlags));
 
+  DBUG_PRINT("error", ("Deprecated my_lwrite() function should not be used."));
+
   /* Temp hack to get count to int32 while write wants int */
   if ((writenbytes = (uint32) write(Filedes, Buffer, (uint) Count)) != Count)
   {
diff --git a/mysys/my_pread.c b/mysys/my_pread.c
index 3d02e368720..f378d548731 100644
--- a/mysys/my_pread.c
+++ b/mysys/my_pread.c
@@ -52,8 +52,12 @@ uint my_pread(File Filedes, byte *Buffer, uint Count, my_off_t offset,
       DBUG_PRINT("warning",("Read only %ld bytes off %ld from %d, errno: %d",
 			    readbytes,Count,Filedes,my_errno));
 #ifdef THREAD
-      if (readbytes == 0 && errno == EINTR)
-	continue;				/* Interrupted */
+      if ((readbytes == 0 || (int) readbytes == -1) && errno == EINTR)
+      {
+        DBUG_PRINT("debug", ("my_pread() was interrupted and returned %d",
+                             (int) readbytes));
+        continue;                              /* Interrupted */
+      }
 #endif
       if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
       {
@@ -124,8 +128,8 @@ uint my_pwrite(int Filedes, const byte *Buffer, uint Count, my_off_t offset,
       VOID(sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC));
       continue;
     }
-    if ((writenbytes == 0 && my_errno == EINTR) ||
-	(writenbytes > 0 && (uint) writenbytes != (uint) -1))
+    if ((writenbytes > 0 && (uint) writenbytes != (uint) -1) ||
+        my_errno == EINTR)
       continue;					/* Retry */
 #endif
     if (MyFlags & (MY_NABP | MY_FNABP))
diff --git a/mysys/my_quick.c b/mysys/my_quick.c
index 44ed3fc0b2c..ffc8160c371 100644
--- a/mysys/my_quick.c
+++ b/mysys/my_quick.c
@@ -26,6 +26,14 @@ uint my_quick_read(File Filedes,byte *Buffer,uint Count,myf MyFlags)
 
   if ((readbytes = (uint) read(Filedes, Buffer, Count)) != Count)
   {
+#ifndef DBUG_OFF
+    if ((readbytes == 0 || (int) readbytes == -1) && errno == EINTR)
+    {  
+      DBUG_PRINT("error", ("my_quick_read() was interrupted and returned %d"
+                           ".  This function does not retry the read!",
+                           (int) readbytes));
+    }
+#endif
     my_errno=errno;
     return readbytes;
   }
@@ -35,8 +43,24 @@ uint my_quick_read(File Filedes,byte *Buffer,uint Count,myf MyFlags)
 
 uint my_quick_write(File Filedes,const byte *Buffer,uint Count)
 {
-  if ((uint) write(Filedes,Buffer,Count) != Count)
+#ifndef DBUG_OFF
+  uint writtenbytes;
+#endif
+
+  if ((
+#ifndef DBUG_OFF
+       writtenbytes =
+#endif
+       (uint) write(Filedes,Buffer,Count)) != Count)
   {
+#ifndef DBUG_OFF
+    if ((writtenbytes == 0 || (int) writtenbytes == -1) && errno == EINTR)
+    {  
+      DBUG_PRINT("error", ("my_quick_write() was interrupted and returned %d"
+                           ".  This function does not retry the write!",
+                           (int) writtenbytes));
+    }
+#endif
     my_errno=errno;
     return (uint) -1;
   }
diff --git a/mysys/my_read.c b/mysys/my_read.c
index 2e23f2175f8..8b88e483fef 100644
--- a/mysys/my_read.c
+++ b/mysys/my_read.c
@@ -51,10 +51,11 @@ uint my_read(File Filedes, byte *Buffer, uint Count, myf MyFlags)
       DBUG_PRINT("warning",("Read only %ld bytes off %ld from %d, errno: %d",
                             readbytes, Count, Filedes, my_errno));
 #ifdef THREAD
-      if ((int) readbytes <= 0 && errno == EINTR)
-      {
-        DBUG_PRINT("debug", ("my_read() was interrupted and returned %d", (int) readbytes));
-        continue;				/* Interrupted */
+      if ((readbytes == 0 || (int) readbytes == -1) && errno == EINTR)
+      {  
+        DBUG_PRINT("debug", ("my_read() was interrupted and returned %d",
+                             (int) readbytes));
+        continue;                              /* Interrupted */
       }
 #endif
       if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
diff --git a/mysys/my_seek.c b/mysys/my_seek.c
index 6af65d70fd0..a9ae68cd5f0 100644
--- a/mysys/my_seek.c
+++ b/mysys/my_seek.c
@@ -16,8 +16,30 @@
 
 #include "mysys_priv.h"
 
-	/* Seek to position in file */
-	/*ARGSUSED*/
+/* 
+  Seek to a position in a file.
+
+  ARGUMENTS
+  File fd          The file descriptor
+  my_off_t pos     The expected position (absolute or relative)
+  int whence       A direction parameter and one of 
+                   {SEEK_SET, SEEK_CUR, SEEK_END}
+  myf MyFlags      Not used.
+
+  DESCRIPTION
+    The my_seek  function  is a wrapper around the system call lseek and
+    repositions  the  offset of the file descriptor fd to the argument 
+    offset according to the directive whence as follows:
+      SEEK_SET    The offset is set to offset bytes.
+      SEEK_CUR    The offset is set to its current location plus offset bytes
+      SEEK_END    The offset is set to the size of the file plus offset bytes
+
+  RETURN VALUE
+    my_off_t newpos    The new position in the file.
+    MY_FILEPOS_ERROR   An error was encountered while performing 
+                       the seek. my_errno is set to indicate the
+                       actual error.
+*/
 
 my_off_t my_seek(File fd, my_off_t pos, int whence,
 		 myf MyFlags __attribute__((unused)))
diff --git a/mysys/my_write.c b/mysys/my_write.c
index 4e8369480b3..ae8cb4ab02b 100644
--- a/mysys/my_write.c
+++ b/mysys/my_write.c
@@ -57,18 +57,24 @@ uint my_write(int Filedes, const byte *Buffer, uint Count, myf MyFlags)
       VOID(sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC));
       continue;
     }
-    if (!writenbytes)
+
+    if ((writenbytes == 0 || (int) writenbytes == -1))
     {
-      /* We may come here on an interrupt or if the file quote is exeeded */
       if (my_errno == EINTR)
-	continue;
-      if (!errors++)				/* Retry once */
       {
-	errno=EFBIG;				/* Assume this is the error */
-	continue;
+        DBUG_PRINT("debug", ("my_write() was interrupted and returned %d",
+                             (int) writenbytes));
+        continue;                               /* Interrupted */
+      }
+
+      if (!writenbytes && !errors++)		/* Retry once */
+      {
+        /* We may come here if the file quota is exeeded */
+        errno=EFBIG;				/* Assume this is the error */
+        continue;
       }
     }
-    else if ((uint) writenbytes != (uint) -1)
+    else
       continue;					/* Retry */
 #endif
     if (MyFlags & (MY_NABP | MY_FNABP))