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

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. /*
  14.  
  15.    RAID support for MySQL. Raid 0 (stiping) only implemented yet.
  16.  
  17.    Why RAID? Why it must be in MySQL?
  18.  
  19.    This is because then you can:
  20.    1. Have bigger tables than your OS limit. In time of writing this
  21.       we are hitting to 2GB limit under linux/ext2
  22.    2. You can get more speed from IO bottleneck by putting
  23.       Raid dirs on different physical disks.
  24.    3. Getting more fault tolerance (not implemented yet)
  25.  
  26.    Why not to use RAID:
  27.  
  28.    1. You are losing some processor power to calculate things,
  29.       do more syscalls and interrupts.
  30.  
  31.    Functionality is supplied by two classes: RaidFd and RaidName.
  32.    RaidFd supports funtionality over file descriptors like
  33.    open/create/write/seek/close. RaidName supports functionality
  34.    like rename/delete where we have no relations to filedescriptors.
  35.    RaidName can be prorably unchanged for different Raid levels. RaidFd
  36.    have to be virtual I think ;).
  37.    You can speed up some calls in MySQL code by skipping RAID code.
  38.    For example LOAD DATA INFILE never needs to read RAID-ed files.
  39.    This can be done adding proper "#undef my_read" or similar undef-s
  40.    in your code. Check out the raid.h!
  41.  
  42.    Some explanation about _seek_vector[]
  43.    This is seek cache. RAID seeks too much and we cacheing this. We
  44.    fool it and just storing new position in file to _seek_vector.
  45.    When there is no seeks to do, we are putting RAID_SEEK_DONE into it.
  46.    Any other value requires seeking to that position.
  47.  
  48.    TODO:
  49.  
  50.  
  51.    -  Implement other fancy things like RAID 1 (mirroring) and RAID 5.
  52.       Should not to be very complex.
  53.  
  54.    -  Optimize big blob writes by resorting write buffers and writing
  55.       big chunks at once instead of doing many syscalls. - after thinking I
  56.       found this is useless. This is because same thing one can do with just
  57.       increasing RAID_CHUNKSIZE. Monty, what do you think? tonu.
  58.  
  59.    -  If needed, then implement missing syscalls. One known to miss is stat();
  60.  
  61.    -  Make and use a thread safe dynamic_array buffer. The used one
  62.       will not work if needs to be extended at the same time someone is
  63.       accessing it.
  64.  
  65.  
  66.    tonu@mysql.com & monty@mysql.com
  67. */
  68. #ifdef USE_PRAGMA_IMPLEMENTATION 
  69. #pragma implementation // gcc: Class implementation
  70. #endif
  71. #include "mysys_priv.h"
  72. #include <my_dir.h>
  73. #include <m_string.h>
  74. #include <assert.h>
  75. #if defined(USE_RAID) && !defined(MYSQL_CLIENT)
  76. #define RAID_SEEK_DONE ~(off_t) 0
  77. #define RAID_SIZE_UNKNOWN ~(my_off_t) 0
  78. DYNAMIC_ARRAY RaidFd::_raid_map;
  79. /* ---------------  C compatibility  ---------------*/
  80. extern "C" {
  81.   void init_raid(void)
  82.   {
  83.   /* Allocate memory for global file to raid map */
  84.     my_init_dynamic_array(&RaidFd::_raid_map, sizeof(RaidFd*), 4096, 1024);
  85.   }
  86.   void end_raid(void)
  87.   {
  88.     /* Free memory used by raid */
  89.     delete_dynamic(&RaidFd::_raid_map);
  90.   }
  91.   bool is_raid(File fd)
  92.   {
  93.     return RaidFd::IsRaid(fd);
  94.   }
  95.   File my_raid_create(const char *FileName, int CreateFlags, int access_flags,
  96.       uint raid_type, uint raid_chunks, ulong raid_chunksize,
  97.       myf MyFlags)
  98.   {
  99.     DBUG_ENTER("my_raid_create");
  100.     DBUG_PRINT("enter",("Filename: %s  CreateFlags: %d  access_flags: %d  MyFlags: %d",
  101. FileName, CreateFlags, access_flags, MyFlags));
  102.     if (raid_type)
  103.     {
  104.       RaidFd *raid = new RaidFd(raid_type, raid_chunks , raid_chunksize);
  105.       File res = raid->Create(FileName,CreateFlags,access_flags,MyFlags);
  106.       if (res < 0 || set_dynamic(&RaidFd::_raid_map,(char*) &raid,res))
  107.       {
  108. delete raid;
  109. DBUG_RETURN(-1);
  110.       }
  111.       DBUG_RETURN(res);
  112.     }
  113.     else
  114.        DBUG_RETURN(my_create(FileName, CreateFlags, access_flags,  MyFlags));
  115.   }
  116.   File my_raid_open(const char *FileName, int Flags,
  117.     uint raid_type, uint raid_chunks, ulong raid_chunksize,
  118.     myf MyFlags)
  119.   {
  120.     DBUG_ENTER("my_raid_open");
  121.     DBUG_PRINT("enter",("Filename: %s  Flags: %d  MyFlags: %d",
  122. FileName, Flags, MyFlags));
  123.     if (raid_type)
  124.     {
  125.       RaidFd *raid = new RaidFd(raid_type, raid_chunks , raid_chunksize);
  126.       File res = raid->Open(FileName,Flags,MyFlags);
  127.       if (res < 0 || set_dynamic(&RaidFd::_raid_map,(char*) &raid,res))
  128.       {
  129. delete raid;
  130. DBUG_RETURN(-1);
  131.       }
  132.       DBUG_RETURN(res);
  133.     }
  134.     else
  135.       DBUG_RETURN(my_open(FileName, Flags, MyFlags));
  136.   }
  137.   my_off_t my_raid_seek(File fd, my_off_t pos,int whence,myf MyFlags)
  138.   {
  139.     DBUG_ENTER("my_raid_seek");
  140.     DBUG_PRINT("enter",("Fd: %d  pos: %lu whence: %d  MyFlags: %d",
  141. fd, (ulong) pos, whence, MyFlags));
  142.     if (is_raid(fd))
  143.     {
  144.       assert(pos != MY_FILEPOS_ERROR);
  145.       RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
  146.       DBUG_RETURN(raid->Seek(pos,whence,MyFlags));
  147.     }
  148.     else
  149.       DBUG_RETURN(my_seek(fd, pos, whence, MyFlags));
  150.   }
  151.   my_off_t my_raid_tell(File fd,myf MyFlags)
  152.   {
  153.     DBUG_ENTER("my_raid_tell");
  154.     DBUG_PRINT("enter",("Fd: %d  MyFlags: %d",
  155. fd, MyFlags));
  156.     if (is_raid(fd))
  157.     {
  158.       RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
  159.       DBUG_RETURN(raid->Tell(MyFlags));
  160.     }
  161.     else
  162.        DBUG_RETURN(my_tell(fd, MyFlags));
  163.   }
  164.   uint my_raid_write(File fd,const byte *Buffer, uint Count, myf MyFlags)
  165.   {
  166.     DBUG_ENTER("my_raid_write");
  167.     DBUG_PRINT("enter",("Fd: %d  Buffer: %lx  Count: %u  MyFlags: %d",
  168.       fd, Buffer, Count, MyFlags));
  169.     if (is_raid(fd))
  170.     {
  171.       RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
  172.       DBUG_RETURN(raid->Write(Buffer,Count,MyFlags));
  173.     } else
  174.       DBUG_RETURN(my_write(fd,Buffer,Count,MyFlags));
  175.   }
  176.   uint my_raid_read(File fd, byte *Buffer, uint Count, myf MyFlags)
  177.   {
  178.     DBUG_ENTER("my_raid_read");
  179.     DBUG_PRINT("enter",("Fd: %d  Buffer: %lx  Count: %u  MyFlags: %d",
  180.       fd, Buffer, Count, MyFlags));
  181.     if (is_raid(fd))
  182.     {
  183.       RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
  184.       DBUG_RETURN(raid->Read(Buffer,Count,MyFlags));
  185.     } else
  186.       DBUG_RETURN(my_read(fd,Buffer,Count,MyFlags));
  187.   }
  188.   uint my_raid_pread(File Filedes, byte *Buffer, uint Count, my_off_t offset,
  189.      myf MyFlags)
  190.   {
  191.     DBUG_ENTER("my_raid_pread");
  192.     DBUG_PRINT("enter",("Fd: %d  Buffer: %lx  Count: %u offset: %u  MyFlags: %d",
  193.       Filedes, Buffer, Count, offset, MyFlags));
  194.      if (is_raid(Filedes))
  195.      {
  196.        assert(offset != MY_FILEPOS_ERROR);
  197.        RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,Filedes,RaidFd**));
  198.        /* Returning value isn't important because real seek is done later. */
  199.        raid->Seek(offset,MY_SEEK_SET,MyFlags);
  200.        DBUG_RETURN(raid->Read(Buffer,Count,MyFlags));
  201.      }
  202.      else
  203.        DBUG_RETURN(my_pread(Filedes, Buffer, Count, offset, MyFlags));
  204.   }
  205.   uint my_raid_pwrite(int Filedes, const byte *Buffer, uint Count,
  206.       my_off_t offset, myf MyFlags)
  207.   {
  208.     DBUG_ENTER("my_raid_pwrite");
  209.     DBUG_PRINT("enter",("Fd: %d  Buffer: %lx  Count: %u offset: %u  MyFlags: %d",
  210.       Filedes, Buffer, Count, offset, MyFlags));
  211.      if (is_raid(Filedes))
  212.      {
  213.        assert(offset != MY_FILEPOS_ERROR);
  214.        RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,Filedes,RaidFd**));
  215.        /* Returning value isn't important because real seek is done later. */
  216.        raid->Seek(offset,MY_SEEK_SET,MyFlags);
  217.        DBUG_RETURN(raid->Write(Buffer,Count,MyFlags));
  218.      }
  219.      else
  220.        DBUG_RETURN(my_pwrite(Filedes, Buffer, Count, offset, MyFlags));
  221.   }
  222.   int my_raid_lock(File fd, int locktype, my_off_t start, my_off_t length,
  223.    myf MyFlags)
  224.   {
  225.     DBUG_ENTER("my_raid_lock");
  226.     DBUG_PRINT("enter",("Fd: %d  start: %u  length: %u  MyFlags: %d",
  227.       fd, start, length, MyFlags));
  228.     if (my_disable_locking)
  229.       DBUG_RETURN(0);
  230.     if (is_raid(fd))
  231.     {
  232.       RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
  233.       DBUG_RETURN(raid->Lock(locktype, start, length, MyFlags));
  234.     }
  235.     else
  236.       DBUG_RETURN(my_lock(fd, locktype, start, length, MyFlags));
  237.   }
  238.   int my_raid_close(File fd, myf MyFlags)
  239.   {
  240.     DBUG_ENTER("my_raid_close");
  241.     DBUG_PRINT("enter",("Fd: %d  MyFlags: %d",
  242.       fd, MyFlags));
  243.     if (is_raid(fd))
  244.     {
  245.       RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
  246.       RaidFd *tmp=0;
  247.       set_dynamic(&RaidFd::_raid_map,(char*) &tmp,fd);
  248.       int res = raid->Close(MyFlags);
  249.       delete raid;
  250.       DBUG_RETURN(res);
  251.     }
  252.     else
  253.       DBUG_RETURN(my_close(fd, MyFlags));
  254.   }
  255.   int my_raid_chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
  256.   {
  257.     DBUG_ENTER("my_raid_chsize");
  258.     DBUG_PRINT("enter",("Fd: %d  newlength: %u  MyFlags: %d",
  259.       fd, newlength, MyFlags));
  260.    if (is_raid(fd))
  261.    {
  262.      RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
  263.      DBUG_RETURN(raid->Chsize(fd, newlength, filler, MyFlags));
  264.    }
  265.    else
  266.      DBUG_RETURN(my_chsize(fd, newlength, filler, MyFlags));
  267.   }
  268.   int my_raid_rename(const char *from, const char *to,
  269.      uint raid_chunks, myf MyFlags)
  270.   {
  271.     char from_tmp[FN_REFLEN];
  272.     char to_tmp[FN_REFLEN];
  273.     DBUG_ENTER("my_raid_rename");
  274.     uint from_pos = dirname_length(from);
  275.     uint to_pos   = dirname_length(to);
  276.     memcpy(from_tmp, from, from_pos);
  277.     memcpy(to_tmp, to, to_pos);
  278.     for (uint i = 0 ; i < raid_chunks ; i++ )
  279.     {
  280.       sprintf(from_tmp+from_pos,"%02x/%s", i, from + from_pos);
  281.       sprintf(to_tmp+to_pos,"%02x/%s", i, to+ to_pos);
  282.       /* Convert if not unix */
  283.       unpack_filename(from_tmp, from_tmp);
  284.       unpack_filename(to_tmp,to_tmp);
  285.       if (my_rename(from_tmp, to_tmp, MyFlags))
  286. DBUG_RETURN(-1);
  287.     }
  288.     DBUG_RETURN(0);
  289.   }
  290.   int my_raid_delete(const char *from, uint raid_chunks, myf MyFlags)
  291.   {
  292.     char from_tmp[FN_REFLEN];
  293.     uint from_pos = dirname_length(from);
  294.     DBUG_ENTER("my_raid_delete");
  295.     if (!raid_chunks)
  296.       DBUG_RETURN(my_delete(from,MyFlags));
  297.     for (uint i = 0 ; i < raid_chunks ; i++ )
  298.     {
  299.       memcpy(from_tmp, from, from_pos);
  300.       sprintf(from_tmp+from_pos,"%02x/%s", i, from + from_pos);
  301.       /* Convert if not unix */
  302.       unpack_filename(from_tmp, from_tmp);
  303.       if (my_delete(from_tmp, MyFlags))
  304. DBUG_RETURN(-1);
  305.     }
  306.     DBUG_RETURN(0);
  307.   }
  308.   int my_raid_redel(const char *old_name, const char *new_name,
  309.     uint raid_chunks, myf MyFlags)
  310.   {
  311.     char new_name_buff[FN_REFLEN], old_name_buff[FN_REFLEN];
  312.     char *new_end, *old_end;
  313.     uint i,old_length,new_length;
  314.     int error=0;
  315.     DBUG_ENTER("my_raid_redel");
  316.     old_end=old_name_buff+dirname_part(old_name_buff,old_name);
  317.     old_length=dirname_length(old_name);
  318.     new_end=new_name_buff+dirname_part(new_name_buff,new_name);
  319.     new_length=dirname_length(new_name);
  320.     for (i=0 ; i < raid_chunks ; i++)
  321.     {
  322.       MY_STAT status;
  323.       sprintf(new_end,"%02x",i);
  324.       if (my_stat(new_name_buff,&status, MYF(0)))
  325.       {
  326. DBUG_PRINT("info",("%02x exists, skipping directory creation",i));
  327.       }
  328.       else
  329.       {
  330. if (my_mkdir(new_name_buff,0777,MYF(0)))
  331. {
  332.   DBUG_PRINT("error",("mkdir failed for %02x",i));
  333.   DBUG_RETURN(-1);
  334. }
  335.       }
  336.       strxmov(strend(new_end),"/",new_name+new_length,NullS);
  337.       sprintf(old_end,"%02x/%s",i, old_name+old_length);
  338.       if (my_redel(old_name_buff, new_name_buff, MyFlags))
  339. error=1;
  340.     }
  341.     DBUG_RETURN(error);
  342.   }
  343. }
  344. int my_raid_fstat(int fd, MY_STAT *stat_area, myf MyFlags )
  345. {
  346.   DBUG_ENTER("my_raid_fstat");
  347.   if (is_raid(fd))
  348.   {
  349.     RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
  350.     DBUG_RETURN(raid->Fstat(fd, stat_area, MyFlags));
  351.   }
  352.   else
  353.     DBUG_RETURN(my_fstat(fd, stat_area, MyFlags));
  354. }
  355. /* -------------- RaidFd base class begins ----------------*/
  356. /*
  357.   RaidFd - raided file is identified by file descriptor
  358.   this is useful when we open/write/read/close files
  359. */
  360. bool RaidFd::
  361. IsRaid(File fd)
  362. {
  363.   DBUG_ENTER("RaidFd::IsRaid");
  364.   DBUG_RETURN((uint) fd < _raid_map.elements &&
  365.       *dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
  366. }
  367. RaidFd::
  368. RaidFd(uint raid_type, uint raid_chunks, ulong raid_chunksize)
  369.   :_raid_type(raid_type), _raid_chunks(raid_chunks),
  370.    _raid_chunksize(raid_chunksize), _position(0), _size(RAID_SIZE_UNKNOWN),
  371.    _fd_vector(0)
  372. {
  373.   DBUG_ENTER("RaidFd::RaidFd");
  374.   DBUG_PRINT("enter",("RaidFd_type: %u  Disks: %u  Chunksize: %d",
  375.    raid_type, raid_chunks, raid_chunksize));
  376.   /* TODO: Here we should add checks if the malloc fails */
  377.   _seek_vector=0; /* In case of errors */
  378.   my_multi_malloc(MYF(MY_WME),
  379.   &_seek_vector,sizeof(off_t)*_raid_chunks,
  380.   &_fd_vector, sizeof(File) *_raid_chunks,
  381.   NullS);
  382.   if (!RaidFd::_raid_map.buffer)
  383.   { /* Not initied */
  384.     pthread_mutex_lock(&THR_LOCK_open); /* Ensure that no other thread */
  385.     if (!RaidFd::_raid_map.buffer) /* has done init in between */
  386.       init_raid();
  387.     pthread_mutex_unlock(&THR_LOCK_open);
  388.   }
  389.   DBUG_VOID_RETURN;
  390. }
  391. RaidFd::
  392. ~RaidFd() {
  393.   DBUG_ENTER("RaidFd::~RaidFd");
  394.   /* We don't have to free _fd_vector ! */
  395.   my_free((char*) _seek_vector, MYF(MY_ALLOW_ZERO_PTR));
  396.   DBUG_VOID_RETURN;
  397. }
  398. File RaidFd::
  399. Create(const char *FileName, int CreateFlags, int access_flags, myf MyFlags)
  400. {
  401.   char RaidFdFileName[FN_REFLEN];
  402.   DBUG_ENTER("RaidFd::Create");
  403.   DBUG_PRINT("enter",
  404.      ("FileName: %s  CreateFlags: %d  access_flags: %d  MyFlags: %d",
  405.       FileName, CreateFlags, access_flags, MyFlags));
  406.   char DirName[FN_REFLEN];
  407.   uint pos = dirname_part(DirName, FileName);
  408.   MY_STAT status;
  409.   if (!_seek_vector)
  410.     DBUG_RETURN(-1); /* Not enough memory */
  411.   uint i = _raid_chunks-1;
  412.   do
  413.   {
  414.     /* Create subdir */
  415.     (void)sprintf(RaidFdFileName,"%s%02x", DirName,i);
  416.     unpack_dirname(RaidFdFileName,RaidFdFileName);   /* Convert if not unix */
  417.     if (my_stat(RaidFdFileName,&status, MYF(0)))
  418.     {
  419.       DBUG_PRINT("info",("%02x exists, skipping directory creation",i));
  420.     }
  421.     else
  422.     {
  423.       if (my_mkdir(RaidFdFileName,0777,MYF(0)))
  424.       {
  425. DBUG_PRINT("error",("mkdir failed for %d",i));
  426. goto error;
  427.       }
  428.     }
  429.     /* Create file */
  430.     sprintf(RaidFdFileName,"%s%02x/%s",DirName, i, FileName + pos);
  431.     unpack_filename(RaidFdFileName,RaidFdFileName); /* Convert if not unix */
  432.     _fd = my_create(RaidFdFileName, CreateFlags ,access_flags, (myf)MyFlags);
  433.     if (_fd < 0)
  434.       goto error;
  435.     _fd_vector[i]=_fd;
  436.     _seek_vector[i]=RAID_SEEK_DONE;
  437.   } while (i--);
  438.   _size=0;
  439.   DBUG_RETURN(_fd); /* Last filenr is pointer to map */
  440. error:
  441.   {
  442.     int save_errno=my_errno;
  443.     while (++i < _raid_chunks)
  444.     {
  445.       my_close(_fd_vector[i],MYF(0));
  446.       sprintf(RaidFdFileName,"%s%02x/%s",DirName, i, FileName + pos);
  447.       unpack_filename(RaidFdFileName,RaidFdFileName);
  448.       my_delete(RaidFdFileName,MYF(0));
  449.     }
  450.     my_errno=save_errno;
  451.   }
  452.   DBUG_RETURN(-1);
  453. }
  454. File RaidFd::
  455. Open(const char *FileName, int Flags, myf MyFlags)
  456. {
  457.   DBUG_ENTER("RaidFd::Open");
  458.   DBUG_PRINT("enter",("FileName: %s  Flags: %d  MyFlags: %d",
  459.    FileName, Flags, MyFlags));
  460.   char DirName[FN_REFLEN];
  461.   uint pos = dirname_part(DirName, FileName);
  462.   if (!_seek_vector)
  463.     DBUG_RETURN(-1); /* Not enough memory */
  464.   for( uint i = 0 ;  i < _raid_chunks ; i++ )
  465.   {
  466.     char RaidFdFileName[FN_REFLEN];
  467.     sprintf(RaidFdFileName,"%s%02x/%s",DirName, i, FileName + pos);
  468.     unpack_filename(RaidFdFileName,RaidFdFileName); /* Convert if not unix */
  469.     _fd = my_open(RaidFdFileName, Flags, MyFlags);
  470.     if (_fd < 0)
  471.     {
  472.       int save_errno=my_errno;
  473.       while (i-- != 0)
  474. my_close(_fd_vector[i],MYF(0));
  475.       my_errno=save_errno;
  476.       DBUG_RETURN(_fd);
  477.     }
  478.     _fd_vector[i]=_fd;
  479.     _seek_vector[i]=RAID_SEEK_DONE;
  480.   }
  481.   Seek(0L,MY_SEEK_END,MYF(0)); // Trick. We just need to know, how big the file is
  482.   DBUG_PRINT("info",("MYD file logical size: %llu", _size));
  483.   DBUG_RETURN(_fd);
  484. }
  485. int RaidFd::
  486. Write(const byte *Buffer, uint Count, myf MyFlags)
  487. {
  488.   DBUG_ENTER("RaidFd::Write");
  489.   DBUG_PRINT("enter",("Count: %d  MyFlags: %d",
  490.       Count, MyFlags));
  491.   const byte *bufptr = Buffer;
  492.   uint res=0, GotBytes, ReadNowCount;
  493.   // Loop until data is written
  494.   do {
  495.     Calculate();
  496.      // Do seeks when neccessary
  497.     if (_seek_vector[_this_block] != RAID_SEEK_DONE)
  498.     {
  499.       if (my_seek(_fd_vector[_this_block], _seek_vector[_this_block],
  500.   MY_SEEK_SET,
  501.   MyFlags) == MY_FILEPOS_ERROR)
  502. DBUG_RETURN(-1);
  503.       _seek_vector[_this_block]=RAID_SEEK_DONE;
  504.     }
  505.     ReadNowCount = min(Count, _remaining_bytes);
  506.     GotBytes = my_write(_fd_vector[_this_block], bufptr, ReadNowCount,
  507. MyFlags);
  508.     DBUG_PRINT("loop",("Wrote bytes: %d", GotBytes));
  509.     if (GotBytes == MY_FILE_ERROR)
  510.       DBUG_RETURN(-1);
  511.     res+= GotBytes;
  512.     if (MyFlags & (MY_NABP | MY_FNABP))
  513.       GotBytes=ReadNowCount;
  514.     bufptr += GotBytes;
  515.     Count  -= GotBytes;
  516.     _position += GotBytes;
  517.   } while(Count);
  518.   set_if_bigger(_size,_position);
  519.   DBUG_RETURN(res);
  520. }
  521. int RaidFd::
  522. Read(const byte *Buffer, uint Count, myf MyFlags)
  523. {
  524.   DBUG_ENTER("RaidFd::Read");
  525.   DBUG_PRINT("enter",("Count: %d  MyFlags: %d",
  526.       Count, MyFlags));
  527.   byte *bufptr = (byte *)Buffer;
  528.   uint res= 0, GotBytes, ReadNowCount;
  529.   // Loop until all data is read (Note that Count may be 0)
  530.   while (Count)
  531.   {
  532.     Calculate();
  533.     // Do seek when neccessary
  534.     if (_seek_vector[_this_block] != RAID_SEEK_DONE)
  535.     {
  536.       if (my_seek(_fd_vector[_this_block], _seek_vector[_this_block],
  537.   MY_SEEK_SET,
  538.   MyFlags) == MY_FILEPOS_ERROR)
  539. DBUG_RETURN(-1);
  540.       _seek_vector[_this_block]=RAID_SEEK_DONE;
  541.     }
  542.     // and read
  543.     ReadNowCount = min(Count, _remaining_bytes);
  544.     GotBytes = my_read(_fd_vector[_this_block], bufptr, ReadNowCount,
  545.        MyFlags & ~(MY_NABP | MY_FNABP));
  546.     DBUG_PRINT("loop",("Got bytes: %u", GotBytes));
  547.     if (GotBytes == MY_FILE_ERROR)
  548.       DBUG_RETURN(-1);
  549.     if (!GotBytes) // End of file.
  550.     {
  551.       DBUG_RETURN((MyFlags & (MY_NABP | MY_FNABP)) ? -1 : (int) res);
  552.     }
  553.     res+= GotBytes;
  554.     bufptr += GotBytes;
  555.     Count  -= GotBytes;
  556.     _position += GotBytes;
  557.   }
  558.   DBUG_RETURN((MyFlags & (MY_NABP | MY_FNABP)) ? 0 : res);
  559. }
  560. int RaidFd::
  561. Lock(int locktype, my_off_t start, my_off_t length, myf MyFlags)
  562. {
  563.   DBUG_ENTER("RaidFd::Lock");
  564.   DBUG_PRINT("enter",("locktype: %d  start: %lu  length: %lu  MyFlags: %d",
  565.       locktype, start, length, MyFlags));
  566.   my_off_t bufptr = start;
  567.   // Loop until all data is locked
  568.   while(length)
  569.   {
  570.     Calculate();
  571.     for (uint i = _this_block ; (i < _raid_chunks) && length ; i++ )
  572.     {
  573.        uint ReadNowCount = min(length, _remaining_bytes);
  574.        uint GotBytes = my_lock(_fd_vector[i], locktype, bufptr, ReadNowCount,
  575. MyFlags);
  576.        if ((int) GotBytes == -1)
  577.  DBUG_RETURN(-1);
  578.        bufptr += ReadNowCount;
  579.        length  -= ReadNowCount;
  580.        Calculate();
  581.     }
  582.   }
  583.   DBUG_RETURN(0);
  584. }
  585. int RaidFd::
  586. Close(myf MyFlags)
  587. {
  588.   DBUG_ENTER("RaidFd::Close");
  589.   DBUG_PRINT("enter",("MyFlags: %d",
  590.    MyFlags));
  591.   for (uint i = 0 ; i < _raid_chunks ; ++i )
  592.   {
  593.     int err = my_close(_fd_vector[i], MyFlags);
  594.     if (err != 0)
  595.       DBUG_RETURN(err);
  596.   }
  597.   /* _fd_vector is erased when RaidFd is released */
  598.   DBUG_RETURN(0);
  599. }
  600. my_off_t RaidFd::
  601. Seek(my_off_t pos,int whence,myf MyFlags)
  602. {
  603.   DBUG_ENTER("RaidFd::Seek");
  604.   DBUG_PRINT("enter",("Pos: %lu  Whence: %d  MyFlags: %d",
  605.    (ulong) pos, whence, MyFlags));
  606.   switch (whence) {
  607.   case MY_SEEK_CUR:
  608.     // FIXME: This is wrong, what is going on there
  609.     // Just I am relied on fact that MySQL 3.23.7 never uses MY_SEEK_CUR
  610.     // for anything else except things like ltell()
  611.     break;
  612.   case MY_SEEK_SET:
  613.     if ( _position != pos) // we can be already in right place
  614.     {
  615.       uint i;
  616.       off_t _rounds;
  617.       _position = pos;
  618.       Calculate();
  619.       _rounds = _total_block / _raid_chunks;     // INT() assumed
  620.       _rounds*= _raid_chunksize;
  621.       for (i = 0; i < _raid_chunks ; i++ )
  622. if ( i < _this_block )
  623.   _seek_vector[i] = _rounds + _raid_chunksize;
  624. else if ( i == _this_block )
  625.   _seek_vector[i] = _rounds + _raid_chunksize -_remaining_bytes;
  626. else // if ( i > _this_block )
  627.   _seek_vector[i] = _rounds;
  628.     }
  629.     break;
  630.   case MY_SEEK_END:
  631.     if (_size==RAID_SIZE_UNKNOWN) // We don't know table size yet
  632.     {
  633.       uint i;
  634.       _position = 0;
  635.       for (i = 0; i < _raid_chunks ; i++ )
  636.       {
  637. my_off_t newpos = my_seek(_fd_vector[i], 0L, MY_SEEK_END, MyFlags);
  638. if (newpos == MY_FILEPOS_ERROR)
  639.   DBUG_RETURN (MY_FILEPOS_ERROR);
  640. _seek_vector[i]=RAID_SEEK_DONE;
  641. _position += newpos;
  642.       }
  643.       _size=_position;
  644.     }
  645.     else if (_position != _size) // Aren't we also already in the end?
  646.     {
  647.       uint i;
  648.       off_t _rounds;
  649.       _position = _size;
  650.       Calculate();
  651.       _rounds = _total_block / _raid_chunks;     // INT() assumed
  652.       _rounds*= _raid_chunksize;
  653.       for (i = 0; i < _raid_chunks ; i++ )
  654. if ( i < _this_block )
  655.   _seek_vector[i] = _rounds + _raid_chunksize;
  656. else if ( i == _this_block )
  657.   _seek_vector[i] = _rounds + _raid_chunksize - _remaining_bytes;
  658. else // if ( i > _this_block )
  659.   _seek_vector[i] = _rounds;
  660.       _position=_size;
  661.     }
  662.   }
  663.   DBUG_RETURN(_position);
  664. }
  665. my_off_t RaidFd::
  666. Tell(myf MyFlags)
  667. {
  668.   DBUG_ENTER("RaidFd::Tell");
  669.   DBUG_PRINT("enter",("MyFlags: %d _position %d",
  670.    MyFlags,_position));
  671.   DBUG_RETURN(_position);
  672. }
  673. int RaidFd::
  674. Chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
  675. {
  676.   DBUG_ENTER("RaidFd::Chsize");
  677.   DBUG_PRINT("enter",("Fd: %d, newlength: %d, MyFlags: %d",
  678.    fd, newlength,MyFlags));
  679.   _position = newlength;
  680.   Calculate();
  681.   uint _rounds = _total_block / _raid_chunks;      // INT() assumed
  682.   for (uint i = 0; i < _raid_chunks ; i++ )
  683.   {
  684.     int newpos;
  685.     if ( i < _this_block )
  686.       newpos = my_chsize(_fd_vector[i],
  687.  _this_block * _raid_chunksize + (_rounds + 1) *
  688.  _raid_chunksize, filler, MyFlags);
  689.     else if ( i == _this_block )
  690.       newpos = my_chsize(_fd_vector[i],
  691.  _this_block * _raid_chunksize + _rounds *
  692.  _raid_chunksize + (newlength % _raid_chunksize),
  693.  filler, MyFlags);
  694.     else // this means: i > _this_block
  695.       newpos = my_chsize(_fd_vector[i],
  696.  _this_block * _raid_chunksize + _rounds *
  697.  _raid_chunksize, filler, MyFlags);
  698.     if (newpos)
  699.       DBUG_RETURN(1);
  700.   }
  701.   DBUG_RETURN(0);
  702. }
  703. int RaidFd::
  704. Fstat(int fd, MY_STAT *stat_area, myf MyFlags )
  705. {
  706.   DBUG_ENTER("RaidFd::Fstat");
  707.   DBUG_PRINT("enter",("fd: %d MyFlags: %d",fd,MyFlags));
  708.   uint i;
  709.   int error=0;
  710.   MY_STAT status;
  711.   stat_area->st_size=0;
  712.   stat_area->st_mtime=0;
  713.   stat_area->st_atime=0;
  714.   stat_area->st_ctime=0;
  715.   for(i=0 ; i < _raid_chunks ; i++)
  716.   {
  717.     if (my_fstat(_fd_vector[i],&status,MyFlags))
  718.       error=1;
  719.     stat_area->st_size+=status.st_size;
  720.     set_if_bigger(stat_area->st_mtime,status.st_mtime);
  721.     set_if_bigger(stat_area->st_atime,status.st_atime);
  722.     set_if_bigger(stat_area->st_ctime,status.st_ctime);
  723.   }
  724.   DBUG_RETURN(error);
  725. }
  726. #endif /* defined(USE_RAID) && !defined(MYSQL_CLIENT) */