my_pread.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:5k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #include "mysys_priv.h"
  14. #include "mysys_err.h"
  15. #include <errno.h>
  16. #ifdef HAVE_PREAD
  17. #include <unistd.h>
  18. #endif
  19. /* Read a chunk of bytes from a file  */
  20. uint my_pread(File Filedes, byte *Buffer, uint Count, my_off_t offset,
  21.       myf MyFlags)
  22. {
  23.   uint readbytes;
  24.   int error;
  25.   DBUG_ENTER("my_pread");
  26.   DBUG_PRINT("my",("Fd: %d  Seek: %lu  Buffer: 0x%lx  Count: %u  MyFlags: %d",
  27.    Filedes, (ulong) offset, Buffer, Count, MyFlags));
  28.   for (;;)
  29.   {
  30. #ifndef __WIN__
  31.     errno=0; /* Linux doesn't reset this */
  32. #endif
  33. #ifndef HAVE_PREAD
  34.     pthread_mutex_lock(&my_file_info[Filedes].mutex);
  35.     readbytes= (uint) -1;
  36.     error= (lseek(Filedes, offset, MY_SEEK_SET) == -1L ||
  37.     (readbytes = (uint) read(Filedes, Buffer, Count)) != Count);
  38.     pthread_mutex_unlock(&my_file_info[Filedes].mutex);
  39. #else
  40.     error=((readbytes = (uint) pread(Filedes, Buffer, Count, offset)) != Count);
  41. #endif
  42.     if (error)
  43.     {
  44.       my_errno=errno;
  45.       DBUG_PRINT("warning",("Read only %ld bytes off %ld from %d, errno: %d",
  46.     readbytes,Count,Filedes,my_errno));
  47. #ifdef THREAD
  48.       if (readbytes == 0 && errno == EINTR)
  49. continue; /* Interrupted */
  50. #endif
  51.       if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
  52.       {
  53. if ((int) readbytes == -1)
  54.   my_error(EE_READ, MYF(ME_BELL+ME_WAITTANG),
  55.    my_filename(Filedes),my_errno);
  56. else if (MyFlags & (MY_NABP | MY_FNABP))
  57.   my_error(EE_EOFERR, MYF(ME_BELL+ME_WAITTANG),
  58.    my_filename(Filedes),my_errno);
  59.       }
  60.       if ((int) readbytes == -1 || (MyFlags & (MY_FNABP | MY_NABP)))
  61. DBUG_RETURN(MY_FILE_ERROR); /* Return with error */
  62.     }
  63.     if (MyFlags & (MY_NABP | MY_FNABP))
  64.       DBUG_RETURN(0); /* Read went ok; Return 0 */
  65.     DBUG_RETURN(readbytes); /* purecov: inspected */
  66.   }
  67. } /* my_pread */
  68. /* Write a chunk of bytes to a file */
  69. uint my_pwrite(int Filedes, const byte *Buffer, uint Count, my_off_t offset,
  70.        myf MyFlags)
  71. {
  72.   uint writenbytes,errors;
  73.   ulong written;
  74.   DBUG_ENTER("my_pwrite");
  75.   DBUG_PRINT("my",("Fd: %d  Seek: %lu  Buffer: 0x%lx  Count: %d  MyFlags: %d",
  76.    Filedes, (ulong) offset,Buffer, Count, MyFlags));
  77.   errors=0; written=0L;
  78.   for (;;)
  79.   {
  80. #ifndef HAVE_PREAD
  81.     int error;
  82.     writenbytes= (uint) -1;
  83.     pthread_mutex_lock(&my_file_info[Filedes].mutex);
  84.     error=(lseek(Filedes, offset, MY_SEEK_SET) != -1L &&
  85.    (writenbytes = (uint) write(Filedes, Buffer, Count)) == Count);
  86.     pthread_mutex_unlock(&my_file_info[Filedes].mutex);
  87.     if (error)
  88.       break;
  89. #else
  90.     if ((writenbytes = (uint) pwrite(Filedes, Buffer, Count,offset)) == Count)
  91.       break;
  92. #endif
  93.     if ((int) writenbytes != -1)
  94.     { /* Safegueard */
  95.       written+=writenbytes;
  96.       Buffer+=writenbytes;
  97.       Count-=writenbytes;
  98.       offset+=writenbytes;
  99.     }
  100.     my_errno=errno;
  101.     DBUG_PRINT("error",("Write only %d bytes",writenbytes));
  102. #ifndef NO_BACKGROUND
  103. #ifdef THREAD
  104.     if (my_thread_var->abort)
  105.       MyFlags&= ~ MY_WAIT_IF_FULL; /* End if aborted by user */
  106. #endif
  107.     if ((my_errno == ENOSPC || my_errno == EDQUOT) &&
  108.         (MyFlags & MY_WAIT_IF_FULL))
  109.     {
  110.       if (!(errors++ % MY_WAIT_GIVE_USER_A_MESSAGE))
  111. my_error(EE_DISK_FULL,MYF(ME_BELL | ME_NOREFRESH),
  112.  my_filename(Filedes),my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
  113.       VOID(sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC));
  114.       continue;
  115.     }
  116.     if ((writenbytes == 0 && my_errno == EINTR) ||
  117. (writenbytes > 0 && (uint) writenbytes != (uint) -1))
  118.       continue; /* Retry */
  119. #endif
  120.     if (MyFlags & (MY_NABP | MY_FNABP))
  121.     {
  122.       if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
  123.       {
  124. my_error(EE_WRITE, MYF(ME_BELL | ME_WAITTANG),
  125.  my_filename(Filedes),my_errno);
  126.       }
  127.       DBUG_RETURN(MY_FILE_ERROR); /* Error on read */
  128.     }
  129.     else
  130.       break; /* Return bytes written */
  131.   }
  132.   if (MyFlags & (MY_NABP | MY_FNABP))
  133.     DBUG_RETURN(0); /* Want only errors */
  134.   DBUG_RETURN(writenbytes+written); /* purecov: inspected */
  135. } /* my_pwrite */