home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / mf_iocache.cpp < prev    next >
C/C++ Source or Header  |  2000-11-18  |  20KB  |  670 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17. /*
  18.   Cashing of files with only does (sequential) read or writes of fixed-
  19.   length records. A read isn't allowed to go over file-length. A read is ok
  20.   if it ends at file-length and next read can try to read after file-length
  21.   (and get a EOF-error).
  22.   Possibly use of asyncronic io.
  23.   macros for read and writes for faster io.
  24.   Used instead of FILE when reading or writing whole files.
  25.   This will make mf_rec_cache obsolete.
  26.   One can change info->pos_in_file to a higher value to skip bytes in file if
  27.   also info->rc_pos is set to info->rc_end.
  28.   If called through open_cached_file(), then the temporary file will
  29.   only be created if a write exeeds the file buffer or if one calls
  30.   flush_io_cache().  
  31. */
  32.  
  33. #define MAP_TO_USE_RAID
  34. #include "mysql_priv.h"
  35. #ifdef HAVE_AIOWAIT
  36. #include <mysys_err.h>
  37. #include <errno.h>
  38. static void my_aiowait(my_aio_result *result);
  39. #endif
  40. #include <assert.h>
  41.  
  42. extern "C" {
  43.  
  44.     /*
  45.     ** if cachesize == 0 then use default cachesize (from s-file)
  46.     ** if file == -1 then real_open_cached_file() will be called.
  47.     ** returns 0 if ok
  48.     */
  49.  
  50. int init_io_cache(IO_CACHE *info, File file, uint cachesize,
  51.           enum cache_type type, my_off_t seek_offset,
  52.           pbool use_async_io, myf cache_myflags)
  53. {
  54.   uint min_cache;
  55.   DBUG_ENTER("init_io_cache");
  56.   DBUG_PRINT("enter",("type: %d  pos: %ld",(int) type, (ulong) seek_offset));
  57.  
  58.   /* There is no file in net_reading */
  59.   info->file= file;
  60.   if (!cachesize)
  61.     if (! (cachesize= my_default_record_cache_size))
  62.       DBUG_RETURN(1);                /* No cache requested */
  63.   min_cache=use_async_io ? IO_SIZE*4 : IO_SIZE*2;
  64.   if (type == READ_CACHE)
  65.   {                        /* Assume file isn't growing */
  66.     if (cache_myflags & MY_DONT_CHECK_FILESIZE)
  67.     {
  68.       cache_myflags &= ~MY_DONT_CHECK_FILESIZE;
  69.     }
  70.     else
  71.     {
  72.       my_off_t file_pos,end_of_file;
  73.       if ((file_pos=my_tell(file,MYF(0)) == MY_FILEPOS_ERROR))
  74.     DBUG_RETURN(1);
  75.       end_of_file=my_seek(file,0L,MY_SEEK_END,MYF(0));
  76.       if (end_of_file < seek_offset)
  77.     end_of_file=seek_offset;
  78.       VOID(my_seek(file,file_pos,MY_SEEK_SET,MYF(0)));
  79.       if ((my_off_t) cachesize > end_of_file-seek_offset+IO_SIZE*2-1)
  80.       {
  81.     cachesize=(uint) (end_of_file-seek_offset)+IO_SIZE*2-1;
  82.     use_async_io=0;                /* No nead to use async */
  83.       }
  84.     }
  85.   }
  86.   if ((int) type < (int) READ_NET)
  87.   {
  88.     for (;;)
  89.     {
  90.       cachesize=(uint) ((ulong) (cachesize + min_cache-1) &
  91.             (ulong) ~(min_cache-1));
  92.       if (cachesize < min_cache)
  93.     cachesize = min_cache;
  94.       if ((info->buffer=
  95.        (byte*) my_malloc(cachesize,
  96.                  MYF((cache_myflags & ~ MY_WME) |
  97.                  (cachesize == min_cache ? MY_WME : 0)))) != 0)
  98.     break;                    /* Enough memory found */
  99.       if (cachesize == min_cache)
  100.     DBUG_RETURN(2);                /* Can't alloc cache */
  101.       cachesize= (uint) ((long) cachesize*3/4); /* Try with less memory */
  102.     }
  103.   }
  104.   else
  105.     info->buffer=0;
  106.   DBUG_PRINT("info",("init_io_cache: cachesize = %u",cachesize));
  107.   info->pos_in_file= seek_offset;
  108.   info->read_length=info->buffer_length=cachesize;
  109.   info->seek_not_done= test(file >= 0 && type != READ_FIFO &&
  110.                 type != READ_NET);
  111.   info->myflags=cache_myflags & ~(MY_NABP | MY_FNABP);
  112.   info->rc_request_pos=info->rc_pos=info->buffer;
  113.  
  114.   if (type == READ_CACHE || type == READ_NET || type == READ_FIFO)
  115.   {
  116.     info->rc_end=info->buffer;            /* Nothing in cache */
  117.   }
  118.   else /* type == WRITE_CACHE */
  119.   {
  120.     info->rc_end=info->buffer+info->buffer_length- (seek_offset & (IO_SIZE-1));
  121.   }
  122.   /* end_of_file may be changed by user later */
  123.   info->end_of_file= ((type == READ_NET || type == READ_FIFO ) ? 0
  124.               : MY_FILEPOS_ERROR);
  125.   info->type=type;
  126.   info->error=0;
  127.   info->read_function=(type == READ_NET) ? _my_b_net_read : _my_b_read; /* net | file */
  128. #ifdef HAVE_AIOWAIT
  129.   if (use_async_io && ! my_disable_async_io)
  130.   {
  131.     DBUG_PRINT("info",("Using async io"));
  132.     info->read_length/=2;
  133.     info->read_function=_my_b_async_read;
  134.   }
  135.   info->inited=info->aio_result.pending=0;
  136. #endif
  137.   DBUG_RETURN(0);
  138. }                        /* init_io_cache */
  139.  
  140.  
  141.     /* Wait until current request is ready */
  142.  
  143. #ifdef HAVE_AIOWAIT
  144. static void my_aiowait(my_aio_result *result)
  145. {
  146.   if (result->pending)
  147.   {
  148.     struct aio_result_t *tmp;
  149.     for (;;)
  150.     {
  151.       if ((int) (tmp=aiowait((struct timeval *) 0)) == -1)
  152.       {
  153.     if (errno == EINTR)
  154.       continue;
  155.     DBUG_PRINT("error",("No aio request, error: %d",errno));
  156.     result->pending=0;            /* Assume everythings is ok */
  157.     break;
  158.       }
  159.       ((my_aio_result*) tmp)->pending=0;
  160.       if ((my_aio_result*) tmp == result)
  161.     break;
  162.     }
  163.   }
  164.   return;
  165. }
  166. #endif
  167.  
  168.     /* Use this to reset cache to start or other type */
  169.     /* Some simple optimizing is done when reinit in current buffer */
  170.  
  171. my_bool reinit_io_cache(IO_CACHE *info, enum cache_type type,
  172.             my_off_t seek_offset,
  173.             pbool use_async_io __attribute__((unused)),
  174.             pbool clear_cache)
  175. {
  176.   DBUG_ENTER("reinit_io_cache");
  177.  
  178.   info->seek_not_done= test(info->file >= 0);    /* Seek not done */
  179.   if (! clear_cache &&
  180.       seek_offset >= info->pos_in_file &&
  181.       seek_offset <= info->pos_in_file +
  182.       (uint) (info->rc_end - info->rc_request_pos))
  183.   {                        /* use current buffer */
  184.     if (info->type == WRITE_CACHE && type == READ_CACHE)
  185.     {
  186.       info->rc_end=info->rc_pos;
  187.       info->end_of_file=my_b_tell(info);
  188.     }
  189.     else if (info->type == READ_CACHE && type == WRITE_CACHE)
  190.       info->rc_end=info->buffer+info->buffer_length;
  191.     info->rc_pos=info->rc_request_pos+(seek_offset-info->pos_in_file);
  192. #ifdef HAVE_AIOWAIT
  193.     my_aiowait(&info->aio_result);        /* Wait for outstanding req */
  194. #endif
  195.   }
  196.   else
  197.   {
  198.     if (info->type == WRITE_CACHE && type == READ_CACHE)
  199.       info->end_of_file=my_b_tell(info);
  200.     if (flush_io_cache(info))
  201.       DBUG_RETURN(1);
  202.     info->pos_in_file=seek_offset;
  203.     info->rc_request_pos=info->rc_pos=info->buffer;
  204.     if (type == READ_CACHE || type == READ_NET || type == READ_FIFO)
  205.     {
  206.       info->rc_end=info->buffer;        /* Nothing in cache */
  207.     }
  208.     else
  209.     {
  210.       info->rc_end=info->buffer+info->buffer_length-
  211.     (seek_offset & (IO_SIZE-1));
  212.       info->end_of_file= ((type == READ_NET || type == READ_FIFO) ? 0 :
  213.               MY_FILEPOS_ERROR);
  214.     }
  215.   }
  216.   info->type=type;
  217.   info->error=0;
  218.   info->read_function=(type == READ_NET) ? _my_b_net_read : _my_b_read;
  219. #ifdef HAVE_AIOWAIT
  220.   if (type != READ_NET)
  221.   {
  222.     if (use_async_io && ! my_disable_async_io &&
  223.     ((ulong) info->buffer_length <
  224.      (ulong) (info->end_of_file - seek_offset)))
  225.     {
  226.       info->read_length=info->buffer_length/2;
  227.       info->read_function=_my_b_async_read;
  228.     }
  229.   }
  230.   info->inited=0;
  231. #endif
  232.   DBUG_RETURN(0);
  233. } /* init_io_cache */
  234.  
  235.  
  236.  
  237.     /*
  238.       Read buffered. Returns 1 if can't read requested characters
  239.       This function is only called from the my_b_read() macro
  240.       when there isn't enough characters in the buffer to
  241.       satisfy the request.
  242.       Returns 0 we succeeded in reading all data
  243.     */
  244.  
  245. int _my_b_read(register IO_CACHE *info, byte *Buffer, uint Count)
  246. {
  247.   uint length,diff_length,left_length;
  248.   my_off_t max_length, pos_in_file;
  249.   
  250.   if ((left_length=(uint) (info->rc_end-info->rc_pos)))
  251.   {
  252.     dbug_assert(Count >= left_length);    /* User is not using my_b_read() */
  253.     memcpy(Buffer,info->rc_pos, (size_t) (left_length));
  254.     Buffer+=left_length;
  255.     Count-=left_length;
  256.   }
  257.   /* pos_in_file always point on where info->buffer was read */
  258.   pos_in_file=info->pos_in_file+(uint) (info->rc_end - info->buffer);
  259.   if (info->seek_not_done)
  260.   {                    /* File touched, do seek */
  261.     VOID(my_seek(info->file,pos_in_file,MY_SEEK_SET,MYF(0)));
  262.     info->seek_not_done=0;
  263.   }
  264.   diff_length=(uint) (pos_in_file & (IO_SIZE-1));
  265.   if (Count >= (uint) (IO_SIZE+(IO_SIZE-diff_length)))
  266.   {                    /* Fill first intern buffer */
  267.     uint read_length;
  268.     if (info->end_of_file == pos_in_file)
  269.     {                    /* End of file */
  270.       info->error=(int) left_length;
  271.       return 1;
  272.     }
  273.     length=(Count & (uint) ~(IO_SIZE-1))-diff_length;
  274.     if ((read_length=my_read(info->file,Buffer,(uint) length,info->myflags))
  275.     != (uint) length)
  276.     {
  277.       info->error= read_length == (uint) -1 ? -1 :
  278.     (int) (read_length+left_length);
  279.       return 1;
  280.     }
  281.     Count-=length;
  282.     Buffer+=length;
  283.     pos_in_file+=length;
  284.     left_length+=length;
  285.     diff_length=0;
  286.   }
  287.   max_length=info->read_length-diff_length;
  288.   if (info->type != READ_FIFO &&
  289.       (info->end_of_file - pos_in_file) < max_length)
  290.     max_length = info->end_of_file - pos_in_file;
  291.   if (!max_length)
  292.   {
  293.     if (Count)
  294.     {
  295.       info->error= left_length;        /* We only got this many char */
  296.       return 1;
  297.     }
  298.     length=0;                /* Didn't read any chars */
  299.   }
  300.   else if ((length=my_read(info->file,info->buffer,(uint) max_length,
  301.                info->myflags)) < Count ||
  302.        length == (uint) -1)
  303.   {
  304.     if (length != (uint) -1)
  305.       memcpy(Buffer,info->buffer,(size_t) length);
  306.     info->error= length == (uint) -1 ? -1 : (int) (length+left_length);
  307.     return 1;
  308.   }
  309.   info->rc_pos=info->buffer+Count;
  310.   info->rc_end=info->buffer+length;
  311.   info->pos_in_file=pos_in_file;
  312.   memcpy(Buffer,info->buffer,(size_t) Count);
  313.   return 0;
  314. }
  315.  
  316.     /*
  317.     ** Read buffered from the net.
  318.     ** Returns 1 if can't read requested characters
  319.     ** Returns 0 if record read
  320.     */
  321.  
  322. int _my_b_net_read(register IO_CACHE *info, byte *Buffer,
  323.            uint Count __attribute__((unused)))
  324. {
  325.   int read_length;
  326.   NET *net= &(current_thd)->net;
  327.  
  328.   if (info->end_of_file)
  329.     return 1;        /* because my_b_get (no _) takes 1 byte at a time */
  330.   read_length=my_net_read(net);
  331.   if (read_length == (int) packet_error)
  332.   {
  333.     info->error= -1;
  334.     return 1;
  335.   }
  336.   if (read_length == 0)
  337.   {
  338.     /* End of file from client */
  339.     info->end_of_file = 1; return 1;
  340.   }
  341.   /* to set up stuff for my_b_get (no _) */
  342.   info->rc_end = (info->rc_pos = (byte*) net->read_pos) + read_length;
  343.   Buffer[0] = info->rc_pos[0];            /* length is always 1 */
  344.   info->rc_pos++;
  345.   return 0;
  346. }
  347.  
  348. #ifdef HAVE_AIOWAIT
  349.  
  350. int _my_b_async_read(register IO_CACHE *info, byte *Buffer, uint Count)
  351. {
  352.   uint length,read_length,diff_length,left_length,use_length,org_Count;
  353.   my_off_t max_length;
  354.   my_off_t next_pos_in_file;
  355.   byte *read_buffer;
  356.  
  357.   memcpy(Buffer,info->rc_pos,
  358.      (size_t) (left_length=(uint) (info->rc_end-info->rc_pos)));
  359.   Buffer+=left_length;
  360.   org_Count=Count;
  361.   Count-=left_length;
  362.  
  363.   if (info->inited)
  364.   {                        /* wait for read block */
  365.     info->inited=0;                /* No more block to read */
  366.     my_aiowait(&info->aio_result);        /* Wait for outstanding req */
  367.     if (info->aio_result.result.aio_errno)
  368.     {
  369.       if (info->myflags & MY_WME)
  370.     my_error(EE_READ, MYF(ME_BELL+ME_WAITTANG),
  371.          my_filename(info->file),
  372.          info->aio_result.result.aio_errno);
  373.       my_errno=info->aio_result.result.aio_errno;
  374.       info->error= -1;
  375.       return(1);
  376.     }
  377.     if (! (read_length = (uint) info->aio_result.result.aio_return) ||
  378.     read_length == (uint) -1)
  379.     {
  380.       my_errno=0;                /* For testing */
  381.       info->error= (read_length == (uint) -1 ? -1 :
  382.             (int) (read_length+left_length));
  383.       return(1);
  384.     }
  385.     info->pos_in_file+=(uint) (info->rc_end - info->rc_request_pos);
  386.  
  387.     if (info->rc_request_pos != info->buffer)
  388.       info->rc_request_pos=info->buffer;
  389.     else
  390.       info->rc_request_pos=info->buffer+info->read_length;
  391.     info->rc_pos=info->rc_request_pos;
  392.     next_pos_in_file=info->aio_read_pos+read_length;
  393.  
  394.     /* Check if pos_in_file is changed
  395.        (_ni_read_cache may have skipped some bytes) */
  396.  
  397.     if (info->aio_read_pos < info->pos_in_file)
  398.     {                        /* Fix if skipped bytes */
  399.       if (info->aio_read_pos + read_length < info->pos_in_file)
  400.       {
  401.     read_length=0;                /* Skipp block */
  402.     next_pos_in_file=info->pos_in_file;
  403.       }
  404.       else
  405.       {
  406.     my_off_t offset= (info->pos_in_file - info->aio_read_pos);
  407.     info->pos_in_file=info->aio_read_pos; /* Whe are here */
  408.     info->rc_pos=info->rc_request_pos+offset;
  409.     read_length-=offset;            /* Bytes left from rc_pos */
  410.       }
  411.     }
  412. #ifndef DBUG_OFF
  413.     if (info->aio_read_pos > info->pos_in_file)
  414.     {
  415.       my_errno=EINVAL;
  416.       return(info->read_length= -1);
  417.     }
  418. #endif
  419.     /* Copy found bytes to buffer */
  420.     length=min(Count,read_length);
  421.     memcpy(Buffer,info->rc_pos,(size_t) length);
  422.     Buffer+=length;
  423.     Count-=length;
  424.     left_length+=length;
  425.     info->rc_end=info->rc_pos+read_length;
  426.     info->rc_pos+=length;
  427.   }
  428.   else
  429.     next_pos_in_file=(info->pos_in_file+ (uint)
  430.               (info->rc_end - info->rc_request_pos));
  431.  
  432.     /* If reading large blocks, or first read or read with skipp */
  433.   if (Count)
  434.   {
  435.     if (next_pos_in_file == info->end_of_file)
  436.     {
  437.       info->error=(int) (read_length+left_length);
  438.       return 1;
  439.     }
  440.     VOID(my_seek(info->file,next_pos_in_file,MY_SEEK_SET,MYF(0)));
  441.     read_length=IO_SIZE*2- (uint) (next_pos_in_file & (IO_SIZE-1));
  442.     if (Count < read_length)
  443.     {                    /* Small block, read to cache */
  444.       if ((read_length=my_read(info->file,info->rc_request_pos,
  445.                    read_length, info->myflags)) == (uint) -1)
  446.     return info->error= -1;
  447.       use_length=min(Count,read_length);
  448.       memcpy(Buffer,info->rc_request_pos,(size_t) use_length);
  449.       info->rc_pos=info->rc_request_pos+Count;
  450.       info->rc_end=info->rc_request_pos+read_length;
  451.       info->pos_in_file=next_pos_in_file;    /* Start of block in cache */
  452.       next_pos_in_file+=read_length;
  453.  
  454.       if (Count != use_length)
  455.       {                    /* Didn't find hole block */
  456.     if (info->myflags & (MY_WME | MY_FAE | MY_FNABP) && Count != org_Count)
  457.       my_error(EE_EOFERR, MYF(ME_BELL+ME_WAITTANG),
  458.            my_filename(info->file),my_errno);
  459.     info->error=(int) (read_length+left_length);
  460.     return 1;
  461.       }
  462.     }
  463.     else
  464.     {                        /* Big block, don't cache it */
  465.       if ((read_length=my_read(info->file,Buffer,(uint) Count,info->myflags))
  466.       != Count)
  467.       {
  468.     info->error= read_length == (uint)  -1 ? -1 : read_length+left_length;
  469.     return 1;
  470.       }
  471.       info->rc_pos=info->rc_end=info->rc_request_pos;
  472.       info->pos_in_file=(next_pos_in_file+=Count);
  473.     }
  474.   }
  475.  
  476.     /* Read next block with asyncronic io */
  477.   max_length=info->end_of_file - next_pos_in_file;
  478.   diff_length=(next_pos_in_file & (IO_SIZE-1));
  479.  
  480.   if (max_length > (my_off_t) info->read_length - diff_length)
  481.     max_length= (my_off_t) info->read_length - diff_length;
  482.   if (info->rc_request_pos != info->buffer)
  483.     read_buffer=info->buffer;
  484.   else
  485.     read_buffer=info->buffer+info->read_length;
  486.   info->aio_read_pos=next_pos_in_file;
  487.   if (max_length)
  488.   {
  489.     info->aio_result.result.aio_errno=AIO_INPROGRESS;    /* Marker for test */
  490.     DBUG_PRINT("aioread",("filepos: %ld  length: %ld",
  491.               (ulong) next_pos_in_file,(ulong) max_length));
  492.     if (aioread(info->file,read_buffer,(int) max_length,
  493.         (my_off_t) next_pos_in_file,MY_SEEK_SET,
  494.         &info->aio_result.result))
  495.     {                        /* Skipp async io */
  496.       my_errno=errno;
  497.       DBUG_PRINT("error",("got error: %d, aio_result: %d from aioread, async skipped",
  498.               errno, info->aio_result.result.aio_errno));
  499.       if (info->rc_request_pos != info->buffer)
  500.       {
  501.     bmove(info->buffer,info->rc_request_pos,
  502.           (uint) (info->rc_end - info->rc_pos));
  503.     info->rc_request_pos=info->buffer;
  504.     info->rc_pos-=info->read_length;
  505.     info->rc_end-=info->read_length;
  506.       }
  507.       info->read_length=info->buffer_length;    /* Use hole buffer */
  508.       info->read_function=_my_b_read;        /* Use normal IO_READ next */
  509.     }
  510.     else
  511.       info->inited=info->aio_result.pending=1;
  512.   }
  513.   return 0;                    /* Block read, async in use */
  514. } /* _my_b_async_read */
  515. #endif
  516.  
  517.  
  518. /* Read one byte when buffer is empty */
  519.  
  520. int _my_b_get(IO_CACHE *info)
  521. {
  522.   byte buff;
  523.   if ((*(info)->read_function)(info,&buff,1))
  524.     return my_b_EOF;
  525.   return (int) (uchar) buff;
  526. }
  527.  
  528.     /* Returns != 0 if error on write */
  529.  
  530. int _my_b_write(register IO_CACHE *info, const byte *Buffer, uint Count)
  531. {
  532.   uint rest_length,length;
  533.  
  534.   rest_length=(uint) (info->rc_end - info->rc_pos);
  535.   memcpy(info->rc_pos,Buffer,(size_t) rest_length);
  536.   Buffer+=rest_length;
  537.   Count-=rest_length;
  538.   info->rc_pos+=rest_length;
  539.   if (flush_io_cache(info))
  540.     return 1;
  541.   if (Count >= IO_SIZE)
  542.   {                    /* Fill first intern buffer */
  543.     length=Count & (uint) ~(IO_SIZE-1);
  544.     if (info->seek_not_done)
  545.     {                    /* File touched, do seek */
  546.       VOID(my_seek(info->file,info->pos_in_file,MY_SEEK_SET,MYF(0)));
  547.       info->seek_not_done=0;
  548.     }
  549.     if (my_write(info->file,Buffer,(uint) length,info->myflags | MY_NABP))
  550.       return info->error= -1;
  551.     Count-=length;
  552.     Buffer+=length;
  553.     info->pos_in_file+=length;
  554.   }
  555.   memcpy(info->rc_pos,Buffer,(size_t) Count);
  556.   info->rc_pos+=Count;
  557.   return 0;
  558. }
  559.  
  560.  
  561. /*
  562.   Write a block to disk where part of the data may be inside the record
  563.   buffer.  As all write calls to the data goes through the cache,
  564.   we will never get a seek over the end of the buffer
  565. */
  566.  
  567. int my_block_write(register IO_CACHE *info, const byte *Buffer, uint Count,
  568.            my_off_t pos)
  569. {
  570.   uint length;
  571.   int error=0;
  572.  
  573.   if (pos < info->pos_in_file)
  574.   {
  575.     /* Of no overlap, write everything without buffering */
  576.     if (pos + Count <= info->pos_in_file)
  577.       return my_pwrite(info->file, Buffer, Count, pos,
  578.                info->myflags | MY_NABP);
  579.     /* Write the part of the block that is before buffer */
  580.     length= (uint) (info->pos_in_file - pos);
  581.     if (my_pwrite(info->file, Buffer, length, pos, info->myflags | MY_NABP))
  582.       info->error=error=-1;
  583.     Buffer+=length;
  584.     pos+=  length;
  585.     Count-= length;
  586.   }
  587.  
  588.   /* Check if we want to write inside the used part of the buffer.*/
  589.   length= (uint) (info->rc_end - info->buffer);
  590.   if (pos < info->pos_in_file + length)
  591.   {
  592.     uint offset= (uint) (pos - info->pos_in_file);
  593.     length-=offset;
  594.     if (length > Count)
  595.       length=Count;
  596.     memcpy(info->buffer+offset, Buffer, length);
  597.     Buffer+=length;
  598.     Count-= length;
  599.     /* Fix length of buffer if the new data was larger */
  600.     if (info->buffer+length > info->rc_pos)
  601.       info->rc_pos=info->buffer+length;
  602.     if (!Count)
  603.       return (error);
  604.   }
  605.   /* Write at the end of the current buffer; This is the normal case */
  606.   if (_my_b_write(info, Buffer, Count))
  607.     error= -1;
  608.   return error;
  609. }
  610.  
  611.     /* Flush write cache */
  612.  
  613. int flush_io_cache(IO_CACHE *info)
  614. {
  615.   uint length;
  616.   DBUG_ENTER("flush_io_cache");
  617.  
  618.   if (info->type == WRITE_CACHE)
  619.   {
  620.     if (info->file == -1)
  621.     {
  622.       if (real_open_cached_file(info))
  623.     DBUG_RETURN((info->error= -1));
  624.     }
  625.     if (info->rc_pos != info->buffer)
  626.     {
  627.       length=(uint) (info->rc_pos - info->buffer);
  628.       if (info->seek_not_done)
  629.       {                    /* File touched, do seek */
  630.     if (my_seek(info->file,info->pos_in_file,MY_SEEK_SET,MYF(0)) ==
  631.         MY_FILEPOS_ERROR)
  632.       DBUG_RETURN((info->error= -1));
  633.     info->seek_not_done=0;
  634.       }
  635.       info->rc_pos=info->buffer;
  636.       info->pos_in_file+=length;
  637.       info->rc_end=(info->buffer+info->buffer_length-
  638.             (info->pos_in_file & (IO_SIZE-1)));
  639.       if (my_write(info->file,info->buffer,length,info->myflags | MY_NABP))
  640.     DBUG_RETURN((info->error= -1));
  641.       DBUG_RETURN(0);
  642.     }
  643.   }
  644. #ifdef HAVE_AIOWAIT
  645.   else if (info->type != READ_NET)
  646.   {
  647.     my_aiowait(&info->aio_result);    /* Wait for outstanding req */
  648.     info->inited=0;
  649.   }
  650. #endif
  651.   DBUG_RETURN(0);
  652. }
  653.  
  654.  
  655. int end_io_cache(IO_CACHE *info)
  656. {
  657.   int error=0;
  658.   DBUG_ENTER("end_io_cache");
  659.   if (info->buffer)
  660.   {
  661.     if (info->file != -1)            /* File doesn't exist */
  662.       error=flush_io_cache(info);
  663.     my_free((gptr) info->buffer,MYF(MY_WME));
  664.     info->buffer=info->rc_pos=(byte*) 0;
  665.   }
  666.   DBUG_RETURN(error);
  667. } /* end_io_cache */
  668.  
  669. } /* extern "C" */
  670.