database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-10-30 04:26:45 +03:00
Code Activity
Files
0963c705cd6aa875cd86c91afa749b4619d59e6c
mariadb/mysys/raid.cc
monty@mysql.com 775f17667b Merge with 4.1
2005-06-07 00:31:53 +03:00

800 lines
23 KiB
C++
Raw Blame History

/* Copyright (C) 2000 MySQL AB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/*
RAID support for MySQL. Raid 0 (stiping) only implemented yet.
Why RAID? Why it must be in MySQL?
This is because then you can:
1. Have bigger tables than your OS limit. In time of writing this
we are hitting to 2GB limit under linux/ext2
2. You can get more speed from IO bottleneck by putting
Raid dirs on different physical disks.
3. Getting more fault tolerance (not implemented yet)
Why not to use RAID:
1. You are losing some processor power to calculate things,
do more syscalls and interrupts.
Functionality is supplied by two classes: RaidFd and RaidName.
RaidFd supports funtionality over file descriptors like
open/create/write/seek/close. RaidName supports functionality
like rename/delete where we have no relations to filedescriptors.
RaidName can be prorably unchanged for different Raid levels. RaidFd
have to be virtual I think ;).
You can speed up some calls in MySQL code by skipping RAID code.
For example LOAD DATA INFILE never needs to read RAID-ed files.
This can be done adding proper "#undef my_read" or similar undef-s
in your code. Check out the raid.h!
Some explanation about _seek_vector[]
This is seek cache. RAID seeks too much and we cacheing this. We
fool it and just storing new position in file to _seek_vector.
When there is no seeks to do, we are putting RAID_SEEK_DONE into it.
Any other value requires seeking to that position.
TODO:
- Implement other fancy things like RAID 1 (mirroring) and RAID 5.
Should not to be very complex.
- Optimize big blob writes by resorting write buffers and writing
big chunks at once instead of doing many syscalls. - after thinking I
found this is useless. This is because same thing one can do with just
increasing RAID_CHUNKSIZE. Monty, what do you think? tonu.
- If needed, then implement missing syscalls. One known to miss is stat();
- Make and use a thread safe dynamic_array buffer. The used one
will not work if needs to be extended at the same time someone is
accessing it.
tonu@mysql.com & monty@mysql.com
*/
#ifdef USE_PRAGMA_IMPLEMENTATION
#pragma implementation // gcc: Class implementation
#endif
#include "mysys_priv.h"
#include <my_dir.h>
#include <m_string.h>
#include <assert.h>
#if defined(USE_RAID) && !defined(MYSQL_CLIENT)
#define RAID_SEEK_DONE ~(off_t) 0
#define RAID_SIZE_UNKNOWN ~(my_off_t) 0
DYNAMIC_ARRAY RaidFd::_raid_map;
/* --------------- C compatibility ---------------*/
extern "C" {
void init_raid(void)
{
/* Allocate memory for global file to raid map */
my_init_dynamic_array(&RaidFd::_raid_map, sizeof(RaidFd*), 4096, 1024);
}
void end_raid(void)
{
/* Free memory used by raid */
delete_dynamic(&RaidFd::_raid_map);
}
bool is_raid(File fd)
{
return RaidFd::IsRaid(fd);
}
File my_raid_create(const char *FileName, int CreateFlags, int access_flags,
uint raid_type, uint raid_chunks, ulong raid_chunksize,
myf MyFlags)
{
DBUG_ENTER("my_raid_create");
DBUG_PRINT("enter",("Filename: %s CreateFlags: %d access_flags: %d MyFlags: %d",
FileName, CreateFlags, access_flags, MyFlags));
if (raid_type)
{
RaidFd *raid = new RaidFd(raid_type, raid_chunks , raid_chunksize);
File res = raid->Create(FileName,CreateFlags,access_flags,MyFlags);
if (res < 0 || set_dynamic(&RaidFd::_raid_map,(char*) &raid,res))
{
delete raid;
DBUG_RETURN(-1);
}
DBUG_RETURN(res);
}
else
DBUG_RETURN(my_create(FileName, CreateFlags, access_flags, MyFlags));
}
File my_raid_open(const char *FileName, int Flags,
uint raid_type, uint raid_chunks, ulong raid_chunksize,
myf MyFlags)
{
DBUG_ENTER("my_raid_open");
DBUG_PRINT("enter",("Filename: %s Flags: %d MyFlags: %d",
FileName, Flags, MyFlags));
if (raid_type)
{
RaidFd *raid = new RaidFd(raid_type, raid_chunks , raid_chunksize);
File res = raid->Open(FileName,Flags,MyFlags);
if (res < 0 || set_dynamic(&RaidFd::_raid_map,(char*) &raid,res))
{
delete raid;
DBUG_RETURN(-1);
}
DBUG_RETURN(res);
}
else
DBUG_RETURN(my_open(FileName, Flags, MyFlags));
}
my_off_t my_raid_seek(File fd, my_off_t pos,int whence,myf MyFlags)
{
DBUG_ENTER("my_raid_seek");
DBUG_PRINT("enter",("Fd: %d pos: %lu whence: %d MyFlags: %d",
fd, (ulong) pos, whence, MyFlags));
if (is_raid(fd))
{
assert(pos != MY_FILEPOS_ERROR);
RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
DBUG_RETURN(raid->Seek(pos,whence,MyFlags));
}
else
DBUG_RETURN(my_seek(fd, pos, whence, MyFlags));
}
my_off_t my_raid_tell(File fd,myf MyFlags)
{
DBUG_ENTER("my_raid_tell");
DBUG_PRINT("enter",("Fd: %d MyFlags: %d",
fd, MyFlags));
if (is_raid(fd))
{
RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
DBUG_RETURN(raid->Tell(MyFlags));
}
else
DBUG_RETURN(my_tell(fd, MyFlags));
}
uint my_raid_write(File fd,const byte *Buffer, uint Count, myf MyFlags)
{
DBUG_ENTER("my_raid_write");
DBUG_PRINT("enter",("Fd: %d Buffer: 0x%lx Count: %u MyFlags: %d",
fd, Buffer, Count, MyFlags));
if (is_raid(fd))
{
RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
DBUG_RETURN(raid->Write(Buffer,Count,MyFlags));
} else
DBUG_RETURN(my_write(fd,Buffer,Count,MyFlags));
}
uint my_raid_read(File fd, byte *Buffer, uint Count, myf MyFlags)
{
DBUG_ENTER("my_raid_read");
DBUG_PRINT("enter",("Fd: %d Buffer: 0x%lx Count: %u MyFlags: %d",
fd, Buffer, Count, MyFlags));
if (is_raid(fd))
{
RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
DBUG_RETURN(raid->Read(Buffer,Count,MyFlags));
} else
DBUG_RETURN(my_read(fd,Buffer,Count,MyFlags));
}
uint my_raid_pread(File Filedes, byte *Buffer, uint Count, my_off_t offset,
myf MyFlags)
{
DBUG_ENTER("my_raid_pread");
DBUG_PRINT("enter",
("Fd: %d Buffer: 0x%lx Count: %u offset: %u MyFlags: %d",
Filedes, Buffer, Count, offset, MyFlags));
if (is_raid(Filedes))
{
assert(offset != MY_FILEPOS_ERROR);
RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,Filedes,RaidFd**));
/* Returning value isn't important because real seek is done later. */
raid->Seek(offset,MY_SEEK_SET,MyFlags);
DBUG_RETURN(raid->Read(Buffer,Count,MyFlags));
}
else
DBUG_RETURN(my_pread(Filedes, Buffer, Count, offset, MyFlags));
}
uint my_raid_pwrite(int Filedes, const byte *Buffer, uint Count,
my_off_t offset, myf MyFlags)
{
DBUG_ENTER("my_raid_pwrite");
DBUG_PRINT("enter",
("Fd: %d Buffer: 0x %lx Count: %u offset: %u MyFlags: %d",
Filedes, Buffer, Count, offset, MyFlags));
if (is_raid(Filedes))
{
assert(offset != MY_FILEPOS_ERROR);
RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,Filedes,RaidFd**));
/* Returning value isn't important because real seek is done later. */
raid->Seek(offset,MY_SEEK_SET,MyFlags);
DBUG_RETURN(raid->Write(Buffer,Count,MyFlags));
}
else
DBUG_RETURN(my_pwrite(Filedes, Buffer, Count, offset, MyFlags));
}
int my_raid_lock(File fd, int locktype, my_off_t start, my_off_t length,
myf MyFlags)
{
DBUG_ENTER("my_raid_lock");
DBUG_PRINT("enter",("Fd: %d start: %u length: %u MyFlags: %d",
fd, start, length, MyFlags));
if (my_disable_locking)
DBUG_RETURN(0);
if (is_raid(fd))
{
RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
DBUG_RETURN(raid->Lock(locktype, start, length, MyFlags));
}
else
DBUG_RETURN(my_lock(fd, locktype, start, length, MyFlags));
}
int my_raid_close(File fd, myf MyFlags)
{
DBUG_ENTER("my_raid_close");
DBUG_PRINT("enter",("Fd: %d MyFlags: %d",
fd, MyFlags));
if (is_raid(fd))
{
RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
RaidFd *tmp=0;
set_dynamic(&RaidFd::_raid_map,(char*) &tmp,fd);
int res = raid->Close(MyFlags);
delete raid;
DBUG_RETURN(res);
}
else
DBUG_RETURN(my_close(fd, MyFlags));
}
int my_raid_chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
{
DBUG_ENTER("my_raid_chsize");
DBUG_PRINT("enter",("Fd: %d newlength: %u MyFlags: %d",
fd, newlength, MyFlags));
if (is_raid(fd))
{
RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
DBUG_RETURN(raid->Chsize(fd, newlength, filler, MyFlags));
}
else
DBUG_RETURN(my_chsize(fd, newlength, filler, MyFlags));
}
int my_raid_rename(const char *from, const char *to,
uint raid_chunks, myf MyFlags)
{
char from_tmp[FN_REFLEN];
char to_tmp[FN_REFLEN];
DBUG_ENTER("my_raid_rename");
uint from_pos = dirname_length(from);
uint to_pos = dirname_length(to);
memcpy(from_tmp, from, from_pos);
memcpy(to_tmp, to, to_pos);
for (uint i = 0 ; i < raid_chunks ; i++ )
{
sprintf(from_tmp+from_pos,"%02x/%s", i, from + from_pos);
sprintf(to_tmp+to_pos,"%02x/%s", i, to+ to_pos);
/* Convert if not unix */
unpack_filename(from_tmp, from_tmp);
unpack_filename(to_tmp,to_tmp);
if (my_rename(from_tmp, to_tmp, MyFlags))
DBUG_RETURN(-1);
}
DBUG_RETURN(0);
}
int my_raid_delete(const char *from, uint raid_chunks, myf MyFlags)
{
char from_tmp[FN_REFLEN];
uint from_pos = dirname_length(from);
DBUG_ENTER("my_raid_delete");
if (!raid_chunks)
DBUG_RETURN(my_delete(from,MyFlags));
for (uint i = 0 ; i < raid_chunks ; i++ )
{
memcpy(from_tmp, from, from_pos);
sprintf(from_tmp+from_pos,"%02x/%s", i, from + from_pos);
/* Convert if not unix */
unpack_filename(from_tmp, from_tmp);
if (my_delete(from_tmp, MyFlags))
DBUG_RETURN(-1);
}
DBUG_RETURN(0);
}
int my_raid_redel(const char *old_name, const char *new_name,
uint raid_chunks, myf MyFlags)
{
char new_name_buff[FN_REFLEN], old_name_buff[FN_REFLEN];
char *new_end, *old_end;
uint i,old_length,new_length;
int error=0;
DBUG_ENTER("my_raid_redel");
old_end=old_name_buff+dirname_part(old_name_buff,old_name);
old_length=dirname_length(old_name);
new_end=new_name_buff+dirname_part(new_name_buff,new_name);
new_length=dirname_length(new_name);
for (i=0 ; i < raid_chunks ; i++)
{
MY_STAT status;
sprintf(new_end,"%02x",i);
if (my_stat(new_name_buff,&status, MYF(0)))
{
DBUG_PRINT("info",("%02x exists, skipping directory creation",i));
}
else
{
if (my_mkdir(new_name_buff,0777,MYF(0)))
{
DBUG_PRINT("error",("mkdir failed for %02x",i));
DBUG_RETURN(-1);
}
}
strxmov(strend(new_end),"/",new_name+new_length,NullS);
sprintf(old_end,"%02x/%s",i, old_name+old_length);
if (my_redel(old_name_buff, new_name_buff, MyFlags))
error=1;
}
DBUG_RETURN(error);
}
}
int my_raid_fstat(int fd, MY_STAT *stat_area, myf MyFlags )
{
DBUG_ENTER("my_raid_fstat");
if (is_raid(fd))
{
RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
DBUG_RETURN(raid->Fstat(fd, stat_area, MyFlags));
}
else
DBUG_RETURN(my_fstat(fd, stat_area, MyFlags));
}
/* -------------- RaidFd base class begins ----------------*/
/*
RaidFd - raided file is identified by file descriptor
this is useful when we open/write/read/close files
*/
bool RaidFd::
IsRaid(File fd)
{
DBUG_ENTER("RaidFd::IsRaid");
DBUG_RETURN((uint) fd < _raid_map.elements &&
*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
}
RaidFd::
RaidFd(uint raid_type, uint raid_chunks, ulong raid_chunksize)
:_raid_type(raid_type), _raid_chunks(raid_chunks),
_raid_chunksize(raid_chunksize), _position(0), _size(RAID_SIZE_UNKNOWN),
_fd_vector(0)
{
DBUG_ENTER("RaidFd::RaidFd");
DBUG_PRINT("enter",("RaidFd_type: %u Disks: %u Chunksize: %d",
raid_type, raid_chunks, raid_chunksize));
/* TODO: Here we should add checks if the malloc fails */
_seek_vector=0; /* In case of errors */
my_multi_malloc(MYF(MY_WME),
&_seek_vector,sizeof(off_t)*_raid_chunks,
&_fd_vector, sizeof(File) *_raid_chunks,
NullS);
if (!RaidFd::_raid_map.buffer)
{ /* Not initied */
pthread_mutex_lock(&THR_LOCK_open); /* Ensure that no other thread */
if (!RaidFd::_raid_map.buffer) /* has done init in between */
init_raid();
pthread_mutex_unlock(&THR_LOCK_open);
}
DBUG_VOID_RETURN;
}
RaidFd::
~RaidFd() {
DBUG_ENTER("RaidFd::~RaidFd");
/* We don't have to free _fd_vector ! */
my_free((char*) _seek_vector, MYF(MY_ALLOW_ZERO_PTR));
DBUG_VOID_RETURN;
}
File RaidFd::
Create(const char *FileName, int CreateFlags, int access_flags, myf MyFlags)
{
char RaidFdFileName[FN_REFLEN];
DBUG_ENTER("RaidFd::Create");
DBUG_PRINT("enter",
("FileName: %s CreateFlags: %d access_flags: %d MyFlags: %d",
FileName, CreateFlags, access_flags, MyFlags));
char DirName[FN_REFLEN];
uint pos = dirname_part(DirName, FileName);
MY_STAT status;
if (!_seek_vector)
DBUG_RETURN(-1); /* Not enough memory */
uint i = _raid_chunks-1;
do
{
/* Create subdir */
(void)sprintf(RaidFdFileName,"%s%02x", DirName,i);
unpack_dirname(RaidFdFileName,RaidFdFileName); /* Convert if not unix */
if (my_stat(RaidFdFileName,&status, MYF(0)))
{
DBUG_PRINT("info",("%02x exists, skipping directory creation",i));
}
else
{
if (my_mkdir(RaidFdFileName,0777,MYF(0)))
{
DBUG_PRINT("error",("mkdir failed for %d",i));
goto error;
}
}
/* Create file */
sprintf(RaidFdFileName,"%s%02x/%s",DirName, i, FileName + pos);
unpack_filename(RaidFdFileName,RaidFdFileName); /* Convert if not unix */
_fd = my_create(RaidFdFileName, CreateFlags ,access_flags, (myf)MyFlags);
if (_fd < 0)
goto error;
_fd_vector[i]=_fd;
_seek_vector[i]=RAID_SEEK_DONE;
} while (i--);
_size=0;
DBUG_RETURN(_fd); /* Last filenr is pointer to map */
error:
{
int save_errno=my_errno;
while (++i < _raid_chunks)
{
my_close(_fd_vector[i],MYF(0));
sprintf(RaidFdFileName,"%s%02x/%s",DirName, i, FileName + pos);
unpack_filename(RaidFdFileName,RaidFdFileName);
my_delete(RaidFdFileName,MYF(0));
}
my_errno=save_errno;
}
DBUG_RETURN(-1);
}
File RaidFd::
Open(const char *FileName, int Flags, myf MyFlags)
{
DBUG_ENTER("RaidFd::Open");
DBUG_PRINT("enter",("FileName: %s Flags: %d MyFlags: %d",
FileName, Flags, MyFlags));
char DirName[FN_REFLEN];
uint pos = dirname_part(DirName, FileName);
if (!_seek_vector)
DBUG_RETURN(-1); /* Not enough memory */
for( uint i = 0 ; i < _raid_chunks ; i++ )
{
char RaidFdFileName[FN_REFLEN];
sprintf(RaidFdFileName,"%s%02x/%s",DirName, i, FileName + pos);
unpack_filename(RaidFdFileName,RaidFdFileName); /* Convert if not unix */
_fd = my_open(RaidFdFileName, Flags, MyFlags);
if (_fd < 0)
{
int save_errno=my_errno;
while (i-- != 0)
my_close(_fd_vector[i],MYF(0));
my_errno=save_errno;
DBUG_RETURN(_fd);
}
_fd_vector[i]=_fd;
_seek_vector[i]=RAID_SEEK_DONE;
}
Seek(0L,MY_SEEK_END,MYF(0)); // Trick. We just need to know, how big the file is
DBUG_PRINT("info",("MYD file logical size: %llu", _size));
DBUG_RETURN(_fd);
}
int RaidFd::
Write(const byte *Buffer, uint Count, myf MyFlags)
{
DBUG_ENTER("RaidFd::Write");
DBUG_PRINT("enter",("Count: %d MyFlags: %d",
Count, MyFlags));
const byte *bufptr = Buffer;
uint res=0, GotBytes, ReadNowCount;
// Loop until data is written
do {
Calculate();
// Do seeks when neccessary
if (_seek_vector[_this_block] != RAID_SEEK_DONE)
{
if (my_seek(_fd_vector[_this_block], _seek_vector[_this_block],
MY_SEEK_SET,
MyFlags) == MY_FILEPOS_ERROR)
DBUG_RETURN(-1);
_seek_vector[_this_block]=RAID_SEEK_DONE;
}
ReadNowCount = min(Count, _remaining_bytes);
GotBytes = my_write(_fd_vector[_this_block], bufptr, ReadNowCount,
MyFlags);
DBUG_PRINT("loop",("Wrote bytes: %d", GotBytes));
if (GotBytes == MY_FILE_ERROR)
DBUG_RETURN(-1);
res+= GotBytes;
if (MyFlags & (MY_NABP | MY_FNABP))
GotBytes=ReadNowCount;
bufptr += GotBytes;
Count -= GotBytes;
_position += GotBytes;
} while(Count);
set_if_bigger(_size,_position);
DBUG_RETURN(res);
}
int RaidFd::
Read(const byte *Buffer, uint Count, myf MyFlags)
{
DBUG_ENTER("RaidFd::Read");
DBUG_PRINT("enter",("Count: %d MyFlags: %d",
Count, MyFlags));
byte *bufptr = (byte *)Buffer;
uint res= 0, GotBytes, ReadNowCount;
// Loop until all data is read (Note that Count may be 0)
while (Count)
{
Calculate();
// Do seek when neccessary
if (_seek_vector[_this_block] != RAID_SEEK_DONE)
{
if (my_seek(_fd_vector[_this_block], _seek_vector[_this_block],
MY_SEEK_SET,
MyFlags) == MY_FILEPOS_ERROR)
DBUG_RETURN(-1);
_seek_vector[_this_block]=RAID_SEEK_DONE;
}
// and read
ReadNowCount = min(Count, _remaining_bytes);
GotBytes = my_read(_fd_vector[_this_block], bufptr, ReadNowCount,
MyFlags & ~(MY_NABP | MY_FNABP));
DBUG_PRINT("loop",("Got bytes: %u", GotBytes));
if (GotBytes == MY_FILE_ERROR)
DBUG_RETURN(-1);
if (!GotBytes) // End of file.
{
DBUG_RETURN((MyFlags & (MY_NABP | MY_FNABP)) ? -1 : (int) res);
}
res+= GotBytes;
bufptr += GotBytes;
Count -= GotBytes;
_position += GotBytes;
}
DBUG_RETURN((MyFlags & (MY_NABP | MY_FNABP)) ? 0 : res);
}
int RaidFd::
Lock(int locktype, my_off_t start, my_off_t length, myf MyFlags)
{
DBUG_ENTER("RaidFd::Lock");
DBUG_PRINT("enter",("locktype: %d start: %lu length: %lu MyFlags: %d",
locktype, start, length, MyFlags));
my_off_t bufptr = start;
// Loop until all data is locked
while(length)
{
Calculate();
for (uint i = _this_block ; (i < _raid_chunks) && length ; i++ )
{
uint ReadNowCount = min(length, _remaining_bytes);
uint GotBytes = my_lock(_fd_vector[i], locktype, bufptr, ReadNowCount,
MyFlags);
if ((int) GotBytes == -1)
DBUG_RETURN(-1);
bufptr += ReadNowCount;
length -= ReadNowCount;
Calculate();
}
}
DBUG_RETURN(0);
}
int RaidFd::
Close(myf MyFlags)
{
DBUG_ENTER("RaidFd::Close");
DBUG_PRINT("enter",("MyFlags: %d",
MyFlags));
for (uint i = 0 ; i < _raid_chunks ; ++i )
{
int err = my_close(_fd_vector[i], MyFlags);
if (err != 0)
DBUG_RETURN(err);
}
/* _fd_vector is erased when RaidFd is released */
DBUG_RETURN(0);
}
my_off_t RaidFd::
Seek(my_off_t pos,int whence,myf MyFlags)
{
DBUG_ENTER("RaidFd::Seek");
DBUG_PRINT("enter",("Pos: %lu Whence: %d MyFlags: %d",
(ulong) pos, whence, MyFlags));
switch (whence) {
case MY_SEEK_CUR:
// FIXME: This is wrong, what is going on there
// Just I am relied on fact that MySQL 3.23.7 never uses MY_SEEK_CUR
// for anything else except things like ltell()
break;
case MY_SEEK_SET:
if ( _position != pos) // we can be already in right place
{
uint i;
off_t _rounds;
_position = pos;
Calculate();
_rounds = _total_block / _raid_chunks; // INT() assumed
_rounds*= _raid_chunksize;
for (i = 0; i < _raid_chunks ; i++ )
if ( i < _this_block )
_seek_vector[i] = _rounds + _raid_chunksize;
else if ( i == _this_block )
_seek_vector[i] = _rounds + _raid_chunksize -_remaining_bytes;
else // if ( i > _this_block )
_seek_vector[i] = _rounds;
}
break;
case MY_SEEK_END:
if (_size==RAID_SIZE_UNKNOWN) // We don't know table size yet
{
uint i;
_position = 0;
for (i = 0; i < _raid_chunks ; i++ )
{
my_off_t newpos = my_seek(_fd_vector[i], 0L, MY_SEEK_END, MyFlags);
if (newpos == MY_FILEPOS_ERROR)
DBUG_RETURN (MY_FILEPOS_ERROR);
_seek_vector[i]=RAID_SEEK_DONE;
_position += newpos;
}
_size=_position;
}
else if (_position != _size) // Aren't we also already in the end?
{
uint i;
off_t _rounds;
_position = _size;
Calculate();
_rounds = _total_block / _raid_chunks; // INT() assumed
_rounds*= _raid_chunksize;
for (i = 0; i < _raid_chunks ; i++ )
if ( i < _this_block )
_seek_vector[i] = _rounds + _raid_chunksize;
else if ( i == _this_block )
_seek_vector[i] = _rounds + _raid_chunksize - _remaining_bytes;
else // if ( i > _this_block )
_seek_vector[i] = _rounds;
_position=_size;
}
}
DBUG_RETURN(_position);
}
my_off_t RaidFd::
Tell(myf MyFlags)
{
DBUG_ENTER("RaidFd::Tell");
DBUG_PRINT("enter",("MyFlags: %d _position %d",
MyFlags,_position));
DBUG_RETURN(_position);
}
int RaidFd::
Chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
{
DBUG_ENTER("RaidFd::Chsize");
DBUG_PRINT("enter",("Fd: %d, newlength: %d, MyFlags: %d",
fd, newlength,MyFlags));
_position = newlength;
Calculate();
uint _rounds = _total_block / _raid_chunks; // INT() assumed
for (uint i = 0; i < _raid_chunks ; i++ )
{
int newpos;
if ( i < _this_block )
newpos = my_chsize(_fd_vector[i],
_this_block * _raid_chunksize + (_rounds + 1) *
_raid_chunksize, filler, MyFlags);
else if ( i == _this_block )
newpos = my_chsize(_fd_vector[i],
_this_block * _raid_chunksize + _rounds *
_raid_chunksize + (newlength % _raid_chunksize),
filler, MyFlags);
else // this means: i > _this_block
newpos = my_chsize(_fd_vector[i],
_this_block * _raid_chunksize + _rounds *
_raid_chunksize, filler, MyFlags);
if (newpos)
DBUG_RETURN(1);
}
DBUG_RETURN(0);
}
int RaidFd::
Fstat(int fd, MY_STAT *stat_area, myf MyFlags )
{
DBUG_ENTER("RaidFd::Fstat");
DBUG_PRINT("enter",("fd: %d MyFlags: %d",fd,MyFlags));
uint i;
int error=0;
MY_STAT status;
stat_area->st_size=0;
stat_area->st_mtime=0;
stat_area->st_atime=0;
stat_area->st_ctime=0;
for(i=0 ; i < _raid_chunks ; i++)
{
if (my_fstat(_fd_vector[i],&status,MyFlags))
error=1;
stat_area->st_size+=status.st_size;
set_if_bigger(stat_area->st_mtime,status.st_mtime);
set_if_bigger(stat_area->st_atime,status.st_atime);
set_if_bigger(stat_area->st_ctime,status.st_ctime);
}
DBUG_RETURN(error);
}
#endif /* defined(USE_RAID) && !defined(MYSQL_CLIENT) */
View Git Blame Copy Permalink