This patch cleans up two tests which were a bit fragile from other failing tests. It also removes some variables associated with removed RAID support.
This commit is contained in:
brian@zim.(none)
parent
85869e5fde
commit
cb07d52a7e
@ -18,7 +18,7 @@
|
|||||||
BUILT_SOURCES = mysql_version.h m_ctype.h my_config.h
|
BUILT_SOURCES = mysql_version.h m_ctype.h my_config.h
|
||||||
pkginclude_HEADERS = my_dbug.h m_string.h my_sys.h my_list.h my_xml.h \
|
pkginclude_HEADERS = my_dbug.h m_string.h my_sys.h my_list.h my_xml.h \
|
||||||
mysql.h mysql_com.h mysql_embed.h \
|
mysql.h mysql_com.h mysql_embed.h \
|
||||||
my_semaphore.h my_pthread.h my_no_pthread.h raid.h \
|
my_semaphore.h my_pthread.h my_no_pthread.h \
|
||||||
errmsg.h my_global.h my_net.h my_alloc.h \
|
errmsg.h my_global.h my_net.h my_alloc.h \
|
||||||
my_getopt.h sslopt-longopts.h my_dir.h typelib.h \
|
my_getopt.h sslopt-longopts.h my_dir.h typelib.h \
|
||||||
sslopt-vars.h sslopt-case.h sql_common.h keycache.h \
|
sslopt-vars.h sslopt-case.h sql_common.h keycache.h \
|
||||||
|
|||||||
@ -915,5 +915,4 @@ void netware_reg_user(const char *ip, const char *user,
|
|||||||
#endif
|
#endif
|
||||||
|
|
||||||
C_MODE_END
|
C_MODE_END
|
||||||
#include "raid.h"
|
|
||||||
#endif /* _my_sys_h */
|
#endif /* _my_sys_h */
|
||||||
|
|||||||
@ -159,8 +159,6 @@ typedef struct st_mi_isaminfo /* Struct from h_info */
|
|||||||
uint reflength;
|
uint reflength;
|
||||||
ulong record_offset;
|
ulong record_offset;
|
||||||
ulong *rec_per_key; /* for sql optimizing */
|
ulong *rec_per_key; /* for sql optimizing */
|
||||||
uint raid_type,raid_chunks;
|
|
||||||
ulong raid_chunksize;
|
|
||||||
} MI_ISAMINFO;
|
} MI_ISAMINFO;
|
||||||
|
|
||||||
|
|
||||||
@ -172,8 +170,6 @@ typedef struct st_mi_create_info
|
|||||||
ulonglong auto_increment;
|
ulonglong auto_increment;
|
||||||
ulonglong data_file_length;
|
ulonglong data_file_length;
|
||||||
ulonglong key_file_length;
|
ulonglong key_file_length;
|
||||||
uint raid_type,raid_chunks;
|
|
||||||
ulong raid_chunksize;
|
|
||||||
uint old_options;
|
uint old_options;
|
||||||
uint8 language;
|
uint8 language;
|
||||||
my_bool with_auto_increment;
|
my_bool with_auto_increment;
|
||||||
|
|||||||
159
include/raid.h
159
include/raid.h
@ -1,159 +0,0 @@
|
|||||||
/* 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 */
|
|
||||||
|
|
||||||
/* Parser needs these defines always, even if USE_RAID is not defined */
|
|
||||||
#define RAID_TYPE_0 1 /* Striping */
|
|
||||||
#define RAID_TYPE_x 2 /* Some new modes */
|
|
||||||
#define RAID_TYPE_y 3
|
|
||||||
|
|
||||||
#define RAID_DEFAULT_CHUNKS 4
|
|
||||||
#define RAID_DEFAULT_CHUNKSIZE 256*1024 /* 256kB */
|
|
||||||
|
|
||||||
C_MODE_START
|
|
||||||
#define my_raid_type(raid_type) raid_type_string[(int)(raid_type)]
|
|
||||||
extern const char *raid_type_string[];
|
|
||||||
C_MODE_END
|
|
||||||
|
|
||||||
#ifdef DONT_USE_RAID
|
|
||||||
#undef USE_RAID
|
|
||||||
#endif
|
|
||||||
#if defined(USE_RAID)
|
|
||||||
|
|
||||||
#include "my_dir.h"
|
|
||||||
|
|
||||||
/* Trap all occurences of my_...() in source and use our wrapper around this function */
|
|
||||||
|
|
||||||
#ifdef MAP_TO_USE_RAID
|
|
||||||
#define my_read(A,B,C,D) my_raid_read(A,B,C,D)
|
|
||||||
#define my_write(A,B,C,D) my_raid_write(A,B,C,D)
|
|
||||||
#define my_pwrite(A,B,C,D,E) my_raid_pwrite(A,B,C,D,E)
|
|
||||||
#define my_pread(A,B,C,D,E) my_raid_pread(A,B,C,D,E)
|
|
||||||
#define my_chsize(A,B,C,D) my_raid_chsize(A,B,C,D)
|
|
||||||
#define my_close(A,B) my_raid_close(A,B)
|
|
||||||
#define my_tell(A,B) my_raid_tell(A,B)
|
|
||||||
#define my_seek(A,B,C,D) my_raid_seek(A,B,C,D)
|
|
||||||
#define my_lock(A,B,C,D,E) my_raid_lock(A,B,C,D,E)
|
|
||||||
#define my_fstat(A,B,C) my_raid_fstat(A,B,C)
|
|
||||||
#endif /* MAP_TO_USE_RAID */
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void init_raid(void);
|
|
||||||
void end_raid(void);
|
|
||||||
|
|
||||||
bool is_raid(File fd);
|
|
||||||
File my_raid_create(const char *FileName, int CreateFlags, int access_flags,
|
|
||||||
uint raid_type, uint raid_chunks, ulong raid_chunksize,
|
|
||||||
myf MyFlags);
|
|
||||||
File my_raid_open(const char *FileName, int Flags,
|
|
||||||
uint raid_type, uint raid_chunks, ulong raid_chunksize,
|
|
||||||
myf MyFlags);
|
|
||||||
int my_raid_rename(const char *from, const char *to, uint raid_chunks,
|
|
||||||
myf MyFlags);
|
|
||||||
int my_raid_delete(const char *from, uint raid_chunks, myf MyFlags);
|
|
||||||
int my_raid_redel(const char *old_name, const char *new_name,
|
|
||||||
uint raid_chunks, myf MyFlags);
|
|
||||||
|
|
||||||
my_off_t my_raid_seek(File fd, my_off_t pos, int whence, myf MyFlags);
|
|
||||||
my_off_t my_raid_tell(File fd, myf MyFlags);
|
|
||||||
|
|
||||||
uint my_raid_write(File,const byte *Buffer, uint Count, myf MyFlags);
|
|
||||||
uint my_raid_read(File Filedes, byte *Buffer, uint Count, myf MyFlags);
|
|
||||||
|
|
||||||
uint my_raid_pread(File Filedes, byte *Buffer, uint Count, my_off_t offset,
|
|
||||||
myf MyFlags);
|
|
||||||
uint my_raid_pwrite(int Filedes, const byte *Buffer, uint Count,
|
|
||||||
my_off_t offset, myf MyFlags);
|
|
||||||
|
|
||||||
int my_raid_lock(File,int locktype, my_off_t start, my_off_t length,
|
|
||||||
myf MyFlags);
|
|
||||||
int my_raid_chsize(File fd, my_off_t newlength, int filler, myf MyFlags);
|
|
||||||
int my_raid_close(File, myf MyFlags);
|
|
||||||
int my_raid_fstat(int Filedes, struct stat *buf, myf MyFlags);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef USE_PRAGMA_INTERFACE
|
|
||||||
#pragma interface /* gcc class implementation */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
class RaidName {
|
|
||||||
public:
|
|
||||||
RaidName(const char *FileName);
|
|
||||||
~RaidName();
|
|
||||||
bool IsRaid();
|
|
||||||
int Rename(const char * from, const char * to, myf MyFlags);
|
|
||||||
private:
|
|
||||||
uint _raid_type; /* RAID_TYPE_0 or RAID_TYPE_1 or RAID_TYPE_5 */
|
|
||||||
uint _raid_chunks; /* 1..n */
|
|
||||||
ulong _raid_chunksize; /* 1..n in bytes */
|
|
||||||
};
|
|
||||||
|
|
||||||
class RaidFd {
|
|
||||||
public:
|
|
||||||
RaidFd(uint raid_type, uint raid_chunks , ulong raid_chunksize);
|
|
||||||
~RaidFd();
|
|
||||||
File Create(const char *FileName, int CreateFlags, int access_flags,
|
|
||||||
myf MyFlags);
|
|
||||||
File Open(const char *FileName, int Flags, myf MyFlags);
|
|
||||||
my_off_t Seek(my_off_t pos,int whence,myf MyFlags);
|
|
||||||
my_off_t Tell(myf MyFlags);
|
|
||||||
int Write(const byte *Buffer, uint Count, myf MyFlags);
|
|
||||||
int Read(const byte *Buffer, uint Count, myf MyFlags);
|
|
||||||
int Lock(int locktype, my_off_t start, my_off_t length, myf MyFlags);
|
|
||||||
int Chsize(File fd, my_off_t newlength, int filler, myf MyFlags);
|
|
||||||
int Fstat(int fd, MY_STAT *stat_area, myf MyFlags );
|
|
||||||
int Close(myf MyFlags);
|
|
||||||
static bool IsRaid(File fd);
|
|
||||||
static DYNAMIC_ARRAY _raid_map; /* Map of RaidFD* */
|
|
||||||
private:
|
|
||||||
|
|
||||||
uint _raid_type; /* RAID_TYPE_0 or RAID_TYPE_1 or RAID_TYPE_5 */
|
|
||||||
uint _raid_chunks; /* 1..n */
|
|
||||||
ulong _raid_chunksize; /* 1..n in bytes */
|
|
||||||
|
|
||||||
ulong _total_block; /* We are operating with block no x (can be 0..many). */
|
|
||||||
uint _this_block; /* can be 0.._raid_chunks */
|
|
||||||
uint _remaining_bytes; /* Maximum bytes that can be written in this block */
|
|
||||||
|
|
||||||
my_off_t _position;
|
|
||||||
my_off_t _size; /* Cached file size for faster seek(SEEK_END) */
|
|
||||||
File _fd;
|
|
||||||
File *_fd_vector; /* Array of File */
|
|
||||||
off_t *_seek_vector; /* Array of cached seek positions */
|
|
||||||
|
|
||||||
inline void Calculate()
|
|
||||||
{
|
|
||||||
DBUG_ENTER("RaidFd::_Calculate");
|
|
||||||
DBUG_PRINT("info",("_position: %lu _raid_chunksize: %d, _size: %lu",
|
|
||||||
(ulong) _position, _raid_chunksize, (ulong) _size));
|
|
||||||
|
|
||||||
_total_block = (ulong) (_position / _raid_chunksize);
|
|
||||||
_this_block = _total_block % _raid_chunks; /* can be 0.._raid_chunks */
|
|
||||||
_remaining_bytes = (uint) (_raid_chunksize -
|
|
||||||
(_position - _total_block * _raid_chunksize));
|
|
||||||
DBUG_PRINT("info",
|
|
||||||
("_total_block: %d this_block: %d _remaining_bytes:%d",
|
|
||||||
_total_block, _this_block, _remaining_bytes));
|
|
||||||
DBUG_VOID_RETURN;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif /* __cplusplus */
|
|
||||||
#endif /* USE_RAID */
|
|
||||||
@ -1,4 +1,4 @@
|
|||||||
drop table if exists t1;
|
drop table if exists t1,t2;
|
||||||
select CASE "b" when "a" then 1 when "b" then 2 END;
|
select CASE "b" when "a" then 1 when "b" then 2 END;
|
||||||
CASE "b" when "a" then 1 when "b" then 2 END
|
CASE "b" when "a" then 1 when "b" then 2 END
|
||||||
2
|
2
|
||||||
|
|||||||
@ -1,3 +1,5 @@
|
|||||||
|
DROP SCHEMA test;
|
||||||
|
CREATE SCHEMA test;
|
||||||
cluster_replication.binlog_index OK
|
cluster_replication.binlog_index OK
|
||||||
mysql.columns_priv OK
|
mysql.columns_priv OK
|
||||||
mysql.db OK
|
mysql.db OK
|
||||||
|
|||||||
@ -3,7 +3,7 @@
|
|||||||
#
|
#
|
||||||
|
|
||||||
--disable_warnings
|
--disable_warnings
|
||||||
drop table if exists t1;
|
drop table if exists t1,t2;
|
||||||
--enable_warnings
|
--enable_warnings
|
||||||
|
|
||||||
select CASE "b" when "a" then 1 when "b" then 2 END;
|
select CASE "b" when "a" then 1 when "b" then 2 END;
|
||||||
|
|||||||
@ -5,6 +5,8 @@
|
|||||||
# depends on the presence of the log tables (which are CSV-based).
|
# depends on the presence of the log tables (which are CSV-based).
|
||||||
--source include/have_csv.inc
|
--source include/have_csv.inc
|
||||||
|
|
||||||
|
DROP SCHEMA test;
|
||||||
|
CREATE SCHEMA test;
|
||||||
#
|
#
|
||||||
# Bug #13783 mysqlcheck tries to optimize and analyze information_schema
|
# Bug #13783 mysqlcheck tries to optimize and analyze information_schema
|
||||||
#
|
#
|
||||||
|
|||||||
@ -51,7 +51,7 @@ libmysys_a_SOURCES = my_init.c my_getwd.c mf_getdate.c my_mmap.c \
|
|||||||
my_quick.c my_lockmem.c my_static.c \
|
my_quick.c my_lockmem.c my_static.c \
|
||||||
my_sync.c my_getopt.c my_mkdir.c \
|
my_sync.c my_getopt.c my_mkdir.c \
|
||||||
default_modify.c default.c \
|
default_modify.c default.c \
|
||||||
my_compress.c checksum.c raid.cc \
|
my_compress.c checksum.c \
|
||||||
my_net.c my_semaphore.c my_port.c my_sleep.c \
|
my_net.c my_semaphore.c my_port.c my_sleep.c \
|
||||||
charset.c charset-def.c my_bitmap.c my_bit.c md5.c \
|
charset.c charset-def.c my_bitmap.c my_bit.c md5.c \
|
||||||
my_gethostbyname.c rijndael.c my_aes.c sha1.c \
|
my_gethostbyname.c rijndael.c my_aes.c sha1.c \
|
||||||
|
|||||||
@ -92,13 +92,6 @@ struct st_irem *sf_malloc_root = NULL;
|
|||||||
int volatile my_have_got_alarm=0; /* declare variable to reset */
|
int volatile my_have_got_alarm=0; /* declare variable to reset */
|
||||||
ulong my_time_to_wait_for_lock=2; /* In seconds */
|
ulong my_time_to_wait_for_lock=2; /* In seconds */
|
||||||
|
|
||||||
/*
|
|
||||||
We need to have this define here as otherwise linking will fail
|
|
||||||
on OSF1 when compiling --without-raid --with-debug
|
|
||||||
*/
|
|
||||||
|
|
||||||
const char *raid_type_string[]={"none","striped"};
|
|
||||||
|
|
||||||
/* from errors.c */
|
/* from errors.c */
|
||||||
#ifdef SHARED_LIBRARY
|
#ifdef SHARED_LIBRARY
|
||||||
char * NEAR globerrs[GLOBERRS]; /* my_error_messages is here */
|
char * NEAR globerrs[GLOBERRS]; /* my_error_messages is here */
|
||||||
|
|||||||
799
mysys/raid.cc
799
mysys/raid.cc
@ -1,799 +0,0 @@
|
|||||||
/* 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) */
|
|
||||||
@ -1,31 +0,0 @@
|
|||||||
/* Copyright (C) 2002 MySQL AB
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Library General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library 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
|
|
||||||
Library General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Library General Public
|
|
||||||
License along with this library; if not, write to the Free
|
|
||||||
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
|
|
||||||
MA 02111-1307, USA */
|
|
||||||
|
|
||||||
/*
|
|
||||||
RAID support for MySQL. For full comments, check raid.cc
|
|
||||||
This is in a separate file to not cause problems on OS that can't
|
|
||||||
put C++ files in archives.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "mysys_priv.h"
|
|
||||||
|
|
||||||
const char *raid_type_string[]={"none","striped"};
|
|
||||||
|
|
||||||
const char *my_raid_type(int raid_type)
|
|
||||||
{
|
|
||||||
return raid_type_string[raid_type];
|
|
||||||
}
|
|
||||||
@ -3900,9 +3900,6 @@ int recreate_table(MI_CHECK *param, MI_INFO **org_info, char *filename)
|
|||||||
|
|
||||||
create_info.data_file_length=file_length;
|
create_info.data_file_length=file_length;
|
||||||
create_info.auto_increment=share.state.auto_increment;
|
create_info.auto_increment=share.state.auto_increment;
|
||||||
create_info.raid_type= share.base.raid_type;
|
|
||||||
create_info.raid_chunks= share.base.raid_chunks;
|
|
||||||
create_info.raid_chunksize= share.base.raid_chunksize;
|
|
||||||
create_info.language = (param->language ? param->language :
|
create_info.language = (param->language ? param->language :
|
||||||
share.state.header.language);
|
share.state.header.language);
|
||||||
create_info.key_file_length= status_info.key_file_length;
|
create_info.key_file_length= status_info.key_file_length;
|
||||||
|
|||||||
@ -85,13 +85,6 @@ int mi_status(MI_INFO *info, register MI_ISAMINFO *x, uint flag)
|
|||||||
x->key_map = share->state.key_map;
|
x->key_map = share->state.key_map;
|
||||||
x->data_file_name = share->data_file_name;
|
x->data_file_name = share->data_file_name;
|
||||||
x->index_file_name = share->index_file_name;
|
x->index_file_name = share->index_file_name;
|
||||||
/*
|
|
||||||
The following should be included even if we are not compiling with
|
|
||||||
USE_RAID as the client must be able to request it!
|
|
||||||
*/
|
|
||||||
x->raid_type= share->base.raid_type;
|
|
||||||
x->raid_chunks= share->base.raid_chunks;
|
|
||||||
x->raid_chunksize= share->base.raid_chunksize;
|
|
||||||
}
|
}
|
||||||
if ((flag & HA_STATUS_TIME) && !my_fstat(info->dfile,&state,MYF(0)))
|
if ((flag & HA_STATUS_TIME) && !my_fstat(info->dfile,&state,MYF(0)))
|
||||||
x->update_time=state.st_mtime;
|
x->update_time=state.st_mtime;
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user