mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 20:42:30 +01:00
3960c84f12
Gluh's SESSION/GLOBAL for @variables fix in sql_yacc.yy and Bar's well_formed_len() changes in ndb code did not make it and should be re-applied manually BitKeeper/etc/logging_ok: auto-union include/m_ctype.h: Auto merged innobase/btr/btr0pcur.c: Auto merged innobase/include/btr0pcur.h: Auto merged innobase/include/os0file.h: Auto merged innobase/os/os0file.c: Auto merged innobase/row/row0sel.c: Auto merged innobase/srv/srv0start.c: Auto merged mysql-test/r/user_var.result: Auto merged mysql-test/t/user_var.test: Auto merged ndb/include/ndbapi/NdbTransaction.hpp: Auto merged ndb/src/ndbapi/NdbTransaction.cpp: Auto merged ndb/tools/desc.cpp: Auto merged strings/ctype-big5.c: Auto merged strings/ctype-mb.c: Auto merged strings/ctype-simple.c: Auto merged strings/ctype-sjis.c: Auto merged strings/ctype-ucs2.c: Auto merged strings/ctype-ujis.c: Auto merged BitKeeper/deleted/.del-NdbResultSet.cpp~84d192cf3f42600d: ul ndb/include/ndbapi/NdbScanOperation.hpp: ul ndb/src/ndbapi/NdbIndexOperation.cpp: ul ndb/src/ndbapi/NdbOperationDefine.cpp: ul ndb/src/ndbapi/NdbOperationSearch.cpp: ul ndb/src/ndbapi/NdbScanOperation.cpp: ul sql/field.cc: manually merged, because bk messed it up sql/sql_yacc.yy: merged
4243 lines
101 KiB
C
4243 lines
101 KiB
C
/******************************************************
|
||
The interface to the operating system file i/o primitives
|
||
|
||
(c) 1995 Innobase Oy
|
||
|
||
Created 10/21/1995 Heikki Tuuri
|
||
*******************************************************/
|
||
|
||
#include "os0file.h"
|
||
#include "os0sync.h"
|
||
#include "os0thread.h"
|
||
#include "ut0mem.h"
|
||
#include "srv0srv.h"
|
||
#include "srv0start.h"
|
||
#include "fil0fil.h"
|
||
#include "buf0buf.h"
|
||
|
||
#if defined(UNIV_HOTBACKUP) && defined(__WIN__)
|
||
/* Add includes for the _stat() call to compile on Windows */
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
#include <errno.h>
|
||
#endif /* UNIV_HOTBACKUP */
|
||
|
||
#undef HAVE_FDATASYNC
|
||
|
||
#ifdef POSIX_ASYNC_IO
|
||
/* We assume in this case that the OS has standard Posix aio (at least SunOS
|
||
2.6, HP-UX 11i and AIX 4.3 have) */
|
||
|
||
#endif
|
||
|
||
/* This specifies the file permissions InnoDB uses when it creates files in
|
||
Unix; the value of os_innodb_umask is initialized in ha_innodb.cc to
|
||
my_umask */
|
||
|
||
#ifndef __WIN__
|
||
ulint os_innodb_umask = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
|
||
#else
|
||
ulint os_innodb_umask = 0;
|
||
#endif
|
||
|
||
/* If the following is set to TRUE, we do not call os_file_flush in every
|
||
os_file_write. We can set this TRUE when the doublewrite buffer is used. */
|
||
ibool os_do_not_call_flush_at_each_write = FALSE;
|
||
|
||
/* We use these mutexes to protect lseek + file i/o operation, if the
|
||
OS does not provide an atomic pread or pwrite, or similar */
|
||
#define OS_FILE_N_SEEK_MUTEXES 16
|
||
os_mutex_t os_file_seek_mutexes[OS_FILE_N_SEEK_MUTEXES];
|
||
|
||
/* In simulated aio, merge at most this many consecutive i/os */
|
||
#define OS_AIO_MERGE_N_CONSECUTIVE 64
|
||
|
||
/* If this flag is TRUE, then we will use the native aio of the
|
||
OS (provided we compiled Innobase with it in), otherwise we will
|
||
use simulated aio we build below with threads */
|
||
|
||
ibool os_aio_use_native_aio = FALSE;
|
||
|
||
ibool os_aio_print_debug = FALSE;
|
||
|
||
/* The aio array slot structure */
|
||
typedef struct os_aio_slot_struct os_aio_slot_t;
|
||
|
||
struct os_aio_slot_struct{
|
||
ibool is_read; /* TRUE if a read operation */
|
||
ulint pos; /* index of the slot in the aio
|
||
array */
|
||
ibool reserved; /* TRUE if this slot is reserved */
|
||
time_t reservation_time;/* time when reserved */
|
||
ulint len; /* length of the block to read or
|
||
write */
|
||
byte* buf; /* buffer used in i/o */
|
||
ulint type; /* OS_FILE_READ or OS_FILE_WRITE */
|
||
ulint offset; /* 32 low bits of file offset in
|
||
bytes */
|
||
ulint offset_high; /* 32 high bits of file offset */
|
||
os_file_t file; /* file where to read or write */
|
||
const char* name; /* file name or path */
|
||
ibool io_already_done;/* used only in simulated aio:
|
||
TRUE if the physical i/o already
|
||
made and only the slot message
|
||
needs to be passed to the caller
|
||
of os_aio_simulated_handle */
|
||
void* message1; /* message which is given by the */
|
||
void* message2; /* the requester of an aio operation
|
||
and which can be used to identify
|
||
which pending aio operation was
|
||
completed */
|
||
#ifdef WIN_ASYNC_IO
|
||
os_event_t event; /* event object we need in the
|
||
OVERLAPPED struct */
|
||
OVERLAPPED control; /* Windows control block for the
|
||
aio request */
|
||
#elif defined(POSIX_ASYNC_IO)
|
||
struct aiocb control; /* Posix control block for aio
|
||
request */
|
||
#endif
|
||
};
|
||
|
||
/* The aio array structure */
|
||
typedef struct os_aio_array_struct os_aio_array_t;
|
||
|
||
struct os_aio_array_struct{
|
||
os_mutex_t mutex; /* the mutex protecting the aio array */
|
||
os_event_t not_full; /* The event which is set to the signaled
|
||
state when there is space in the aio
|
||
outside the ibuf segment */
|
||
os_event_t is_empty; /* The event which is set to the signaled
|
||
state when there are no pending i/os
|
||
in this array */
|
||
ulint n_slots; /* Total number of slots in the aio array.
|
||
This must be divisible by n_threads. */
|
||
ulint n_segments;/* Number of segments in the aio array of
|
||
pending aio requests. A thread can wait
|
||
separately for any one of the segments. */
|
||
ulint n_reserved;/* Number of reserved slots in the
|
||
aio array outside the ibuf segment */
|
||
os_aio_slot_t* slots; /* Pointer to the slots in the array */
|
||
#ifdef __WIN__
|
||
os_native_event_t* native_events;
|
||
/* Pointer to an array of OS native event
|
||
handles where we copied the handles from
|
||
slots, in the same order. This can be used
|
||
in WaitForMultipleObjects; used only in
|
||
Windows */
|
||
#endif
|
||
};
|
||
|
||
/* Array of events used in simulated aio */
|
||
os_event_t* os_aio_segment_wait_events = NULL;
|
||
|
||
/* The aio arrays for non-ibuf i/o and ibuf i/o, as well as sync aio. These
|
||
are NULL when the module has not yet been initialized. */
|
||
os_aio_array_t* os_aio_read_array = NULL;
|
||
os_aio_array_t* os_aio_write_array = NULL;
|
||
os_aio_array_t* os_aio_ibuf_array = NULL;
|
||
os_aio_array_t* os_aio_log_array = NULL;
|
||
os_aio_array_t* os_aio_sync_array = NULL;
|
||
|
||
ulint os_aio_n_segments = ULINT_UNDEFINED;
|
||
|
||
/* If the following is TRUE, read i/o handler threads try to
|
||
wait until a batch of new read requests have been posted */
|
||
ibool os_aio_recommend_sleep_for_read_threads = FALSE;
|
||
|
||
ulint os_n_file_reads = 0;
|
||
ulint os_bytes_read_since_printout = 0;
|
||
ulint os_n_file_writes = 0;
|
||
ulint os_n_fsyncs = 0;
|
||
ulint os_n_file_reads_old = 0;
|
||
ulint os_n_file_writes_old = 0;
|
||
ulint os_n_fsyncs_old = 0;
|
||
time_t os_last_printout;
|
||
|
||
ibool os_has_said_disk_full = FALSE;
|
||
|
||
/* The mutex protecting the following counts of pending pread and pwrite
|
||
operations */
|
||
os_mutex_t os_file_count_mutex;
|
||
ulint os_file_n_pending_preads = 0;
|
||
ulint os_file_n_pending_pwrites = 0;
|
||
|
||
/* These are not protected by any mutex */
|
||
ulint os_n_pending_writes = 0;
|
||
ulint os_n_pending_reads = 0;
|
||
|
||
/***************************************************************************
|
||
Gets the operating system version. Currently works only on Windows. */
|
||
|
||
ulint
|
||
os_get_os_version(void)
|
||
/*===================*/
|
||
/* out: OS_WIN95, OS_WIN31, OS_WINNT, OS_WIN2000 */
|
||
{
|
||
#ifdef __WIN__
|
||
OSVERSIONINFO os_info;
|
||
|
||
os_info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
||
|
||
ut_a(GetVersionEx(&os_info));
|
||
|
||
if (os_info.dwPlatformId == VER_PLATFORM_WIN32s) {
|
||
return(OS_WIN31);
|
||
} else if (os_info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
|
||
return(OS_WIN95);
|
||
} else if (os_info.dwPlatformId == VER_PLATFORM_WIN32_NT) {
|
||
if (os_info.dwMajorVersion <= 4) {
|
||
return(OS_WINNT);
|
||
} else {
|
||
return(OS_WIN2000);
|
||
}
|
||
} else {
|
||
ut_error;
|
||
return(0);
|
||
}
|
||
#else
|
||
ut_error;
|
||
|
||
return(0);
|
||
#endif
|
||
}
|
||
|
||
/***************************************************************************
|
||
Retrieves the last error number if an error occurs in a file io function.
|
||
The number should be retrieved before any other OS calls (because they may
|
||
overwrite the error number). If the number is not known to this program,
|
||
the OS error number + 100 is returned. */
|
||
|
||
ulint
|
||
os_file_get_last_error(
|
||
/*===================*/
|
||
/* out: error number, or OS error
|
||
number + 100 */
|
||
ibool report_all_errors) /* in: TRUE if we want an error message
|
||
printed of all errors */
|
||
{
|
||
ulint err;
|
||
|
||
#ifdef __WIN__
|
||
|
||
err = (ulint) GetLastError();
|
||
|
||
if (report_all_errors
|
||
|| (err != ERROR_DISK_FULL && err != ERROR_FILE_EXISTS)) {
|
||
|
||
ut_print_timestamp(stderr);
|
||
fprintf(stderr,
|
||
" InnoDB: Operating system error number %lu in a file operation.\n", (ulong) err);
|
||
|
||
if (err == ERROR_PATH_NOT_FOUND) {
|
||
fprintf(stderr,
|
||
"InnoDB: The error means the system cannot find the path specified.\n");
|
||
|
||
if (srv_is_being_started) {
|
||
fprintf(stderr,
|
||
"InnoDB: If you are installing InnoDB, remember that you must create\n"
|
||
"InnoDB: directories yourself, InnoDB does not create them.\n");
|
||
}
|
||
} else if (err == ERROR_ACCESS_DENIED) {
|
||
fprintf(stderr,
|
||
"InnoDB: The error means mysqld does not have the access rights to\n"
|
||
"InnoDB: the directory. It may also be you have created a subdirectory\n"
|
||
"InnoDB: of the same name as a data file.\n");
|
||
} else {
|
||
fprintf(stderr,
|
||
"InnoDB: Some operating system error numbers are described at\n"
|
||
"InnoDB: "
|
||
"http://dev.mysql.com/doc/mysql/en/Operating_System_error_codes.html\n");
|
||
}
|
||
}
|
||
|
||
fflush(stderr);
|
||
|
||
if (err == ERROR_FILE_NOT_FOUND) {
|
||
return(OS_FILE_NOT_FOUND);
|
||
} else if (err == ERROR_DISK_FULL) {
|
||
return(OS_FILE_DISK_FULL);
|
||
} else if (err == ERROR_FILE_EXISTS) {
|
||
return(OS_FILE_ALREADY_EXISTS);
|
||
} else {
|
||
return(100 + err);
|
||
}
|
||
#else
|
||
err = (ulint) errno;
|
||
|
||
if (report_all_errors
|
||
|| (err != ENOSPC && err != EEXIST)) {
|
||
|
||
ut_print_timestamp(stderr);
|
||
fprintf(stderr,
|
||
" InnoDB: Operating system error number %lu in a file operation.\n", (ulong) err);
|
||
|
||
if (err == ENOENT) {
|
||
fprintf(stderr,
|
||
"InnoDB: The error means the system cannot find the path specified.\n");
|
||
|
||
if (srv_is_being_started) {
|
||
fprintf(stderr,
|
||
"InnoDB: If you are installing InnoDB, remember that you must create\n"
|
||
"InnoDB: directories yourself, InnoDB does not create them.\n");
|
||
}
|
||
} else if (err == EACCES) {
|
||
fprintf(stderr,
|
||
"InnoDB: The error means mysqld does not have the access rights to\n"
|
||
"InnoDB: the directory.\n");
|
||
} else {
|
||
if (strerror((int)err) != NULL) {
|
||
fprintf(stderr,
|
||
"InnoDB: Error number %lu means '%s'.\n", err, strerror((int)err));
|
||
}
|
||
|
||
fprintf(stderr,
|
||
"InnoDB: Some operating system error numbers are described at\n"
|
||
"InnoDB: "
|
||
"http://dev.mysql.com/doc/mysql/en/Operating_System_error_codes.html\n");
|
||
}
|
||
}
|
||
|
||
fflush(stderr);
|
||
|
||
if (err == ENOSPC ) {
|
||
return(OS_FILE_DISK_FULL);
|
||
#ifdef POSIX_ASYNC_IO
|
||
} else if (err == EAGAIN) {
|
||
return(OS_FILE_AIO_RESOURCES_RESERVED);
|
||
#endif
|
||
} else if (err == ENOENT) {
|
||
return(OS_FILE_NOT_FOUND);
|
||
} else if (err == EEXIST) {
|
||
return(OS_FILE_ALREADY_EXISTS);
|
||
} else {
|
||
return(100 + err);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
/********************************************************************
|
||
Does error handling when a file operation fails. */
|
||
static
|
||
ibool
|
||
os_file_handle_error(
|
||
/*=================*/
|
||
/* out: TRUE if we should retry the
|
||
operation */
|
||
const char* name, /* in: name of a file or NULL */
|
||
const char* operation)/* in: operation */
|
||
{
|
||
ulint err;
|
||
|
||
err = os_file_get_last_error(FALSE);
|
||
|
||
if (err == OS_FILE_DISK_FULL) {
|
||
/* We only print a warning about disk full once */
|
||
|
||
if (os_has_said_disk_full) {
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
if (name) {
|
||
ut_print_timestamp(stderr);
|
||
fprintf(stderr,
|
||
" InnoDB: Encountered a problem with file %s\n", name);
|
||
}
|
||
|
||
ut_print_timestamp(stderr);
|
||
fprintf(stderr,
|
||
" InnoDB: Disk is full. Try to clean the disk to free space.\n");
|
||
|
||
os_has_said_disk_full = TRUE;
|
||
|
||
fflush(stderr);
|
||
|
||
return(FALSE);
|
||
|
||
} else if (err == OS_FILE_AIO_RESOURCES_RESERVED) {
|
||
|
||
return(TRUE);
|
||
|
||
} else if (err == OS_FILE_ALREADY_EXISTS) {
|
||
|
||
return(FALSE);
|
||
} else {
|
||
if (name) {
|
||
fprintf(stderr, "InnoDB: File name %s\n", name);
|
||
}
|
||
|
||
fprintf(stderr, "InnoDB: File operation call: '%s'.\n",
|
||
operation);
|
||
fprintf(stderr, "InnoDB: Cannot continue operation.\n");
|
||
|
||
fflush(stderr);
|
||
|
||
exit(1);
|
||
}
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
#undef USE_FILE_LOCK
|
||
#define USE_FILE_LOCK
|
||
#if defined(UNIV_HOTBACKUP) || defined(__WIN__) || defined(__FreeBSD__) || defined(__NETWARE__)
|
||
/* InnoDB Hot Backup does not lock the data files.
|
||
* On Windows, mandatory locking is used.
|
||
* On FreeBSD with LinuxThreads, advisory locking does not work properly.
|
||
*/
|
||
# undef USE_FILE_LOCK
|
||
#endif
|
||
#ifdef USE_FILE_LOCK
|
||
/********************************************************************
|
||
Obtain an exclusive lock on a file. */
|
||
static
|
||
int
|
||
os_file_lock(
|
||
/*=========*/
|
||
/* out: 0 on success */
|
||
int fd, /* in: file descriptor */
|
||
const char* name) /* in: file name */
|
||
{
|
||
struct flock lk;
|
||
lk.l_type = F_WRLCK;
|
||
lk.l_whence = SEEK_SET;
|
||
lk.l_start = lk.l_len = 0;
|
||
if (fcntl(fd, F_SETLK, &lk) == -1) {
|
||
fprintf(stderr,
|
||
"InnoDB: Unable to lock %s, error: %d\n", name, errno);
|
||
|
||
if (errno == EAGAIN || errno == EACCES) {
|
||
fprintf(stderr,
|
||
"InnoDB: Check that you do not already have another mysqld process\n"
|
||
"InnoDB: using the same InnoDB data or log files.\n");
|
||
}
|
||
|
||
return(-1);
|
||
}
|
||
|
||
return(0);
|
||
}
|
||
#endif /* USE_FILE_LOCK */
|
||
|
||
/********************************************************************
|
||
Does error handling when a file operation fails. */
|
||
static
|
||
ibool
|
||
os_file_handle_error_no_exit(
|
||
/*=========================*/
|
||
/* out: TRUE if we should retry the
|
||
operation */
|
||
const char* name, /* in: name of a file or NULL */
|
||
const char* operation)/* in: operation */
|
||
{
|
||
ulint err;
|
||
|
||
err = os_file_get_last_error(FALSE);
|
||
|
||
if (err == OS_FILE_DISK_FULL) {
|
||
/* We only print a warning about disk full once */
|
||
|
||
if (os_has_said_disk_full) {
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
if (name) {
|
||
ut_print_timestamp(stderr);
|
||
fprintf(stderr,
|
||
" InnoDB: Encountered a problem with file %s\n", name);
|
||
}
|
||
|
||
ut_print_timestamp(stderr);
|
||
fprintf(stderr,
|
||
" InnoDB: Disk is full. Try to clean the disk to free space.\n");
|
||
|
||
os_has_said_disk_full = TRUE;
|
||
|
||
fflush(stderr);
|
||
|
||
return(FALSE);
|
||
|
||
} else if (err == OS_FILE_AIO_RESOURCES_RESERVED) {
|
||
|
||
return(TRUE);
|
||
|
||
} else if (err == OS_FILE_ALREADY_EXISTS) {
|
||
|
||
return(FALSE);
|
||
} else {
|
||
if (name) {
|
||
fprintf(stderr, "InnoDB: File name %s\n", name);
|
||
}
|
||
|
||
fprintf(stderr, "InnoDB: File operation call: '%s'.\n",
|
||
operation);
|
||
return (FALSE);
|
||
}
|
||
|
||
return(FALSE); /* not reached */
|
||
}
|
||
|
||
/********************************************************************
|
||
Creates the seek mutexes used in positioned reads and writes. */
|
||
|
||
void
|
||
os_io_init_simple(void)
|
||
/*===================*/
|
||
{
|
||
ulint i;
|
||
|
||
os_file_count_mutex = os_mutex_create(NULL);
|
||
|
||
for (i = 0; i < OS_FILE_N_SEEK_MUTEXES; i++) {
|
||
os_file_seek_mutexes[i] = os_mutex_create(NULL);
|
||
}
|
||
}
|
||
|
||
#if !defined(UNIV_HOTBACKUP) && !defined(__NETWARE__)
|
||
/*************************************************************************
|
||
Creates a temporary file. This function is defined in ha_innodb.cc. */
|
||
|
||
int
|
||
innobase_mysql_tmpfile(void);
|
||
/*========================*/
|
||
/* out: temporary file descriptor, or < 0 on error */
|
||
#endif /* !UNIV_HOTBACKUP && !__NETWARE__ */
|
||
|
||
/***************************************************************************
|
||
Creates a temporary file. */
|
||
|
||
FILE*
|
||
os_file_create_tmpfile(void)
|
||
/*========================*/
|
||
/* out: temporary file handle, or NULL on error */
|
||
{
|
||
#ifdef __NETWARE__
|
||
FILE* file = tmpfile();
|
||
#else /* __NETWARE__ */
|
||
FILE* file = NULL;
|
||
int fd = -1;
|
||
# ifdef UNIV_HOTBACKUP
|
||
int tries;
|
||
for (tries = 10; tries--; ) {
|
||
char* name = tempnam(fil_path_to_mysql_datadir, "ib");
|
||
if (!name) {
|
||
break;
|
||
}
|
||
|
||
fd = open(name,
|
||
# ifdef __WIN__
|
||
O_SEQUENTIAL | O_SHORT_LIVED | O_TEMPORARY |
|
||
# endif /* __WIN__ */
|
||
O_CREAT | O_EXCL | O_RDWR,
|
||
S_IREAD | S_IWRITE);
|
||
if (fd >= 0) {
|
||
# ifndef __WIN__
|
||
unlink(name);
|
||
# endif /* !__WIN__ */
|
||
free(name);
|
||
break;
|
||
}
|
||
|
||
ut_print_timestamp(stderr);
|
||
fprintf(stderr, " InnoDB: Warning: "
|
||
"unable to create temporary file %s, retrying\n",
|
||
name);
|
||
free(name);
|
||
}
|
||
# else /* UNIV_HOTBACKUP */
|
||
fd = innobase_mysql_tmpfile();
|
||
# endif /* UNIV_HOTBACKUP */
|
||
|
||
if (fd >= 0) {
|
||
file = fdopen(fd, "w+b");
|
||
}
|
||
#endif /* __NETWARE__ */
|
||
|
||
if (!file) {
|
||
ut_print_timestamp(stderr);
|
||
fprintf(stderr,
|
||
" InnoDB: Error: unable to create temporary file;"
|
||
" errno: %d\n", errno);
|
||
#ifndef __NETWARE__
|
||
if (fd >= 0) {
|
||
close(fd);
|
||
}
|
||
#endif /* !__NETWARE__ */
|
||
}
|
||
|
||
return(file);
|
||
}
|
||
|
||
/***************************************************************************
|
||
The os_file_opendir() function opens a directory stream corresponding to the
|
||
directory named by the dirname argument. The directory stream is positioned
|
||
at the first entry. In both Unix and Windows we automatically skip the '.'
|
||
and '..' items at the start of the directory listing. */
|
||
|
||
os_file_dir_t
|
||
os_file_opendir(
|
||
/*============*/
|
||
/* out: directory stream, NULL if
|
||
error */
|
||
const char* dirname, /* in: directory name; it must not
|
||
contain a trailing '\' or '/' */
|
||
ibool error_is_fatal) /* in: TRUE if we should treat an
|
||
error as a fatal error; if we try to
|
||
open symlinks then we do not wish a
|
||
fatal error if it happens not to be
|
||
a directory */
|
||
{
|
||
os_file_dir_t dir;
|
||
#ifdef __WIN__
|
||
LPWIN32_FIND_DATA lpFindFileData;
|
||
char path[OS_FILE_MAX_PATH + 3];
|
||
|
||
ut_a(strlen(dirname) < OS_FILE_MAX_PATH);
|
||
|
||
strcpy(path, dirname);
|
||
strcpy(path + strlen(path), "\\*");
|
||
|
||
/* Note that in Windows opening the 'directory stream' also retrieves
|
||
the first entry in the directory. Since it is '.', that is no problem,
|
||
as we will skip over the '.' and '..' entries anyway. */
|
||
|
||
lpFindFileData = ut_malloc(sizeof(WIN32_FIND_DATA));
|
||
|
||
dir = FindFirstFile(path, lpFindFileData);
|
||
|
||
ut_free(lpFindFileData);
|
||
|
||
if (dir == INVALID_HANDLE_VALUE) {
|
||
|
||
if (error_is_fatal) {
|
||
os_file_handle_error(dirname, "opendir");
|
||
}
|
||
|
||
return(NULL);
|
||
}
|
||
|
||
return(dir);
|
||
#else
|
||
dir = opendir(dirname);
|
||
|
||
if (dir == NULL && error_is_fatal) {
|
||
os_file_handle_error(dirname, "opendir");
|
||
}
|
||
|
||
return(dir);
|
||
#endif
|
||
}
|
||
|
||
/***************************************************************************
|
||
Closes a directory stream. */
|
||
|
||
int
|
||
os_file_closedir(
|
||
/*=============*/
|
||
/* out: 0 if success, -1 if failure */
|
||
os_file_dir_t dir) /* in: directory stream */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL ret;
|
||
|
||
ret = FindClose(dir);
|
||
|
||
if (!ret) {
|
||
os_file_handle_error_no_exit(NULL, "closedir");
|
||
|
||
return(-1);
|
||
}
|
||
|
||
return(0);
|
||
#else
|
||
int ret;
|
||
|
||
ret = closedir(dir);
|
||
|
||
if (ret) {
|
||
os_file_handle_error_no_exit(NULL, "closedir");
|
||
}
|
||
|
||
return(ret);
|
||
#endif
|
||
}
|
||
|
||
/***************************************************************************
|
||
This function returns information of the next file in the directory. We jump
|
||
over the '.' and '..' entries in the directory. */
|
||
|
||
int
|
||
os_file_readdir_next_file(
|
||
/*======================*/
|
||
/* out: 0 if ok, -1 if error, 1 if at the end
|
||
of the directory */
|
||
const char* dirname,/* in: directory name or path */
|
||
os_file_dir_t dir, /* in: directory stream */
|
||
os_file_stat_t* info) /* in/out: buffer where the info is returned */
|
||
{
|
||
#ifdef __WIN__
|
||
LPWIN32_FIND_DATA lpFindFileData;
|
||
BOOL ret;
|
||
|
||
lpFindFileData = ut_malloc(sizeof(WIN32_FIND_DATA));
|
||
next_file:
|
||
ret = FindNextFile(dir, lpFindFileData);
|
||
|
||
if (ret) {
|
||
ut_a(strlen(lpFindFileData->cFileName) < OS_FILE_MAX_PATH);
|
||
|
||
if (strcmp(lpFindFileData->cFileName, ".") == 0
|
||
|| strcmp(lpFindFileData->cFileName, "..") == 0) {
|
||
|
||
goto next_file;
|
||
}
|
||
|
||
strcpy(info->name, lpFindFileData->cFileName);
|
||
|
||
info->size = (ib_longlong)(lpFindFileData->nFileSizeLow)
|
||
+ (((ib_longlong)(lpFindFileData->nFileSizeHigh)) << 32);
|
||
|
||
if (lpFindFileData->dwFileAttributes
|
||
& FILE_ATTRIBUTE_REPARSE_POINT) {
|
||
/* TODO: test Windows symlinks */
|
||
/* TODO: MySQL has apparently its own symlink implementation in Windows,
|
||
dbname.sym can redirect a database directory:
|
||
http://www.mysql.com/doc/en/Windows_symbolic_links.html */
|
||
info->type = OS_FILE_TYPE_LINK;
|
||
} else if (lpFindFileData->dwFileAttributes
|
||
& FILE_ATTRIBUTE_DIRECTORY) {
|
||
info->type = OS_FILE_TYPE_DIR;
|
||
} else {
|
||
/* It is probably safest to assume that all other
|
||
file types are normal. Better to check them rather
|
||
than blindly skip them. */
|
||
|
||
info->type = OS_FILE_TYPE_FILE;
|
||
}
|
||
}
|
||
|
||
ut_free(lpFindFileData);
|
||
|
||
if (ret) {
|
||
return(0);
|
||
} else if (GetLastError() == ERROR_NO_MORE_FILES) {
|
||
|
||
return(1);
|
||
} else {
|
||
os_file_handle_error_no_exit(dirname,
|
||
"readdir_next_file");
|
||
return(-1);
|
||
}
|
||
#else
|
||
struct dirent* ent;
|
||
char* full_path;
|
||
int ret;
|
||
struct stat statinfo;
|
||
#ifdef HAVE_READDIR_R
|
||
char dirent_buf[sizeof(struct dirent) + _POSIX_PATH_MAX +
|
||
100];
|
||
/* In /mysys/my_lib.c, _POSIX_PATH_MAX + 1 is used as
|
||
the max file name len; but in most standards, the
|
||
length is NAME_MAX; we add 100 to be even safer */
|
||
#endif
|
||
|
||
next_file:
|
||
|
||
#ifdef HAVE_READDIR_R
|
||
ret = readdir_r(dir, (struct dirent*)dirent_buf, &ent);
|
||
|
||
if (ret != 0) {
|
||
fprintf(stderr,
|
||
"InnoDB: cannot read directory %s, error %lu\n", dirname, (ulong)ret);
|
||
|
||
return(-1);
|
||
}
|
||
|
||
if (ent == NULL) {
|
||
/* End of directory */
|
||
|
||
return(1);
|
||
}
|
||
|
||
ut_a(strlen(ent->d_name) < _POSIX_PATH_MAX + 100 - 1);
|
||
#else
|
||
ent = readdir(dir);
|
||
|
||
if (ent == NULL) {
|
||
|
||
return(1);
|
||
}
|
||
#endif
|
||
ut_a(strlen(ent->d_name) < OS_FILE_MAX_PATH);
|
||
|
||
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0) {
|
||
|
||
goto next_file;
|
||
}
|
||
|
||
strcpy(info->name, ent->d_name);
|
||
|
||
full_path = ut_malloc(strlen(dirname) + strlen(ent->d_name) + 10);
|
||
|
||
sprintf(full_path, "%s/%s", dirname, ent->d_name);
|
||
|
||
ret = stat(full_path, &statinfo);
|
||
|
||
if (ret) {
|
||
os_file_handle_error_no_exit(full_path, "stat");
|
||
|
||
ut_free(full_path);
|
||
|
||
return(-1);
|
||
}
|
||
|
||
info->size = (ib_longlong)statinfo.st_size;
|
||
|
||
if (S_ISDIR(statinfo.st_mode)) {
|
||
info->type = OS_FILE_TYPE_DIR;
|
||
} else if (S_ISLNK(statinfo.st_mode)) {
|
||
info->type = OS_FILE_TYPE_LINK;
|
||
} else if (S_ISREG(statinfo.st_mode)) {
|
||
info->type = OS_FILE_TYPE_FILE;
|
||
} else {
|
||
info->type = OS_FILE_TYPE_UNKNOWN;
|
||
}
|
||
|
||
ut_free(full_path);
|
||
|
||
return(0);
|
||
#endif
|
||
}
|
||
|
||
/*********************************************************************
|
||
This function attempts to create a directory named pathname. The new directory
|
||
gets default permissions. On Unix the permissions are (0770 & ~umask). If the
|
||
directory exists already, nothing is done and the call succeeds, unless the
|
||
fail_if_exists arguments is true. */
|
||
|
||
ibool
|
||
os_file_create_directory(
|
||
/*=====================*/
|
||
/* out: TRUE if call succeeds,
|
||
FALSE on error */
|
||
const char* pathname, /* in: directory name as
|
||
null-terminated string */
|
||
ibool fail_if_exists) /* in: if TRUE, pre-existing directory
|
||
is treated as an error. */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL rcode;
|
||
|
||
rcode = CreateDirectory(pathname, NULL);
|
||
if (!(rcode != 0 ||
|
||
(GetLastError() == ERROR_ALREADY_EXISTS && !fail_if_exists))) {
|
||
/* failure */
|
||
os_file_handle_error(pathname, "CreateDirectory");
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
return (TRUE);
|
||
#else
|
||
int rcode;
|
||
|
||
rcode = mkdir(pathname, 0770);
|
||
|
||
if (!(rcode == 0 || (errno == EEXIST && !fail_if_exists))) {
|
||
/* failure */
|
||
os_file_handle_error(pathname, "mkdir");
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
return (TRUE);
|
||
#endif
|
||
}
|
||
|
||
/********************************************************************
|
||
A simple function to open or create a file. */
|
||
|
||
os_file_t
|
||
os_file_create_simple(
|
||
/*==================*/
|
||
/* out, own: handle to the file, not defined
|
||
if error, error number can be retrieved with
|
||
os_file_get_last_error */
|
||
const char* name, /* in: name of the file or path as a
|
||
null-terminated string */
|
||
ulint create_mode,/* in: OS_FILE_OPEN if an existing file is
|
||
opened (if does not exist, error), or
|
||
OS_FILE_CREATE if a new file is created
|
||
(if exists, error), or
|
||
OS_FILE_CREATE_PATH if new file
|
||
(if exists, error) and subdirectories along
|
||
its path are created (if needed)*/
|
||
ulint access_type,/* in: OS_FILE_READ_ONLY or
|
||
OS_FILE_READ_WRITE */
|
||
ibool* success)/* out: TRUE if succeed, FALSE if error */
|
||
{
|
||
#ifdef __WIN__
|
||
os_file_t file;
|
||
DWORD create_flag;
|
||
DWORD access;
|
||
DWORD attributes = 0;
|
||
ibool retry;
|
||
|
||
try_again:
|
||
ut_a(name);
|
||
|
||
if (create_mode == OS_FILE_OPEN) {
|
||
create_flag = OPEN_EXISTING;
|
||
} else if (create_mode == OS_FILE_CREATE) {
|
||
create_flag = CREATE_NEW;
|
||
} else if (create_mode == OS_FILE_CREATE_PATH) {
|
||
/* create subdirs along the path if needed */
|
||
*success = os_file_create_subdirs_if_needed(name);
|
||
if (!*success) {
|
||
ut_error;
|
||
}
|
||
create_flag = CREATE_NEW;
|
||
create_mode = OS_FILE_CREATE;
|
||
} else {
|
||
create_flag = 0;
|
||
ut_error;
|
||
}
|
||
|
||
if (access_type == OS_FILE_READ_ONLY) {
|
||
access = GENERIC_READ;
|
||
} else if (access_type == OS_FILE_READ_WRITE) {
|
||
access = GENERIC_READ | GENERIC_WRITE;
|
||
} else {
|
||
access = 0;
|
||
ut_error;
|
||
}
|
||
|
||
file = CreateFile(name,
|
||
access,
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||
/* file can be read ansd written also
|
||
by other processes */
|
||
NULL, /* default security attributes */
|
||
create_flag,
|
||
attributes,
|
||
NULL); /* no template file */
|
||
|
||
if (file == INVALID_HANDLE_VALUE) {
|
||
*success = FALSE;
|
||
|
||
retry = os_file_handle_error(name,
|
||
create_mode == OS_FILE_OPEN ?
|
||
"open" : "create");
|
||
if (retry) {
|
||
goto try_again;
|
||
}
|
||
} else {
|
||
*success = TRUE;
|
||
}
|
||
|
||
return(file);
|
||
#else /* __WIN__ */
|
||
os_file_t file;
|
||
int create_flag;
|
||
ibool retry;
|
||
|
||
try_again:
|
||
ut_a(name);
|
||
|
||
if (create_mode == OS_FILE_OPEN) {
|
||
if (access_type == OS_FILE_READ_ONLY) {
|
||
create_flag = O_RDONLY;
|
||
} else {
|
||
create_flag = O_RDWR;
|
||
}
|
||
} else if (create_mode == OS_FILE_CREATE) {
|
||
create_flag = O_RDWR | O_CREAT | O_EXCL;
|
||
} else if (create_mode == OS_FILE_CREATE_PATH) {
|
||
/* create subdirs along the path if needed */
|
||
*success = os_file_create_subdirs_if_needed(name);
|
||
if (!*success) {
|
||
return (-1);
|
||
}
|
||
create_flag = O_RDWR | O_CREAT | O_EXCL;
|
||
create_mode = OS_FILE_CREATE;
|
||
} else {
|
||
create_flag = 0;
|
||
ut_error;
|
||
}
|
||
|
||
if (create_mode == OS_FILE_CREATE) {
|
||
file = open(name, create_flag, S_IRUSR | S_IWUSR
|
||
| S_IRGRP | S_IWGRP);
|
||
} else {
|
||
file = open(name, create_flag);
|
||
}
|
||
|
||
if (file == -1) {
|
||
*success = FALSE;
|
||
|
||
retry = os_file_handle_error(name,
|
||
create_mode == OS_FILE_OPEN ?
|
||
"open" : "create");
|
||
if (retry) {
|
||
goto try_again;
|
||
}
|
||
#ifdef USE_FILE_LOCK
|
||
} else if (access_type == OS_FILE_READ_WRITE
|
||
&& os_file_lock(file, name)) {
|
||
*success = FALSE;
|
||
close(file);
|
||
file = -1;
|
||
#endif
|
||
} else {
|
||
*success = TRUE;
|
||
}
|
||
|
||
return(file);
|
||
#endif /* __WIN__ */
|
||
}
|
||
|
||
/********************************************************************
|
||
A simple function to open or create a file. */
|
||
|
||
os_file_t
|
||
os_file_create_simple_no_error_handling(
|
||
/*====================================*/
|
||
/* out, own: handle to the file, not defined
|
||
if error, error number can be retrieved with
|
||
os_file_get_last_error */
|
||
const char* name, /* in: name of the file or path as a
|
||
null-terminated string */
|
||
ulint create_mode,/* in: OS_FILE_OPEN if an existing file
|
||
is opened (if does not exist, error), or
|
||
OS_FILE_CREATE if a new file is created
|
||
(if exists, error) */
|
||
ulint access_type,/* in: OS_FILE_READ_ONLY,
|
||
OS_FILE_READ_WRITE, or
|
||
OS_FILE_READ_ALLOW_DELETE; the last option is
|
||
used by a backup program reading the file */
|
||
ibool* success)/* out: TRUE if succeed, FALSE if error */
|
||
{
|
||
#ifdef __WIN__
|
||
os_file_t file;
|
||
DWORD create_flag;
|
||
DWORD access;
|
||
DWORD attributes = 0;
|
||
DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
|
||
|
||
ut_a(name);
|
||
|
||
if (create_mode == OS_FILE_OPEN) {
|
||
create_flag = OPEN_EXISTING;
|
||
} else if (create_mode == OS_FILE_CREATE) {
|
||
create_flag = CREATE_NEW;
|
||
} else {
|
||
create_flag = 0;
|
||
ut_error;
|
||
}
|
||
|
||
if (access_type == OS_FILE_READ_ONLY) {
|
||
access = GENERIC_READ;
|
||
} else if (access_type == OS_FILE_READ_WRITE) {
|
||
access = GENERIC_READ | GENERIC_WRITE;
|
||
} else if (access_type == OS_FILE_READ_ALLOW_DELETE) {
|
||
access = GENERIC_READ;
|
||
share_mode = FILE_SHARE_DELETE | FILE_SHARE_READ
|
||
| FILE_SHARE_WRITE; /* A backup program has to give
|
||
mysqld the maximum freedom to
|
||
do what it likes with the
|
||
file */
|
||
} else {
|
||
access = 0;
|
||
ut_error;
|
||
}
|
||
|
||
file = CreateFile(name,
|
||
access,
|
||
share_mode,
|
||
NULL, /* default security attributes */
|
||
create_flag,
|
||
attributes,
|
||
NULL); /* no template file */
|
||
|
||
if (file == INVALID_HANDLE_VALUE) {
|
||
*success = FALSE;
|
||
} else {
|
||
*success = TRUE;
|
||
}
|
||
|
||
return(file);
|
||
#else /* __WIN__ */
|
||
os_file_t file;
|
||
int create_flag;
|
||
|
||
ut_a(name);
|
||
|
||
if (create_mode == OS_FILE_OPEN) {
|
||
if (access_type == OS_FILE_READ_ONLY) {
|
||
create_flag = O_RDONLY;
|
||
} else {
|
||
create_flag = O_RDWR;
|
||
}
|
||
} else if (create_mode == OS_FILE_CREATE) {
|
||
create_flag = O_RDWR | O_CREAT | O_EXCL;
|
||
} else {
|
||
create_flag = 0;
|
||
ut_error;
|
||
}
|
||
|
||
if (create_mode == OS_FILE_CREATE) {
|
||
file = open(name, create_flag, S_IRUSR | S_IWUSR
|
||
| S_IRGRP | S_IWGRP);
|
||
} else {
|
||
file = open(name, create_flag);
|
||
}
|
||
|
||
if (file == -1) {
|
||
*success = FALSE;
|
||
#ifdef USE_FILE_LOCK
|
||
} else if (access_type == OS_FILE_READ_WRITE
|
||
&& os_file_lock(file, name)) {
|
||
*success = FALSE;
|
||
close(file);
|
||
file = -1;
|
||
#endif
|
||
} else {
|
||
*success = TRUE;
|
||
}
|
||
|
||
return(file);
|
||
#endif /* __WIN__ */
|
||
}
|
||
|
||
/********************************************************************
|
||
Opens an existing file or creates a new. */
|
||
|
||
os_file_t
|
||
os_file_create(
|
||
/*===========*/
|
||
/* out, own: handle to the file, not defined
|
||
if error, error number can be retrieved with
|
||
os_file_get_last_error */
|
||
const char* name, /* in: name of the file or path as a
|
||
null-terminated string */
|
||
ulint create_mode,/* in: OS_FILE_OPEN if an existing file
|
||
is opened (if does not exist, error), or
|
||
OS_FILE_CREATE if a new file is created
|
||
(if exists, error),
|
||
OS_FILE_OVERWRITE if a new file is created
|
||
or an old overwritten;
|
||
OS_FILE_OPEN_RAW, if a raw device or disk
|
||
partition should be opened */
|
||
ulint purpose,/* in: OS_FILE_AIO, if asynchronous,
|
||
non-buffered i/o is desired,
|
||
OS_FILE_NORMAL, if any normal file;
|
||
NOTE that it also depends on type, os_aio_..
|
||
and srv_.. variables whether we really use
|
||
async i/o or unbuffered i/o: look in the
|
||
function source code for the exact rules */
|
||
ulint type, /* in: OS_DATA_FILE or OS_LOG_FILE */
|
||
ibool* success)/* out: TRUE if succeed, FALSE if error */
|
||
{
|
||
#ifdef __WIN__
|
||
os_file_t file;
|
||
DWORD share_mode = FILE_SHARE_READ;
|
||
DWORD create_flag;
|
||
DWORD attributes;
|
||
ibool retry;
|
||
try_again:
|
||
ut_a(name);
|
||
|
||
if (create_mode == OS_FILE_OPEN_RAW) {
|
||
create_flag = OPEN_EXISTING;
|
||
share_mode = FILE_SHARE_WRITE;
|
||
} else if (create_mode == OS_FILE_OPEN
|
||
|| create_mode == OS_FILE_OPEN_RETRY) {
|
||
create_flag = OPEN_EXISTING;
|
||
} else if (create_mode == OS_FILE_CREATE) {
|
||
create_flag = CREATE_NEW;
|
||
} else if (create_mode == OS_FILE_OVERWRITE) {
|
||
create_flag = CREATE_ALWAYS;
|
||
} else {
|
||
create_flag = 0;
|
||
ut_error;
|
||
}
|
||
|
||
if (purpose == OS_FILE_AIO) {
|
||
/* If specified, use asynchronous (overlapped) io and no
|
||
buffering of writes in the OS */
|
||
attributes = 0;
|
||
#ifdef WIN_ASYNC_IO
|
||
if (os_aio_use_native_aio) {
|
||
attributes = attributes | FILE_FLAG_OVERLAPPED;
|
||
}
|
||
#endif
|
||
#ifdef UNIV_NON_BUFFERED_IO
|
||
if (type == OS_LOG_FILE && srv_flush_log_at_trx_commit == 2) {
|
||
/* Do not use unbuffered i/o to log files because
|
||
value 2 denotes that we do not flush the log at every
|
||
commit, but only once per second */
|
||
} else if (srv_win_file_flush_method ==
|
||
SRV_WIN_IO_UNBUFFERED) {
|
||
attributes = attributes | FILE_FLAG_NO_BUFFERING;
|
||
}
|
||
#endif
|
||
} else if (purpose == OS_FILE_NORMAL) {
|
||
attributes = 0;
|
||
#ifdef UNIV_NON_BUFFERED_IO
|
||
if (type == OS_LOG_FILE && srv_flush_log_at_trx_commit == 2) {
|
||
/* Do not use unbuffered i/o to log files because
|
||
value 2 denotes that we do not flush the log at every
|
||
commit, but only once per second */
|
||
} else if (srv_win_file_flush_method ==
|
||
SRV_WIN_IO_UNBUFFERED) {
|
||
attributes = attributes | FILE_FLAG_NO_BUFFERING;
|
||
}
|
||
#endif
|
||
} else {
|
||
attributes = 0;
|
||
ut_error;
|
||
}
|
||
|
||
file = CreateFile(name,
|
||
GENERIC_READ | GENERIC_WRITE, /* read and write
|
||
access */
|
||
share_mode, /* File can be read also by other
|
||
processes; we must give the read
|
||
permission because of ibbackup. We do
|
||
not give the write permission to
|
||
others because if one would succeed to
|
||
start 2 instances of mysqld on the
|
||
SAME files, that could cause severe
|
||
database corruption! When opening
|
||
raw disk partitions, Microsoft manuals
|
||
say that we must give also the write
|
||
permission. */
|
||
NULL, /* default security attributes */
|
||
create_flag,
|
||
attributes,
|
||
NULL); /* no template file */
|
||
|
||
if (file == INVALID_HANDLE_VALUE) {
|
||
*success = FALSE;
|
||
|
||
retry = os_file_handle_error(name,
|
||
create_mode == OS_FILE_CREATE ?
|
||
"create" : "open");
|
||
if (retry) {
|
||
goto try_again;
|
||
}
|
||
} else {
|
||
*success = TRUE;
|
||
}
|
||
|
||
return(file);
|
||
#else /* __WIN__ */
|
||
os_file_t file;
|
||
int create_flag;
|
||
ibool retry;
|
||
const char* mode_str = NULL;
|
||
const char* type_str = NULL;
|
||
const char* purpose_str = NULL;
|
||
|
||
try_again:
|
||
ut_a(name);
|
||
|
||
if (create_mode == OS_FILE_OPEN || create_mode == OS_FILE_OPEN_RAW
|
||
|| create_mode == OS_FILE_OPEN_RETRY) {
|
||
mode_str = "OPEN";
|
||
create_flag = O_RDWR;
|
||
} else if (create_mode == OS_FILE_CREATE) {
|
||
mode_str = "CREATE";
|
||
create_flag = O_RDWR | O_CREAT | O_EXCL;
|
||
} else if (create_mode == OS_FILE_OVERWRITE) {
|
||
mode_str = "OVERWRITE";
|
||
create_flag = O_RDWR | O_CREAT | O_TRUNC;
|
||
} else {
|
||
create_flag = 0;
|
||
ut_error;
|
||
}
|
||
|
||
if (type == OS_LOG_FILE) {
|
||
type_str = "LOG";
|
||
} else if (type == OS_DATA_FILE) {
|
||
type_str = "DATA";
|
||
} else {
|
||
ut_error;
|
||
}
|
||
|
||
if (purpose == OS_FILE_AIO) {
|
||
purpose_str = "AIO";
|
||
} else if (purpose == OS_FILE_NORMAL) {
|
||
purpose_str = "NORMAL";
|
||
} else {
|
||
ut_error;
|
||
}
|
||
|
||
/* fprintf(stderr, "Opening file %s, mode %s, type %s, purpose %s\n",
|
||
name, mode_str, type_str, purpose_str); */
|
||
#ifdef O_SYNC
|
||
/* We let O_SYNC only affect log files; note that we map O_DSYNC to
|
||
O_SYNC because the datasync options seemed to corrupt files in 2001
|
||
in both Linux and Solaris */
|
||
if (type == OS_LOG_FILE
|
||
&& srv_unix_file_flush_method == SRV_UNIX_O_DSYNC) {
|
||
|
||
/* fprintf(stderr, "Using O_SYNC for file %s\n", name); */
|
||
|
||
create_flag = create_flag | O_SYNC;
|
||
}
|
||
#endif
|
||
#ifdef O_DIRECT
|
||
/* We let O_DIRECT only affect data files */
|
||
if (type != OS_LOG_FILE
|
||
&& srv_unix_file_flush_method == SRV_UNIX_O_DIRECT) {
|
||
|
||
/* fprintf(stderr, "Using O_DIRECT for file %s\n", name); */
|
||
|
||
create_flag = create_flag | O_DIRECT;
|
||
}
|
||
#endif
|
||
if (create_mode == OS_FILE_CREATE) {
|
||
file = open(name, create_flag, os_innodb_umask);
|
||
} else {
|
||
file = open(name, create_flag);
|
||
}
|
||
|
||
if (file == -1) {
|
||
*success = FALSE;
|
||
|
||
retry = os_file_handle_error(name,
|
||
create_mode == OS_FILE_CREATE ?
|
||
"create" : "open");
|
||
if (retry) {
|
||
goto try_again;
|
||
}
|
||
#ifdef USE_FILE_LOCK
|
||
} else if (create_mode != OS_FILE_OPEN_RAW
|
||
&& os_file_lock(file, name)) {
|
||
*success = FALSE;
|
||
if (create_mode == OS_FILE_OPEN_RETRY) {
|
||
int i;
|
||
ut_print_timestamp(stderr);
|
||
fputs(" InnoDB: Retrying to lock the first data file\n",
|
||
stderr);
|
||
for (i = 0; i < 100; i++) {
|
||
os_thread_sleep(1000000);
|
||
if (!os_file_lock(file, name)) {
|
||
*success = TRUE;
|
||
return(file);
|
||
}
|
||
}
|
||
ut_print_timestamp(stderr);
|
||
fputs(" InnoDB: Unable to open the first data file\n",
|
||
stderr);
|
||
}
|
||
close(file);
|
||
file = -1;
|
||
#endif
|
||
} else {
|
||
*success = TRUE;
|
||
}
|
||
|
||
return(file);
|
||
#endif /* __WIN__ */
|
||
}
|
||
|
||
/***************************************************************************
|
||
Deletes a file if it exists. The file has to be closed before calling this. */
|
||
|
||
ibool
|
||
os_file_delete_if_exists(
|
||
/*=====================*/
|
||
/* out: TRUE if success */
|
||
const char* name) /* in: file path as a null-terminated string */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL ret;
|
||
ulint count = 0;
|
||
loop:
|
||
/* In Windows, deleting an .ibd file may fail if ibbackup is copying
|
||
it */
|
||
|
||
ret = DeleteFile((LPCTSTR)name);
|
||
|
||
if (ret) {
|
||
return(TRUE);
|
||
}
|
||
|
||
if (GetLastError() == ERROR_FILE_NOT_FOUND) {
|
||
/* the file does not exist, this not an error */
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
count++;
|
||
|
||
if (count > 100 && 0 == (count % 10)) {
|
||
fprintf(stderr,
|
||
"InnoDB: Warning: cannot delete file %s\n"
|
||
"InnoDB: Are you running ibbackup to back up the file?\n", name);
|
||
|
||
os_file_get_last_error(TRUE); /* print error information */
|
||
}
|
||
|
||
os_thread_sleep(1000000); /* sleep for a second */
|
||
|
||
if (count > 2000) {
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
goto loop;
|
||
#else
|
||
int ret;
|
||
|
||
ret = unlink((const char*)name);
|
||
|
||
if (ret != 0 && errno != ENOENT) {
|
||
os_file_handle_error_no_exit(name, "delete");
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
return(TRUE);
|
||
#endif
|
||
}
|
||
|
||
/***************************************************************************
|
||
Deletes a file. The file has to be closed before calling this. */
|
||
|
||
ibool
|
||
os_file_delete(
|
||
/*===========*/
|
||
/* out: TRUE if success */
|
||
const char* name) /* in: file path as a null-terminated string */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL ret;
|
||
ulint count = 0;
|
||
loop:
|
||
/* In Windows, deleting an .ibd file may fail if ibbackup is copying
|
||
it */
|
||
|
||
ret = DeleteFile((LPCTSTR)name);
|
||
|
||
if (ret) {
|
||
return(TRUE);
|
||
}
|
||
|
||
if (GetLastError() == ERROR_FILE_NOT_FOUND) {
|
||
/* If the file does not exist, we classify this as a 'mild'
|
||
error and return */
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
count++;
|
||
|
||
if (count > 100 && 0 == (count % 10)) {
|
||
fprintf(stderr,
|
||
"InnoDB: Warning: cannot delete file %s\n"
|
||
"InnoDB: Are you running ibbackup to back up the file?\n", name);
|
||
|
||
os_file_get_last_error(TRUE); /* print error information */
|
||
}
|
||
|
||
os_thread_sleep(1000000); /* sleep for a second */
|
||
|
||
if (count > 2000) {
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
goto loop;
|
||
#else
|
||
int ret;
|
||
|
||
ret = unlink((const char*)name);
|
||
|
||
if (ret != 0) {
|
||
os_file_handle_error_no_exit(name, "delete");
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
return(TRUE);
|
||
#endif
|
||
}
|
||
|
||
/***************************************************************************
|
||
Renames a file (can also move it to another directory). It is safest that the
|
||
file is closed before calling this function. */
|
||
|
||
ibool
|
||
os_file_rename(
|
||
/*===========*/
|
||
/* out: TRUE if success */
|
||
const char* oldpath,/* in: old file path as a null-terminated
|
||
string */
|
||
const char* newpath)/* in: new file path */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL ret;
|
||
|
||
ret = MoveFile((LPCTSTR)oldpath, (LPCTSTR)newpath);
|
||
|
||
if (ret) {
|
||
return(TRUE);
|
||
}
|
||
|
||
os_file_handle_error(oldpath, "rename");
|
||
|
||
return(FALSE);
|
||
#else
|
||
int ret;
|
||
|
||
ret = rename((const char*)oldpath, (const char*)newpath);
|
||
|
||
if (ret != 0) {
|
||
os_file_handle_error(oldpath, "rename");
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
return(TRUE);
|
||
#endif
|
||
}
|
||
|
||
/***************************************************************************
|
||
Closes a file handle. In case of error, error number can be retrieved with
|
||
os_file_get_last_error. */
|
||
|
||
ibool
|
||
os_file_close(
|
||
/*==========*/
|
||
/* out: TRUE if success */
|
||
os_file_t file) /* in, own: handle to a file */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL ret;
|
||
|
||
ut_a(file);
|
||
|
||
ret = CloseHandle(file);
|
||
|
||
if (ret) {
|
||
return(TRUE);
|
||
}
|
||
|
||
os_file_handle_error(NULL, "close");
|
||
|
||
return(FALSE);
|
||
#else
|
||
int ret;
|
||
|
||
ret = close(file);
|
||
|
||
if (ret == -1) {
|
||
os_file_handle_error(NULL, "close");
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
return(TRUE);
|
||
#endif
|
||
}
|
||
|
||
/***************************************************************************
|
||
Closes a file handle. */
|
||
|
||
ibool
|
||
os_file_close_no_error_handling(
|
||
/*============================*/
|
||
/* out: TRUE if success */
|
||
os_file_t file) /* in, own: handle to a file */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL ret;
|
||
|
||
ut_a(file);
|
||
|
||
ret = CloseHandle(file);
|
||
|
||
if (ret) {
|
||
return(TRUE);
|
||
}
|
||
|
||
return(FALSE);
|
||
#else
|
||
int ret;
|
||
|
||
ret = close(file);
|
||
|
||
if (ret == -1) {
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
return(TRUE);
|
||
#endif
|
||
}
|
||
|
||
/***************************************************************************
|
||
Gets a file size. */
|
||
|
||
ibool
|
||
os_file_get_size(
|
||
/*=============*/
|
||
/* out: TRUE if success */
|
||
os_file_t file, /* in: handle to a file */
|
||
ulint* size, /* out: least significant 32 bits of file
|
||
size */
|
||
ulint* size_high)/* out: most significant 32 bits of size */
|
||
{
|
||
#ifdef __WIN__
|
||
DWORD high;
|
||
DWORD low;
|
||
|
||
low = GetFileSize(file, &high);
|
||
|
||
if ((low == 0xFFFFFFFF) && (GetLastError() != NO_ERROR)) {
|
||
return(FALSE);
|
||
}
|
||
|
||
*size = low;
|
||
*size_high = high;
|
||
|
||
return(TRUE);
|
||
#else
|
||
off_t offs;
|
||
|
||
offs = lseek(file, 0, SEEK_END);
|
||
|
||
if (offs == ((off_t)-1)) {
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
if (sizeof(off_t) > 4) {
|
||
*size = (ulint)(offs & 0xFFFFFFFFUL);
|
||
*size_high = (ulint)(offs >> 32);
|
||
} else {
|
||
*size = (ulint) offs;
|
||
*size_high = 0;
|
||
}
|
||
|
||
return(TRUE);
|
||
#endif
|
||
}
|
||
|
||
/***************************************************************************
|
||
Gets file size as a 64-bit integer ib_longlong. */
|
||
|
||
ib_longlong
|
||
os_file_get_size_as_iblonglong(
|
||
/*===========================*/
|
||
/* out: size in bytes, -1 if error */
|
||
os_file_t file) /* in: handle to a file */
|
||
{
|
||
ulint size;
|
||
ulint size_high;
|
||
ibool success;
|
||
|
||
success = os_file_get_size(file, &size, &size_high);
|
||
|
||
if (!success) {
|
||
|
||
return(-1);
|
||
}
|
||
|
||
return((((ib_longlong)size_high) << 32) + (ib_longlong)size);
|
||
}
|
||
|
||
/***************************************************************************
|
||
Sets a file size. This function can be used to extend or truncate a file. */
|
||
|
||
ibool
|
||
os_file_set_size(
|
||
/*=============*/
|
||
/* out: TRUE if success */
|
||
const char* name, /* in: name of the file or path as a
|
||
null-terminated string */
|
||
os_file_t file, /* in: handle to a file */
|
||
ulint size, /* in: least significant 32 bits of file
|
||
size */
|
||
ulint size_high)/* in: most significant 32 bits of size */
|
||
{
|
||
ib_longlong offset;
|
||
ib_longlong low;
|
||
ulint n_bytes;
|
||
ibool ret;
|
||
byte* buf;
|
||
byte* buf2;
|
||
ulint i;
|
||
|
||
ut_a(size == (size & 0xFFFFFFFF));
|
||
|
||
/* We use a very big 8 MB buffer in writing because Linux may be
|
||
extremely slow in fsync on 1 MB writes */
|
||
|
||
buf2 = ut_malloc(UNIV_PAGE_SIZE * 513);
|
||
|
||
/* Align the buffer for possible raw i/o */
|
||
buf = ut_align(buf2, UNIV_PAGE_SIZE);
|
||
|
||
/* Write buffer full of zeros */
|
||
for (i = 0; i < UNIV_PAGE_SIZE * 512; i++) {
|
||
buf[i] = '\0';
|
||
}
|
||
|
||
offset = 0;
|
||
low = (ib_longlong)size + (((ib_longlong)size_high) << 32);
|
||
|
||
if (low >= (ib_longlong)(100 * 1024 * 1024)) {
|
||
|
||
fprintf(stderr, "InnoDB: Progress in MB:");
|
||
}
|
||
|
||
while (offset < low) {
|
||
if (low - offset < UNIV_PAGE_SIZE * 512) {
|
||
n_bytes = (ulint)(low - offset);
|
||
} else {
|
||
n_bytes = UNIV_PAGE_SIZE * 512;
|
||
}
|
||
|
||
ret = os_file_write(name, file, buf,
|
||
(ulint)(offset & 0xFFFFFFFF),
|
||
(ulint)(offset >> 32),
|
||
n_bytes);
|
||
if (!ret) {
|
||
ut_free(buf2);
|
||
goto error_handling;
|
||
}
|
||
|
||
/* Print about progress for each 100 MB written */
|
||
if ((ib_longlong) (offset + n_bytes) / (ib_longlong)(100 * 1024 * 1024)
|
||
!= offset / (ib_longlong)(100 * 1024 * 1024)) {
|
||
|
||
fprintf(stderr, " %lu00",
|
||
(ulong) ((offset + n_bytes)
|
||
/ (ib_longlong)(100 * 1024 * 1024)));
|
||
}
|
||
|
||
offset += n_bytes;
|
||
}
|
||
|
||
if (low >= (ib_longlong)(100 * 1024 * 1024)) {
|
||
|
||
fprintf(stderr, "\n");
|
||
}
|
||
|
||
ut_free(buf2);
|
||
|
||
ret = os_file_flush(file);
|
||
|
||
if (ret) {
|
||
return(TRUE);
|
||
}
|
||
|
||
error_handling:
|
||
return(FALSE);
|
||
}
|
||
|
||
/***************************************************************************
|
||
Truncates a file at its current position. */
|
||
|
||
ibool
|
||
os_file_set_eof(
|
||
/*============*/
|
||
/* out: TRUE if success */
|
||
FILE* file) /* in: file to be truncated */
|
||
{
|
||
#ifdef __WIN__
|
||
HANDLE h = (HANDLE) _get_osfhandle(fileno(file));
|
||
return(SetEndOfFile(h));
|
||
#else /* __WIN__ */
|
||
return(!ftruncate(fileno(file), ftell(file)));
|
||
#endif /* __WIN__ */
|
||
}
|
||
|
||
/***************************************************************************
|
||
Flushes the write buffers of a given file to the disk. */
|
||
|
||
ibool
|
||
os_file_flush(
|
||
/*==========*/
|
||
/* out: TRUE if success */
|
||
os_file_t file) /* in, own: handle to a file */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL ret;
|
||
|
||
ut_a(file);
|
||
|
||
os_n_fsyncs++;
|
||
|
||
ret = FlushFileBuffers(file);
|
||
|
||
if (ret) {
|
||
return(TRUE);
|
||
}
|
||
|
||
/* Since Windows returns ERROR_INVALID_FUNCTION if the 'file' is
|
||
actually a raw device, we choose to ignore that error if we are using
|
||
raw disks */
|
||
|
||
if (srv_start_raw_disk_in_use && GetLastError()
|
||
== ERROR_INVALID_FUNCTION) {
|
||
return(TRUE);
|
||
}
|
||
|
||
os_file_handle_error(NULL, "flush");
|
||
|
||
/* It is a fatal error if a file flush does not succeed, because then
|
||
the database can get corrupt on disk */
|
||
ut_error;
|
||
|
||
return(FALSE);
|
||
#else
|
||
int ret;
|
||
|
||
#if defined(HAVE_DARWIN_THREADS)
|
||
# ifndef F_FULLFSYNC
|
||
/* The following definition is from the Mac OS X 10.3 <sys/fcntl.h> */
|
||
# define F_FULLFSYNC 51 /* fsync + ask the drive to flush to the media */
|
||
# elif F_FULLFSYNC != 51
|
||
# error "F_FULLFSYNC != 51: ABI incompatibility with Mac OS X 10.3"
|
||
# endif
|
||
/* Apple has disabled fsync() for internal disk drives in OS X. That
|
||
caused corruption for a user when he tested a power outage. Let us in
|
||
OS X use a nonstandard flush method recommended by an Apple
|
||
engineer. */
|
||
|
||
if (!srv_have_fullfsync) {
|
||
/* If we are not on an operating system that supports this,
|
||
then fall back to a plain fsync. */
|
||
|
||
ret = fsync(file);
|
||
} else {
|
||
ret = fcntl(file, F_FULLFSYNC, NULL);
|
||
|
||
if (ret) {
|
||
/* If we are not on a file system that supports this,
|
||
then fall back to a plain fsync. */
|
||
ret = fsync(file);
|
||
}
|
||
}
|
||
#elif HAVE_FDATASYNC
|
||
ret = fdatasync(file);
|
||
#else
|
||
/* fprintf(stderr, "Flushing to file %p\n", file); */
|
||
ret = fsync(file);
|
||
#endif
|
||
os_n_fsyncs++;
|
||
|
||
if (ret == 0) {
|
||
return(TRUE);
|
||
}
|
||
|
||
/* Since Linux returns EINVAL if the 'file' is actually a raw device,
|
||
we choose to ignore that error if we are using raw disks */
|
||
|
||
if (srv_start_raw_disk_in_use && errno == EINVAL) {
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
ut_print_timestamp(stderr);
|
||
|
||
fprintf(stderr,
|
||
" InnoDB: Error: the OS said file flush did not succeed\n");
|
||
|
||
os_file_handle_error(NULL, "flush");
|
||
|
||
/* It is a fatal error if a file flush does not succeed, because then
|
||
the database can get corrupt on disk */
|
||
ut_error;
|
||
|
||
return(FALSE);
|
||
#endif
|
||
}
|
||
|
||
#ifndef __WIN__
|
||
/***********************************************************************
|
||
Does a synchronous read operation in Posix. */
|
||
static
|
||
ssize_t
|
||
os_file_pread(
|
||
/*==========*/
|
||
/* out: number of bytes read, -1 if error */
|
||
os_file_t file, /* in: handle to a file */
|
||
void* buf, /* in: buffer where to read */
|
||
ulint n, /* in: number of bytes to read */
|
||
ulint offset, /* in: least significant 32 bits of file
|
||
offset from where to read */
|
||
ulint offset_high) /* in: most significant 32 bits of
|
||
offset */
|
||
{
|
||
off_t offs;
|
||
ssize_t n_bytes;
|
||
|
||
ut_a((offset & 0xFFFFFFFFUL) == offset);
|
||
|
||
/* If off_t is > 4 bytes in size, then we assume we can pass a
|
||
64-bit address */
|
||
|
||
if (sizeof(off_t) > 4) {
|
||
offs = (off_t)offset + (((off_t)offset_high) << 32);
|
||
|
||
} else {
|
||
offs = (off_t)offset;
|
||
|
||
if (offset_high > 0) {
|
||
fprintf(stderr,
|
||
"InnoDB: Error: file read at offset > 4 GB\n");
|
||
}
|
||
}
|
||
|
||
os_n_file_reads++;
|
||
|
||
#if defined(HAVE_PREAD) && !defined(HAVE_BROKEN_PREAD)
|
||
os_mutex_enter(os_file_count_mutex);
|
||
os_file_n_pending_preads++;
|
||
os_mutex_exit(os_file_count_mutex);
|
||
|
||
n_bytes = pread(file, buf, (ssize_t)n, offs);
|
||
|
||
os_mutex_enter(os_file_count_mutex);
|
||
os_file_n_pending_preads--;
|
||
os_mutex_exit(os_file_count_mutex);
|
||
|
||
return(n_bytes);
|
||
#else
|
||
{
|
||
off_t ret_offset;
|
||
ssize_t ret;
|
||
ulint i;
|
||
|
||
/* Protect the seek / read operation with a mutex */
|
||
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
|
||
|
||
os_mutex_enter(os_file_seek_mutexes[i]);
|
||
|
||
ret_offset = lseek(file, offs, SEEK_SET);
|
||
|
||
if (ret_offset < 0) {
|
||
os_mutex_exit(os_file_seek_mutexes[i]);
|
||
|
||
return(-1);
|
||
}
|
||
|
||
ret = read(file, buf, (ssize_t)n);
|
||
|
||
os_mutex_exit(os_file_seek_mutexes[i]);
|
||
|
||
return(ret);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
/***********************************************************************
|
||
Does a synchronous write operation in Posix. */
|
||
static
|
||
ssize_t
|
||
os_file_pwrite(
|
||
/*===========*/
|
||
/* out: number of bytes written, -1 if error */
|
||
os_file_t file, /* in: handle to a file */
|
||
const void* buf, /* in: buffer from where to write */
|
||
ulint n, /* in: number of bytes to write */
|
||
ulint offset, /* in: least significant 32 bits of file
|
||
offset where to write */
|
||
ulint offset_high) /* in: most significant 32 bits of
|
||
offset */
|
||
{
|
||
ssize_t ret;
|
||
off_t offs;
|
||
|
||
ut_a((offset & 0xFFFFFFFFUL) == offset);
|
||
|
||
/* If off_t is > 4 bytes in size, then we assume we can pass a
|
||
64-bit address */
|
||
|
||
if (sizeof(off_t) > 4) {
|
||
offs = (off_t)offset + (((off_t)offset_high) << 32);
|
||
} else {
|
||
offs = (off_t)offset;
|
||
|
||
if (offset_high > 0) {
|
||
fprintf(stderr,
|
||
"InnoDB: Error: file write at offset > 4 GB\n");
|
||
}
|
||
}
|
||
|
||
os_n_file_writes++;
|
||
|
||
#if defined(HAVE_PWRITE) && !defined(HAVE_BROKEN_PREAD)
|
||
os_mutex_enter(os_file_count_mutex);
|
||
os_file_n_pending_pwrites++;
|
||
os_mutex_exit(os_file_count_mutex);
|
||
|
||
ret = pwrite(file, buf, (ssize_t)n, offs);
|
||
|
||
os_mutex_enter(os_file_count_mutex);
|
||
os_file_n_pending_pwrites--;
|
||
os_mutex_exit(os_file_count_mutex);
|
||
|
||
if (srv_unix_file_flush_method != SRV_UNIX_LITTLESYNC
|
||
&& srv_unix_file_flush_method != SRV_UNIX_NOSYNC
|
||
&& !os_do_not_call_flush_at_each_write) {
|
||
|
||
/* Always do fsync to reduce the probability that when
|
||
the OS crashes, a database page is only partially
|
||
physically written to disk. */
|
||
|
||
ut_a(TRUE == os_file_flush(file));
|
||
}
|
||
|
||
return(ret);
|
||
#else
|
||
{
|
||
off_t ret_offset;
|
||
ulint i;
|
||
|
||
/* Protect the seek / write operation with a mutex */
|
||
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
|
||
|
||
os_mutex_enter(os_file_seek_mutexes[i]);
|
||
|
||
ret_offset = lseek(file, offs, SEEK_SET);
|
||
|
||
if (ret_offset < 0) {
|
||
os_mutex_exit(os_file_seek_mutexes[i]);
|
||
|
||
return(-1);
|
||
}
|
||
|
||
ret = write(file, buf, (ssize_t)n);
|
||
|
||
if (srv_unix_file_flush_method != SRV_UNIX_LITTLESYNC
|
||
&& srv_unix_file_flush_method != SRV_UNIX_NOSYNC
|
||
&& !os_do_not_call_flush_at_each_write) {
|
||
|
||
/* Always do fsync to reduce the probability that when
|
||
the OS crashes, a database page is only partially
|
||
physically written to disk. */
|
||
|
||
ut_a(TRUE == os_file_flush(file));
|
||
}
|
||
|
||
os_mutex_exit(os_file_seek_mutexes[i]);
|
||
|
||
return(ret);
|
||
}
|
||
#endif
|
||
}
|
||
#endif
|
||
|
||
/***********************************************************************
|
||
Requests a synchronous positioned read operation. */
|
||
|
||
ibool
|
||
os_file_read(
|
||
/*=========*/
|
||
/* out: TRUE if request was
|
||
successful, FALSE if fail */
|
||
os_file_t file, /* in: handle to a file */
|
||
void* buf, /* in: buffer where to read */
|
||
ulint offset, /* in: least significant 32 bits of file
|
||
offset where to read */
|
||
ulint offset_high, /* in: most significant 32 bits of
|
||
offset */
|
||
ulint n) /* in: number of bytes to read */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL ret;
|
||
DWORD len;
|
||
DWORD ret2;
|
||
DWORD low;
|
||
DWORD high;
|
||
ibool retry;
|
||
ulint i;
|
||
|
||
ut_a((offset & 0xFFFFFFFFUL) == offset);
|
||
|
||
os_n_file_reads++;
|
||
os_bytes_read_since_printout += n;
|
||
|
||
try_again:
|
||
ut_ad(file);
|
||
ut_ad(buf);
|
||
ut_ad(n > 0);
|
||
|
||
low = (DWORD) offset;
|
||
high = (DWORD) offset_high;
|
||
|
||
/* Protect the seek / read operation with a mutex */
|
||
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
|
||
|
||
os_mutex_enter(os_file_seek_mutexes[i]);
|
||
|
||
ret2 = SetFilePointer(file, low, &high, FILE_BEGIN);
|
||
|
||
if (ret2 == 0xFFFFFFFF && GetLastError() != NO_ERROR) {
|
||
|
||
os_mutex_exit(os_file_seek_mutexes[i]);
|
||
|
||
goto error_handling;
|
||
}
|
||
|
||
os_n_pending_reads++;
|
||
|
||
ret = ReadFile(file, buf, (DWORD) n, &len, NULL);
|
||
|
||
os_n_pending_reads--;
|
||
|
||
os_mutex_exit(os_file_seek_mutexes[i]);
|
||
|
||
if (ret && len == n) {
|
||
return(TRUE);
|
||
}
|
||
#else
|
||
ibool retry;
|
||
ssize_t ret;
|
||
|
||
os_bytes_read_since_printout += n;
|
||
|
||
try_again:
|
||
os_n_pending_reads++;
|
||
|
||
ret = os_file_pread(file, buf, n, offset, offset_high);
|
||
|
||
os_n_pending_reads--;
|
||
|
||
if ((ulint)ret == n) {
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
fprintf(stderr,
|
||
"InnoDB: Error: tried to read %lu bytes at offset %lu %lu.\n"
|
||
"InnoDB: Was only able to read %ld.\n", (ulong)n, (ulong)offset_high,
|
||
(ulong)offset, (long)ret);
|
||
#endif
|
||
#ifdef __WIN__
|
||
error_handling:
|
||
#endif
|
||
retry = os_file_handle_error(NULL, "read");
|
||
|
||
if (retry) {
|
||
goto try_again;
|
||
}
|
||
|
||
fprintf(stderr,
|
||
"InnoDB: Fatal error: cannot read from file. OS error number %lu.\n",
|
||
#ifdef __WIN__
|
||
(ulong) GetLastError()
|
||
#else
|
||
(ulong) errno
|
||
#endif
|
||
);
|
||
fflush(stderr);
|
||
|
||
ut_error;
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
/***********************************************************************
|
||
Requests a synchronous positioned read operation. This function does not do
|
||
any error handling. In case of error it returns FALSE. */
|
||
|
||
ibool
|
||
os_file_read_no_error_handling(
|
||
/*===========================*/
|
||
/* out: TRUE if request was
|
||
successful, FALSE if fail */
|
||
os_file_t file, /* in: handle to a file */
|
||
void* buf, /* in: buffer where to read */
|
||
ulint offset, /* in: least significant 32 bits of file
|
||
offset where to read */
|
||
ulint offset_high, /* in: most significant 32 bits of
|
||
offset */
|
||
ulint n) /* in: number of bytes to read */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL ret;
|
||
DWORD len;
|
||
DWORD ret2;
|
||
DWORD low;
|
||
DWORD high;
|
||
ibool retry;
|
||
ulint i;
|
||
|
||
ut_a((offset & 0xFFFFFFFFUL) == offset);
|
||
|
||
os_n_file_reads++;
|
||
os_bytes_read_since_printout += n;
|
||
|
||
try_again:
|
||
ut_ad(file);
|
||
ut_ad(buf);
|
||
ut_ad(n > 0);
|
||
|
||
low = (DWORD) offset;
|
||
high = (DWORD) offset_high;
|
||
|
||
/* Protect the seek / read operation with a mutex */
|
||
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
|
||
|
||
os_mutex_enter(os_file_seek_mutexes[i]);
|
||
|
||
ret2 = SetFilePointer(file, low, &high, FILE_BEGIN);
|
||
|
||
if (ret2 == 0xFFFFFFFF && GetLastError() != NO_ERROR) {
|
||
|
||
os_mutex_exit(os_file_seek_mutexes[i]);
|
||
|
||
goto error_handling;
|
||
}
|
||
|
||
os_n_pending_reads++;
|
||
|
||
ret = ReadFile(file, buf, (DWORD) n, &len, NULL);
|
||
|
||
os_n_pending_reads--;
|
||
|
||
os_mutex_exit(os_file_seek_mutexes[i]);
|
||
|
||
if (ret && len == n) {
|
||
return(TRUE);
|
||
}
|
||
#else
|
||
ibool retry;
|
||
ssize_t ret;
|
||
|
||
os_bytes_read_since_printout += n;
|
||
|
||
try_again:
|
||
os_n_pending_reads++;
|
||
|
||
ret = os_file_pread(file, buf, n, offset, offset_high);
|
||
|
||
os_n_pending_reads--;
|
||
|
||
if ((ulint)ret == n) {
|
||
|
||
return(TRUE);
|
||
}
|
||
#endif
|
||
#ifdef __WIN__
|
||
error_handling:
|
||
#endif
|
||
retry = os_file_handle_error_no_exit(NULL, "read");
|
||
|
||
if (retry) {
|
||
goto try_again;
|
||
}
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
/***********************************************************************
|
||
Requests a synchronous write operation. */
|
||
|
||
ibool
|
||
os_file_write(
|
||
/*==========*/
|
||
/* out: TRUE if request was
|
||
successful, FALSE if fail */
|
||
const char* name, /* in: name of the file or path as a
|
||
null-terminated string */
|
||
os_file_t file, /* in: handle to a file */
|
||
const void* buf, /* in: buffer from which to write */
|
||
ulint offset, /* in: least significant 32 bits of file
|
||
offset where to write */
|
||
ulint offset_high, /* in: most significant 32 bits of
|
||
offset */
|
||
ulint n) /* in: number of bytes to write */
|
||
{
|
||
#ifdef __WIN__
|
||
BOOL ret;
|
||
DWORD len;
|
||
DWORD ret2;
|
||
DWORD low;
|
||
DWORD high;
|
||
ulint i;
|
||
ulint n_retries = 0;
|
||
ulint err;
|
||
|
||
ut_a((offset & 0xFFFFFFFF) == offset);
|
||
|
||
os_n_file_writes++;
|
||
|
||
ut_ad(file);
|
||
ut_ad(buf);
|
||
ut_ad(n > 0);
|
||
retry:
|
||
low = (DWORD) offset;
|
||
high = (DWORD) offset_high;
|
||
|
||
/* Protect the seek / write operation with a mutex */
|
||
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
|
||
|
||
os_mutex_enter(os_file_seek_mutexes[i]);
|
||
|
||
ret2 = SetFilePointer(file, low, &high, FILE_BEGIN);
|
||
|
||
if (ret2 == 0xFFFFFFFF && GetLastError() != NO_ERROR) {
|
||
|
||
os_mutex_exit(os_file_seek_mutexes[i]);
|
||
|
||
ut_print_timestamp(stderr);
|
||
|
||
fprintf(stderr,
|
||
" InnoDB: Error: File pointer positioning to file %s failed at\n"
|
||
"InnoDB: offset %lu %lu. Operating system error number %lu.\n"
|
||
"InnoDB: Some operating system error numbers are described at\n"
|
||
"InnoDB: "
|
||
"http://dev.mysql.com/doc/mysql/en/Operating_System_error_codes.html\n",
|
||
name, (ulong) offset_high, (ulong) offset,
|
||
(ulong) GetLastError());
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
os_n_pending_writes++;
|
||
|
||
ret = WriteFile(file, buf, (DWORD) n, &len, NULL);
|
||
|
||
os_n_pending_writes--;
|
||
|
||
/* Always do fsync to reduce the probability that when the OS crashes,
|
||
a database page is only partially physically written to disk. */
|
||
|
||
if (!os_do_not_call_flush_at_each_write) {
|
||
ut_a(TRUE == os_file_flush(file));
|
||
}
|
||
|
||
os_mutex_exit(os_file_seek_mutexes[i]);
|
||
|
||
if (ret && len == n) {
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
/* If some background file system backup tool is running, then, at
|
||
least in Windows 2000, we may get here a specific error. Let us
|
||
retry the operation 100 times, with 1 second waits. */
|
||
|
||
if (GetLastError() == ERROR_LOCK_VIOLATION && n_retries < 100) {
|
||
|
||
os_thread_sleep(1000000);
|
||
|
||
n_retries++;
|
||
|
||
goto retry;
|
||
}
|
||
|
||
if (!os_has_said_disk_full) {
|
||
|
||
err = (ulint)GetLastError();
|
||
|
||
ut_print_timestamp(stderr);
|
||
|
||
fprintf(stderr,
|
||
" InnoDB: Error: Write to file %s failed at offset %lu %lu.\n"
|
||
"InnoDB: %lu bytes should have been written, only %lu were written.\n"
|
||
"InnoDB: Operating system error number %lu.\n"
|
||
"InnoDB: Check that your OS and file system support files of this size.\n"
|
||
"InnoDB: Check also that the disk is not full or a disk quota exceeded.\n",
|
||
name, (ulong) offset_high, (ulong) offset,
|
||
(ulong) n, (ulong) len, (ulong) err);
|
||
|
||
if (strerror((int)err) != NULL) {
|
||
fprintf(stderr,
|
||
"InnoDB: Error number %lu means '%s'.\n", (ulong) err, strerror((int)err));
|
||
}
|
||
|
||
fprintf(stderr,
|
||
"InnoDB: Some operating system error numbers are described at\n"
|
||
"InnoDB: "
|
||
"http://dev.mysql.com/doc/mysql/en/Operating_System_error_codes.html\n");
|
||
|
||
os_has_said_disk_full = TRUE;
|
||
}
|
||
|
||
return(FALSE);
|
||
#else
|
||
ssize_t ret;
|
||
|
||
os_n_pending_writes++;
|
||
|
||
ret = os_file_pwrite(file, buf, n, offset, offset_high);
|
||
|
||
os_n_pending_writes--;
|
||
|
||
if ((ulint)ret == n) {
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
if (!os_has_said_disk_full) {
|
||
|
||
ut_print_timestamp(stderr);
|
||
|
||
fprintf(stderr,
|
||
" InnoDB: Error: Write to file %s failed at offset %lu %lu.\n"
|
||
"InnoDB: %lu bytes should have been written, only %ld were written.\n"
|
||
"InnoDB: Operating system error number %lu.\n"
|
||
"InnoDB: Check that your OS and file system support files of this size.\n"
|
||
"InnoDB: Check also that the disk is not full or a disk quota exceeded.\n",
|
||
name, offset_high, offset, n, (long int)ret,
|
||
(ulint)errno);
|
||
if (strerror(errno) != NULL) {
|
||
fprintf(stderr,
|
||
"InnoDB: Error number %lu means '%s'.\n", (ulint)errno, strerror(errno));
|
||
}
|
||
|
||
fprintf(stderr,
|
||
"InnoDB: Some operating system error numbers are described at\n"
|
||
"InnoDB: "
|
||
"http://dev.mysql.com/doc/mysql/en/Operating_System_error_codes.html\n");
|
||
|
||
os_has_said_disk_full = TRUE;
|
||
}
|
||
|
||
return(FALSE);
|
||
#endif
|
||
}
|
||
|
||
/***********************************************************************
|
||
Check the existence and type of the given file. */
|
||
|
||
ibool
|
||
os_file_status(
|
||
/*===========*/
|
||
/* out: TRUE if call succeeded */
|
||
const char* path, /* in: pathname of the file */
|
||
ibool* exists, /* out: TRUE if file exists */
|
||
os_file_type_t* type) /* out: type of the file (if it exists) */
|
||
{
|
||
#ifdef __WIN__
|
||
int ret;
|
||
struct _stat statinfo;
|
||
|
||
ret = _stat(path, &statinfo);
|
||
if (ret && (errno == ENOENT || errno == ENOTDIR)) {
|
||
/* file does not exist */
|
||
*exists = FALSE;
|
||
return(TRUE);
|
||
} else if (ret) {
|
||
/* file exists, but stat call failed */
|
||
|
||
os_file_handle_error_no_exit(path, "stat");
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
if (_S_IFDIR & statinfo.st_mode) {
|
||
*type = OS_FILE_TYPE_DIR;
|
||
} else if (_S_IFREG & statinfo.st_mode) {
|
||
*type = OS_FILE_TYPE_FILE;
|
||
} else {
|
||
*type = OS_FILE_TYPE_UNKNOWN;
|
||
}
|
||
|
||
*exists = TRUE;
|
||
|
||
return(TRUE);
|
||
#else
|
||
int ret;
|
||
struct stat statinfo;
|
||
|
||
ret = stat(path, &statinfo);
|
||
if (ret && (errno == ENOENT || errno == ENOTDIR)) {
|
||
/* file does not exist */
|
||
*exists = FALSE;
|
||
return(TRUE);
|
||
} else if (ret) {
|
||
/* file exists, but stat call failed */
|
||
|
||
os_file_handle_error_no_exit(path, "stat");
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
if (S_ISDIR(statinfo.st_mode)) {
|
||
*type = OS_FILE_TYPE_DIR;
|
||
} else if (S_ISLNK(statinfo.st_mode)) {
|
||
*type = OS_FILE_TYPE_LINK;
|
||
} else if (S_ISREG(statinfo.st_mode)) {
|
||
*type = OS_FILE_TYPE_FILE;
|
||
} else {
|
||
*type = OS_FILE_TYPE_UNKNOWN;
|
||
}
|
||
|
||
*exists = TRUE;
|
||
|
||
return(TRUE);
|
||
#endif
|
||
}
|
||
|
||
/***********************************************************************
|
||
This function returns information about the specified file */
|
||
|
||
ibool
|
||
os_file_get_status(
|
||
/*===========*/
|
||
/* out: TRUE if stat information found */
|
||
const char* path, /* in: pathname of the file */
|
||
os_file_stat_t* stat_info) /* information of a file in a directory */
|
||
{
|
||
#ifdef __WIN__
|
||
int ret;
|
||
struct _stat statinfo;
|
||
|
||
ret = _stat(path, &statinfo);
|
||
if (ret && (errno == ENOENT || errno == ENOTDIR)) {
|
||
/* file does not exist */
|
||
|
||
return(FALSE);
|
||
} else if (ret) {
|
||
/* file exists, but stat call failed */
|
||
|
||
os_file_handle_error_no_exit(path, "stat");
|
||
|
||
return(FALSE);
|
||
}
|
||
if (_S_IFDIR & statinfo.st_mode) {
|
||
stat_info->type = OS_FILE_TYPE_DIR;
|
||
} else if (_S_IFREG & statinfo.st_mode) {
|
||
stat_info->type = OS_FILE_TYPE_FILE;
|
||
} else {
|
||
stat_info->type = OS_FILE_TYPE_UNKNOWN;
|
||
}
|
||
|
||
stat_info->ctime = statinfo.st_ctime;
|
||
stat_info->atime = statinfo.st_atime;
|
||
stat_info->mtime = statinfo.st_mtime;
|
||
stat_info->size = statinfo.st_size;
|
||
|
||
return(TRUE);
|
||
#else
|
||
int ret;
|
||
struct stat statinfo;
|
||
|
||
ret = stat(path, &statinfo);
|
||
|
||
if (ret && (errno == ENOENT || errno == ENOTDIR)) {
|
||
/* file does not exist */
|
||
|
||
return(FALSE);
|
||
} else if (ret) {
|
||
/* file exists, but stat call failed */
|
||
|
||
os_file_handle_error_no_exit(path, "stat");
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
if (S_ISDIR(statinfo.st_mode)) {
|
||
stat_info->type = OS_FILE_TYPE_DIR;
|
||
} else if (S_ISLNK(statinfo.st_mode)) {
|
||
stat_info->type = OS_FILE_TYPE_LINK;
|
||
} else if (S_ISREG(statinfo.st_mode)) {
|
||
stat_info->type = OS_FILE_TYPE_FILE;
|
||
} else {
|
||
stat_info->type = OS_FILE_TYPE_UNKNOWN;
|
||
}
|
||
|
||
stat_info->ctime = statinfo.st_ctime;
|
||
stat_info->atime = statinfo.st_atime;
|
||
stat_info->mtime = statinfo.st_mtime;
|
||
stat_info->size = statinfo.st_size;
|
||
|
||
return(TRUE);
|
||
#endif
|
||
}
|
||
|
||
/* path name separator character */
|
||
#ifdef __WIN__
|
||
# define OS_FILE_PATH_SEPARATOR '\\'
|
||
#else
|
||
# define OS_FILE_PATH_SEPARATOR '/'
|
||
#endif
|
||
|
||
/********************************************************************
|
||
The function os_file_dirname returns a directory component of a
|
||
null-terminated pathname string. In the usual case, dirname returns
|
||
the string up to, but not including, the final '/', and basename
|
||
is the component following the final '/'. Trailing '/' charac<61>
|
||
ters are not counted as part of the pathname.
|
||
|
||
If path does not contain a slash, dirname returns the string ".".
|
||
|
||
Concatenating the string returned by dirname, a "/", and the basename
|
||
yields a complete pathname.
|
||
|
||
The return value is a copy of the directory component of the pathname.
|
||
The copy is allocated from heap. It is the caller responsibility
|
||
to free it after it is no longer needed.
|
||
|
||
The following list of examples (taken from SUSv2) shows the strings
|
||
returned by dirname and basename for different paths:
|
||
|
||
path dirname basename
|
||
"/usr/lib" "/usr" "lib"
|
||
"/usr/" "/" "usr"
|
||
"usr" "." "usr"
|
||
"/" "/" "/"
|
||
"." "." "."
|
||
".." "." ".."
|
||
*/
|
||
|
||
char*
|
||
os_file_dirname(
|
||
/*============*/
|
||
/* out, own: directory component of the
|
||
pathname */
|
||
const char* path) /* in: pathname */
|
||
{
|
||
/* Find the offset of the last slash */
|
||
const char* last_slash = strrchr(path, OS_FILE_PATH_SEPARATOR);
|
||
if (!last_slash) {
|
||
/* No slash in the path, return "." */
|
||
|
||
return(mem_strdup("."));
|
||
}
|
||
|
||
/* Ok, there is a slash */
|
||
|
||
if (last_slash == path) {
|
||
/* last slash is the first char of the path */
|
||
|
||
return(mem_strdup("/"));
|
||
}
|
||
|
||
/* Non-trivial directory component */
|
||
|
||
return(mem_strdupl(path, last_slash - path));
|
||
}
|
||
|
||
/********************************************************************
|
||
Creates all missing subdirectories along the given path. */
|
||
|
||
ibool
|
||
os_file_create_subdirs_if_needed(
|
||
/*=============================*/
|
||
/* out: TRUE if call succeeded
|
||
FALSE otherwise */
|
||
const char* path) /* in: path name */
|
||
{
|
||
char* subdir;
|
||
ibool success, subdir_exists;
|
||
os_file_type_t type;
|
||
|
||
subdir = os_file_dirname(path);
|
||
if (strlen(subdir) == 1
|
||
&& (*subdir == OS_FILE_PATH_SEPARATOR || *subdir == '.')) {
|
||
/* subdir is root or cwd, nothing to do */
|
||
mem_free(subdir);
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
/* Test if subdir exists */
|
||
success = os_file_status(subdir, &subdir_exists, &type);
|
||
if (success && !subdir_exists) {
|
||
/* subdir does not exist, create it */
|
||
success = os_file_create_subdirs_if_needed(subdir);
|
||
if (!success) {
|
||
mem_free(subdir);
|
||
|
||
return(FALSE);
|
||
}
|
||
success = os_file_create_directory(subdir, FALSE);
|
||
}
|
||
|
||
mem_free(subdir);
|
||
|
||
return(success);
|
||
}
|
||
|
||
/********************************************************************
|
||
Returns a pointer to the nth slot in the aio array. */
|
||
static
|
||
os_aio_slot_t*
|
||
os_aio_array_get_nth_slot(
|
||
/*======================*/
|
||
/* out: pointer to slot */
|
||
os_aio_array_t* array, /* in: aio array */
|
||
ulint index) /* in: index of the slot */
|
||
{
|
||
ut_a(index < array->n_slots);
|
||
|
||
return((array->slots) + index);
|
||
}
|
||
|
||
/****************************************************************************
|
||
Creates an aio wait array. */
|
||
static
|
||
os_aio_array_t*
|
||
os_aio_array_create(
|
||
/*================*/
|
||
/* out, own: aio array */
|
||
ulint n, /* in: maximum number of pending aio operations
|
||
allowed; n must be divisible by n_segments */
|
||
ulint n_segments) /* in: number of segments in the aio array */
|
||
{
|
||
os_aio_array_t* array;
|
||
ulint i;
|
||
os_aio_slot_t* slot;
|
||
#ifdef WIN_ASYNC_IO
|
||
OVERLAPPED* over;
|
||
#endif
|
||
ut_a(n > 0);
|
||
ut_a(n_segments > 0);
|
||
|
||
array = ut_malloc(sizeof(os_aio_array_t));
|
||
|
||
array->mutex = os_mutex_create(NULL);
|
||
array->not_full = os_event_create(NULL);
|
||
array->is_empty = os_event_create(NULL);
|
||
|
||
os_event_set(array->is_empty);
|
||
|
||
array->n_slots = n;
|
||
array->n_segments = n_segments;
|
||
array->n_reserved = 0;
|
||
array->slots = ut_malloc(n * sizeof(os_aio_slot_t));
|
||
#ifdef __WIN__
|
||
array->native_events = ut_malloc(n * sizeof(os_native_event_t));
|
||
#endif
|
||
for (i = 0; i < n; i++) {
|
||
slot = os_aio_array_get_nth_slot(array, i);
|
||
|
||
slot->pos = i;
|
||
slot->reserved = FALSE;
|
||
#ifdef WIN_ASYNC_IO
|
||
slot->event = os_event_create(NULL);
|
||
|
||
over = &(slot->control);
|
||
|
||
over->hEvent = slot->event->handle;
|
||
|
||
*((array->native_events) + i) = over->hEvent;
|
||
#endif
|
||
}
|
||
|
||
return(array);
|
||
}
|
||
|
||
/****************************************************************************
|
||
Initializes the asynchronous io system. Calls also os_io_init_simple.
|
||
Creates a separate aio array for
|
||
non-ibuf read and write, a third aio array for the ibuf i/o, with just one
|
||
segment, two aio arrays for log reads and writes with one segment, and a
|
||
synchronous aio array of the specified size. The combined number of segments
|
||
in the three first aio arrays is the parameter n_segments given to the
|
||
function. The caller must create an i/o handler thread for each segment in
|
||
the four first arrays, but not for the sync aio array. */
|
||
|
||
void
|
||
os_aio_init(
|
||
/*========*/
|
||
ulint n, /* in: maximum number of pending aio operations
|
||
allowed; n must be divisible by n_segments */
|
||
ulint n_segments, /* in: combined number of segments in the four
|
||
first aio arrays; must be >= 4 */
|
||
ulint n_slots_sync) /* in: number of slots in the sync aio array */
|
||
{
|
||
ulint n_read_segs;
|
||
ulint n_write_segs;
|
||
ulint n_per_seg;
|
||
ulint i;
|
||
#ifdef POSIX_ASYNC_IO
|
||
sigset_t sigset;
|
||
#endif
|
||
ut_ad(n % n_segments == 0);
|
||
ut_ad(n_segments >= 4);
|
||
|
||
os_io_init_simple();
|
||
|
||
for (i = 0; i < n_segments; i++) {
|
||
srv_set_io_thread_op_info(i, "not started yet");
|
||
}
|
||
|
||
n_per_seg = n / n_segments;
|
||
n_write_segs = (n_segments - 2) / 2;
|
||
n_read_segs = n_segments - 2 - n_write_segs;
|
||
|
||
/* fprintf(stderr, "Array n per seg %lu\n", n_per_seg); */
|
||
|
||
os_aio_ibuf_array = os_aio_array_create(n_per_seg, 1);
|
||
|
||
srv_io_thread_function[0] = "insert buffer thread";
|
||
|
||
os_aio_log_array = os_aio_array_create(n_per_seg, 1);
|
||
|
||
srv_io_thread_function[1] = "log thread";
|
||
|
||
os_aio_read_array = os_aio_array_create(n_read_segs * n_per_seg,
|
||
n_read_segs);
|
||
for (i = 2; i < 2 + n_read_segs; i++) {
|
||
ut_a(i < SRV_MAX_N_IO_THREADS);
|
||
srv_io_thread_function[i] = "read thread";
|
||
}
|
||
|
||
os_aio_write_array = os_aio_array_create(n_write_segs * n_per_seg,
|
||
n_write_segs);
|
||
for (i = 2 + n_read_segs; i < n_segments; i++) {
|
||
ut_a(i < SRV_MAX_N_IO_THREADS);
|
||
srv_io_thread_function[i] = "write thread";
|
||
}
|
||
|
||
os_aio_sync_array = os_aio_array_create(n_slots_sync, 1);
|
||
|
||
os_aio_n_segments = n_segments;
|
||
|
||
os_aio_validate();
|
||
|
||
os_aio_segment_wait_events = ut_malloc(n_segments * sizeof(void*));
|
||
|
||
for (i = 0; i < n_segments; i++) {
|
||
os_aio_segment_wait_events[i] = os_event_create(NULL);
|
||
}
|
||
|
||
os_last_printout = time(NULL);
|
||
|
||
#ifdef POSIX_ASYNC_IO
|
||
/* Block aio signals from the current thread and its children:
|
||
for this to work, the current thread must be the first created
|
||
in the database, so that all its children will inherit its
|
||
signal mask */
|
||
|
||
/* TODO: to work MySQL needs the SIGALARM signal; the following
|
||
will not work yet! */
|
||
sigemptyset(&sigset);
|
||
sigaddset(&sigset, SIGRTMIN + 1 + 0);
|
||
sigaddset(&sigset, SIGRTMIN + 1 + 1);
|
||
sigaddset(&sigset, SIGRTMIN + 1 + 2);
|
||
sigaddset(&sigset, SIGRTMIN + 1 + 3);
|
||
|
||
pthread_sigmask(SIG_BLOCK, &sigset, NULL); */
|
||
#endif
|
||
}
|
||
|
||
#ifdef WIN_ASYNC_IO
|
||
/****************************************************************************
|
||
Wakes up all async i/o threads in the array in Windows async i/o at
|
||
shutdown. */
|
||
static
|
||
void
|
||
os_aio_array_wake_win_aio_at_shutdown(
|
||
/*==================================*/
|
||
os_aio_array_t* array) /* in: aio array */
|
||
{
|
||
ulint i;
|
||
|
||
for (i = 0; i < array->n_slots; i++) {
|
||
|
||
os_event_set((array->slots + i)->event);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/****************************************************************************
|
||
Wakes up all async i/o threads so that they know to exit themselves in
|
||
shutdown. */
|
||
|
||
void
|
||
os_aio_wake_all_threads_at_shutdown(void)
|
||
/*=====================================*/
|
||
{
|
||
ulint i;
|
||
|
||
#ifdef WIN_ASYNC_IO
|
||
/* This code wakes up all ai/o threads in Windows native aio */
|
||
os_aio_array_wake_win_aio_at_shutdown(os_aio_read_array);
|
||
os_aio_array_wake_win_aio_at_shutdown(os_aio_write_array);
|
||
os_aio_array_wake_win_aio_at_shutdown(os_aio_ibuf_array);
|
||
os_aio_array_wake_win_aio_at_shutdown(os_aio_log_array);
|
||
#endif
|
||
/* This loop wakes up all simulated ai/o threads */
|
||
|
||
for (i = 0; i < os_aio_n_segments; i++) {
|
||
|
||
os_event_set(os_aio_segment_wait_events[i]);
|
||
}
|
||
}
|
||
|
||
/****************************************************************************
|
||
Waits until there are no pending writes in os_aio_write_array. There can
|
||
be other, synchronous, pending writes. */
|
||
|
||
void
|
||
os_aio_wait_until_no_pending_writes(void)
|
||
/*=====================================*/
|
||
{
|
||
os_event_wait(os_aio_write_array->is_empty);
|
||
}
|
||
|
||
/**************************************************************************
|
||
Calculates segment number for a slot. */
|
||
static
|
||
ulint
|
||
os_aio_get_segment_no_from_slot(
|
||
/*============================*/
|
||
/* out: segment number (which is the number
|
||
used by, for example, i/o-handler threads) */
|
||
os_aio_array_t* array, /* in: aio wait array */
|
||
os_aio_slot_t* slot) /* in: slot in this array */
|
||
{
|
||
ulint segment;
|
||
ulint seg_len;
|
||
|
||
if (array == os_aio_ibuf_array) {
|
||
segment = 0;
|
||
|
||
} else if (array == os_aio_log_array) {
|
||
segment = 1;
|
||
|
||
} else if (array == os_aio_read_array) {
|
||
seg_len = os_aio_read_array->n_slots /
|
||
os_aio_read_array->n_segments;
|
||
|
||
segment = 2 + slot->pos / seg_len;
|
||
} else {
|
||
ut_a(array == os_aio_write_array);
|
||
seg_len = os_aio_write_array->n_slots /
|
||
os_aio_write_array->n_segments;
|
||
|
||
segment = os_aio_read_array->n_segments + 2
|
||
+ slot->pos / seg_len;
|
||
}
|
||
|
||
return(segment);
|
||
}
|
||
|
||
/**************************************************************************
|
||
Calculates local segment number and aio array from global segment number. */
|
||
static
|
||
ulint
|
||
os_aio_get_array_and_local_segment(
|
||
/*===============================*/
|
||
/* out: local segment number within
|
||
the aio array */
|
||
os_aio_array_t** array, /* out: aio wait array */
|
||
ulint global_segment)/* in: global segment number */
|
||
{
|
||
ulint segment;
|
||
|
||
ut_a(global_segment < os_aio_n_segments);
|
||
|
||
if (global_segment == 0) {
|
||
*array = os_aio_ibuf_array;
|
||
segment = 0;
|
||
|
||
} else if (global_segment == 1) {
|
||
*array = os_aio_log_array;
|
||
segment = 0;
|
||
|
||
} else if (global_segment < os_aio_read_array->n_segments + 2) {
|
||
*array = os_aio_read_array;
|
||
|
||
segment = global_segment - 2;
|
||
} else {
|
||
*array = os_aio_write_array;
|
||
|
||
segment = global_segment - (os_aio_read_array->n_segments + 2);
|
||
}
|
||
|
||
return(segment);
|
||
}
|
||
|
||
/***********************************************************************
|
||
Gets an integer value designating a specified aio array. This is used
|
||
to give numbers to signals in Posix aio. */
|
||
|
||
#if !defined(WIN_ASYNC_IO) && defined(POSIX_ASYNC_IO)
|
||
static
|
||
ulint
|
||
os_aio_get_array_no(
|
||
/*================*/
|
||
os_aio_array_t* array) /* in: aio array */
|
||
{
|
||
if (array == os_aio_ibuf_array) {
|
||
|
||
return(0);
|
||
|
||
} else if (array == os_aio_log_array) {
|
||
|
||
return(1);
|
||
|
||
} else if (array == os_aio_read_array) {
|
||
|
||
return(2);
|
||
} else if (array == os_aio_write_array) {
|
||
|
||
return(3);
|
||
} else {
|
||
ut_error;
|
||
|
||
return(0);
|
||
}
|
||
}
|
||
|
||
/***********************************************************************
|
||
Gets the aio array for its number. */
|
||
static
|
||
os_aio_array_t*
|
||
os_aio_get_array_from_no(
|
||
/*=====================*/
|
||
/* out: aio array */
|
||
ulint n) /* in: array number */
|
||
{
|
||
if (n == 0) {
|
||
return(os_aio_ibuf_array);
|
||
} else if (n == 1) {
|
||
|
||
return(os_aio_log_array);
|
||
} else if (n == 2) {
|
||
|
||
return(os_aio_read_array);
|
||
} else if (n == 3) {
|
||
|
||
return(os_aio_write_array);
|
||
} else {
|
||
ut_error;
|
||
|
||
return(NULL);
|
||
}
|
||
}
|
||
#endif /* if !defined(WIN_ASYNC_IO) && defined(POSIX_ASYNC_IO) */
|
||
|
||
/***********************************************************************
|
||
Requests for a slot in the aio array. If no slot is available, waits until
|
||
not_full-event becomes signaled. */
|
||
static
|
||
os_aio_slot_t*
|
||
os_aio_array_reserve_slot(
|
||
/*======================*/
|
||
/* out: pointer to slot */
|
||
ulint type, /* in: OS_FILE_READ or OS_FILE_WRITE */
|
||
os_aio_array_t* array, /* in: aio array */
|
||
void* message1,/* in: message to be passed along with
|
||
the aio operation */
|
||
void* message2,/* in: message to be passed along with
|
||
the aio operation */
|
||
os_file_t file, /* in: file handle */
|
||
const char* name, /* in: name of the file or path as a
|
||
null-terminated string */
|
||
void* buf, /* in: buffer where to read or from which
|
||
to write */
|
||
ulint offset, /* in: least significant 32 bits of file
|
||
offset */
|
||
ulint offset_high, /* in: most significant 32 bits of
|
||
offset */
|
||
ulint len) /* in: length of the block to read or write */
|
||
{
|
||
os_aio_slot_t* slot;
|
||
#ifdef WIN_ASYNC_IO
|
||
OVERLAPPED* control;
|
||
|
||
#elif defined(POSIX_ASYNC_IO)
|
||
|
||
struct aiocb* control;
|
||
#endif
|
||
ulint i;
|
||
loop:
|
||
os_mutex_enter(array->mutex);
|
||
|
||
if (array->n_reserved == array->n_slots) {
|
||
os_mutex_exit(array->mutex);
|
||
|
||
if (!os_aio_use_native_aio) {
|
||
/* If the handler threads are suspended, wake them
|
||
so that we get more slots */
|
||
|
||
os_aio_simulated_wake_handler_threads();
|
||
}
|
||
|
||
os_event_wait(array->not_full);
|
||
|
||
goto loop;
|
||
}
|
||
|
||
for (i = 0;; i++) {
|
||
slot = os_aio_array_get_nth_slot(array, i);
|
||
|
||
if (slot->reserved == FALSE) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
array->n_reserved++;
|
||
|
||
if (array->n_reserved == 1) {
|
||
os_event_reset(array->is_empty);
|
||
}
|
||
|
||
if (array->n_reserved == array->n_slots) {
|
||
os_event_reset(array->not_full);
|
||
}
|
||
|
||
slot->reserved = TRUE;
|
||
slot->reservation_time = time(NULL);
|
||
slot->message1 = message1;
|
||
slot->message2 = message2;
|
||
slot->file = file;
|
||
slot->name = name;
|
||
slot->len = len;
|
||
slot->type = type;
|
||
slot->buf = buf;
|
||
slot->offset = offset;
|
||
slot->offset_high = offset_high;
|
||
slot->io_already_done = FALSE;
|
||
|
||
#ifdef WIN_ASYNC_IO
|
||
control = &(slot->control);
|
||
control->Offset = (DWORD)offset;
|
||
control->OffsetHigh = (DWORD)offset_high;
|
||
os_event_reset(slot->event);
|
||
|
||
#elif defined(POSIX_ASYNC_IO)
|
||
|
||
#if (UNIV_WORD_SIZE == 8)
|
||
offset = offset + (offset_high << 32);
|
||
#else
|
||
ut_a(offset_high == 0);
|
||
#endif
|
||
control = &(slot->control);
|
||
control->aio_fildes = file;
|
||
control->aio_buf = buf;
|
||
control->aio_nbytes = len;
|
||
control->aio_offset = offset;
|
||
control->aio_reqprio = 0;
|
||
control->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
|
||
control->aio_sigevent.sigev_signo =
|
||
SIGRTMIN + 1 + os_aio_get_array_no(array);
|
||
/* TODO: How to choose the signal numbers? */
|
||
/*
|
||
fprintf(stderr, "AIO signal number %lu\n",
|
||
(ulint) control->aio_sigevent.sigev_signo);
|
||
*/
|
||
control->aio_sigevent.sigev_value.sival_ptr = slot;
|
||
#endif
|
||
os_mutex_exit(array->mutex);
|
||
|
||
return(slot);
|
||
}
|
||
|
||
/***********************************************************************
|
||
Frees a slot in the aio array. */
|
||
static
|
||
void
|
||
os_aio_array_free_slot(
|
||
/*===================*/
|
||
os_aio_array_t* array, /* in: aio array */
|
||
os_aio_slot_t* slot) /* in: pointer to slot */
|
||
{
|
||
ut_ad(array);
|
||
ut_ad(slot);
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
ut_ad(slot->reserved);
|
||
|
||
slot->reserved = FALSE;
|
||
|
||
array->n_reserved--;
|
||
|
||
if (array->n_reserved == array->n_slots - 1) {
|
||
os_event_set(array->not_full);
|
||
}
|
||
|
||
if (array->n_reserved == 0) {
|
||
os_event_set(array->is_empty);
|
||
}
|
||
|
||
#ifdef WIN_ASYNC_IO
|
||
os_event_reset(slot->event);
|
||
#endif
|
||
os_mutex_exit(array->mutex);
|
||
}
|
||
|
||
/**************************************************************************
|
||
Wakes up a simulated aio i/o-handler thread if it has something to do. */
|
||
static
|
||
void
|
||
os_aio_simulated_wake_handler_thread(
|
||
/*=================================*/
|
||
ulint global_segment) /* in: the number of the segment in the aio
|
||
arrays */
|
||
{
|
||
os_aio_array_t* array;
|
||
os_aio_slot_t* slot;
|
||
ulint segment;
|
||
ulint n;
|
||
ulint i;
|
||
|
||
ut_ad(!os_aio_use_native_aio);
|
||
|
||
segment = os_aio_get_array_and_local_segment(&array, global_segment);
|
||
|
||
n = array->n_slots / array->n_segments;
|
||
|
||
/* Look through n slots after the segment * n'th slot */
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
for (i = 0; i < n; i++) {
|
||
slot = os_aio_array_get_nth_slot(array, i + segment * n);
|
||
|
||
if (slot->reserved) {
|
||
/* Found an i/o request */
|
||
|
||
break;
|
||
}
|
||
}
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
if (i < n) {
|
||
os_event_set(os_aio_segment_wait_events[global_segment]);
|
||
}
|
||
}
|
||
|
||
/**************************************************************************
|
||
Wakes up simulated aio i/o-handler threads if they have something to do. */
|
||
|
||
void
|
||
os_aio_simulated_wake_handler_threads(void)
|
||
/*=======================================*/
|
||
{
|
||
ulint i;
|
||
|
||
if (os_aio_use_native_aio) {
|
||
/* We do not use simulated aio: do nothing */
|
||
|
||
return;
|
||
}
|
||
|
||
os_aio_recommend_sleep_for_read_threads = FALSE;
|
||
|
||
for (i = 0; i < os_aio_n_segments; i++) {
|
||
os_aio_simulated_wake_handler_thread(i);
|
||
}
|
||
}
|
||
|
||
/**************************************************************************
|
||
This function can be called if one wants to post a batch of reads and
|
||
prefers an i/o-handler thread to handle them all at once later. You must
|
||
call os_aio_simulated_wake_handler_threads later to ensure the threads
|
||
are not left sleeping! */
|
||
|
||
void
|
||
os_aio_simulated_put_read_threads_to_sleep(void)
|
||
/*============================================*/
|
||
{
|
||
os_aio_array_t* array;
|
||
ulint g;
|
||
|
||
os_aio_recommend_sleep_for_read_threads = TRUE;
|
||
|
||
for (g = 0; g < os_aio_n_segments; g++) {
|
||
os_aio_get_array_and_local_segment(&array, g);
|
||
|
||
if (array == os_aio_read_array) {
|
||
|
||
os_event_reset(os_aio_segment_wait_events[g]);
|
||
}
|
||
}
|
||
}
|
||
|
||
/***********************************************************************
|
||
Requests an asynchronous i/o operation. */
|
||
|
||
ibool
|
||
os_aio(
|
||
/*===*/
|
||
/* out: TRUE if request was queued
|
||
successfully, FALSE if fail */
|
||
ulint type, /* in: OS_FILE_READ or OS_FILE_WRITE */
|
||
ulint mode, /* in: OS_AIO_NORMAL, ..., possibly ORed
|
||
to OS_AIO_SIMULATED_WAKE_LATER: the
|
||
last flag advises this function not to wake
|
||
i/o-handler threads, but the caller will
|
||
do the waking explicitly later, in this
|
||
way the caller can post several requests in
|
||
a batch; NOTE that the batch must not be
|
||
so big that it exhausts the slots in aio
|
||
arrays! NOTE that a simulated batch
|
||
may introduce hidden chances of deadlocks,
|
||
because i/os are not actually handled until
|
||
all have been posted: use with great
|
||
caution! */
|
||
const char* name, /* in: name of the file or path as a
|
||
null-terminated string */
|
||
os_file_t file, /* in: handle to a file */
|
||
void* buf, /* in: buffer where to read or from which
|
||
to write */
|
||
ulint offset, /* in: least significant 32 bits of file
|
||
offset where to read or write */
|
||
ulint offset_high, /* in: most significant 32 bits of
|
||
offset */
|
||
ulint n, /* in: number of bytes to read or write */
|
||
void* message1,/* in: messages for the aio handler (these
|
||
can be used to identify a completed aio
|
||
operation); if mode is OS_AIO_SYNC, these
|
||
are ignored */
|
||
void* message2)
|
||
{
|
||
os_aio_array_t* array;
|
||
os_aio_slot_t* slot;
|
||
#ifdef WIN_ASYNC_IO
|
||
ibool retval;
|
||
BOOL ret = TRUE;
|
||
DWORD len = (DWORD) n;
|
||
void* dummy_mess1;
|
||
void* dummy_mess2;
|
||
ulint dummy_type;
|
||
#endif
|
||
ulint err = 0;
|
||
ibool retry;
|
||
ulint wake_later;
|
||
|
||
ut_ad(file);
|
||
ut_ad(buf);
|
||
ut_ad(n > 0);
|
||
ut_ad(n % OS_FILE_LOG_BLOCK_SIZE == 0);
|
||
ut_ad(offset % OS_FILE_LOG_BLOCK_SIZE == 0);
|
||
ut_ad(os_aio_validate());
|
||
|
||
wake_later = mode & OS_AIO_SIMULATED_WAKE_LATER;
|
||
mode = mode & (~OS_AIO_SIMULATED_WAKE_LATER);
|
||
|
||
if (mode == OS_AIO_SYNC
|
||
#ifdef WIN_ASYNC_IO
|
||
&& !os_aio_use_native_aio
|
||
#endif
|
||
) {
|
||
/* This is actually an ordinary synchronous read or write:
|
||
no need to use an i/o-handler thread. NOTE that if we use
|
||
Windows async i/o, Windows does not allow us to use
|
||
ordinary synchronous os_file_read etc. on the same file,
|
||
therefore we have built a special mechanism for synchronous
|
||
wait in the Windows case. */
|
||
|
||
if (type == OS_FILE_READ) {
|
||
return(os_file_read(file, buf, offset,
|
||
offset_high, n));
|
||
}
|
||
|
||
ut_a(type == OS_FILE_WRITE);
|
||
|
||
return(os_file_write(name, file, buf, offset, offset_high, n));
|
||
}
|
||
|
||
try_again:
|
||
if (mode == OS_AIO_NORMAL) {
|
||
if (type == OS_FILE_READ) {
|
||
array = os_aio_read_array;
|
||
} else {
|
||
array = os_aio_write_array;
|
||
}
|
||
} else if (mode == OS_AIO_IBUF) {
|
||
ut_ad(type == OS_FILE_READ);
|
||
/* Reduce probability of deadlock bugs in connection with ibuf:
|
||
do not let the ibuf i/o handler sleep */
|
||
|
||
wake_later = FALSE;
|
||
|
||
array = os_aio_ibuf_array;
|
||
} else if (mode == OS_AIO_LOG) {
|
||
|
||
array = os_aio_log_array;
|
||
} else if (mode == OS_AIO_SYNC) {
|
||
array = os_aio_sync_array;
|
||
} else {
|
||
array = NULL; /* Eliminate compiler warning */
|
||
ut_error;
|
||
}
|
||
|
||
slot = os_aio_array_reserve_slot(type, array, message1, message2, file,
|
||
name, buf, offset, offset_high, n);
|
||
if (type == OS_FILE_READ) {
|
||
if (os_aio_use_native_aio) {
|
||
#ifdef WIN_ASYNC_IO
|
||
os_n_file_reads++;
|
||
os_bytes_read_since_printout += len;
|
||
|
||
ret = ReadFile(file, buf, (DWORD)n, &len,
|
||
&(slot->control));
|
||
#elif defined(POSIX_ASYNC_IO)
|
||
slot->control.aio_lio_opcode = LIO_READ;
|
||
err = (ulint) aio_read(&(slot->control));
|
||
fprintf(stderr, "Starting POSIX aio read %lu\n", err);
|
||
#endif
|
||
} else {
|
||
if (!wake_later) {
|
||
os_aio_simulated_wake_handler_thread(
|
||
os_aio_get_segment_no_from_slot(array, slot));
|
||
}
|
||
}
|
||
} else if (type == OS_FILE_WRITE) {
|
||
if (os_aio_use_native_aio) {
|
||
#ifdef WIN_ASYNC_IO
|
||
os_n_file_writes++;
|
||
ret = WriteFile(file, buf, (DWORD)n, &len,
|
||
&(slot->control));
|
||
#elif defined(POSIX_ASYNC_IO)
|
||
slot->control.aio_lio_opcode = LIO_WRITE;
|
||
err = (ulint) aio_write(&(slot->control));
|
||
fprintf(stderr, "Starting POSIX aio write %lu\n", err);
|
||
#endif
|
||
} else {
|
||
if (!wake_later) {
|
||
os_aio_simulated_wake_handler_thread(
|
||
os_aio_get_segment_no_from_slot(array, slot));
|
||
}
|
||
}
|
||
} else {
|
||
ut_error;
|
||
}
|
||
|
||
#ifdef WIN_ASYNC_IO
|
||
if (os_aio_use_native_aio) {
|
||
if ((ret && len == n)
|
||
|| (!ret && GetLastError() == ERROR_IO_PENDING)) {
|
||
/* aio was queued successfully! */
|
||
|
||
if (mode == OS_AIO_SYNC) {
|
||
/* We want a synchronous i/o operation on a file
|
||
where we also use async i/o: in Windows we must
|
||
use the same wait mechanism as for async i/o */
|
||
|
||
retval = os_aio_windows_handle(ULINT_UNDEFINED,
|
||
slot->pos,
|
||
&dummy_mess1, &dummy_mess2,
|
||
&dummy_type);
|
||
|
||
return(retval);
|
||
}
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
err = 1; /* Fall through the next if */
|
||
}
|
||
#endif
|
||
if (err == 0) {
|
||
/* aio was queued successfully! */
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
os_aio_array_free_slot(array, slot);
|
||
|
||
retry = os_file_handle_error(name,
|
||
type == OS_FILE_READ ? "aio read" : "aio write");
|
||
if (retry) {
|
||
|
||
goto try_again;
|
||
}
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
#ifdef WIN_ASYNC_IO
|
||
/**************************************************************************
|
||
This function is only used in Windows asynchronous i/o.
|
||
Waits for an aio operation to complete. This function is used to wait the
|
||
for completed requests. The aio array of pending requests is divided
|
||
into segments. The thread specifies which segment or slot it wants to wait
|
||
for. NOTE: this function will also take care of freeing the aio slot,
|
||
therefore no other thread is allowed to do the freeing! */
|
||
|
||
ibool
|
||
os_aio_windows_handle(
|
||
/*==================*/
|
||
/* out: TRUE if the aio operation succeeded */
|
||
ulint segment, /* in: the number of the segment in the aio
|
||
arrays to wait for; segment 0 is the ibuf
|
||
i/o thread, segment 1 the log i/o thread,
|
||
then follow the non-ibuf read threads, and as
|
||
the last are the non-ibuf write threads; if
|
||
this is ULINT_UNDEFINED, then it means that
|
||
sync aio is used, and this parameter is
|
||
ignored */
|
||
ulint pos, /* this parameter is used only in sync aio:
|
||
wait for the aio slot at this position */
|
||
void** message1, /* out: the messages passed with the aio
|
||
request; note that also in the case where
|
||
the aio operation failed, these output
|
||
parameters are valid and can be used to
|
||
restart the operation, for example */
|
||
void** message2,
|
||
ulint* type) /* out: OS_FILE_WRITE or ..._READ */
|
||
{
|
||
ulint orig_seg = segment;
|
||
os_aio_array_t* array;
|
||
os_aio_slot_t* slot;
|
||
ulint n;
|
||
ulint i;
|
||
ibool ret_val;
|
||
BOOL ret;
|
||
DWORD len;
|
||
|
||
if (segment == ULINT_UNDEFINED) {
|
||
array = os_aio_sync_array;
|
||
segment = 0;
|
||
} else {
|
||
segment = os_aio_get_array_and_local_segment(&array, segment);
|
||
}
|
||
|
||
/* NOTE! We only access constant fields in os_aio_array. Therefore
|
||
we do not have to acquire the protecting mutex yet */
|
||
|
||
ut_ad(os_aio_validate());
|
||
ut_ad(segment < array->n_segments);
|
||
|
||
n = array->n_slots / array->n_segments;
|
||
|
||
if (array == os_aio_sync_array) {
|
||
os_event_wait(os_aio_array_get_nth_slot(array, pos)->event);
|
||
i = pos;
|
||
} else {
|
||
srv_set_io_thread_op_info(orig_seg, "wait Windows aio");
|
||
i = os_event_wait_multiple(n,
|
||
(array->native_events) + segment * n);
|
||
}
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
slot = os_aio_array_get_nth_slot(array, i + segment * n);
|
||
|
||
ut_a(slot->reserved);
|
||
|
||
if (orig_seg != ULINT_UNDEFINED) {
|
||
srv_set_io_thread_op_info(orig_seg,
|
||
"get windows aio return value");
|
||
}
|
||
|
||
ret = GetOverlappedResult(slot->file, &(slot->control), &len, TRUE);
|
||
|
||
*message1 = slot->message1;
|
||
*message2 = slot->message2;
|
||
|
||
*type = slot->type;
|
||
|
||
if (ret && len == slot->len) {
|
||
ret_val = TRUE;
|
||
|
||
if (slot->type == OS_FILE_WRITE
|
||
&& !os_do_not_call_flush_at_each_write) {
|
||
ut_a(TRUE == os_file_flush(slot->file));
|
||
}
|
||
} else {
|
||
os_file_handle_error(slot->name, "Windows aio");
|
||
|
||
ret_val = FALSE;
|
||
}
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
os_aio_array_free_slot(array, slot);
|
||
|
||
return(ret_val);
|
||
}
|
||
#endif
|
||
|
||
#ifdef POSIX_ASYNC_IO
|
||
|
||
/**************************************************************************
|
||
This function is only used in Posix asynchronous i/o. Waits for an aio
|
||
operation to complete. */
|
||
|
||
ibool
|
||
os_aio_posix_handle(
|
||
/*================*/
|
||
/* out: TRUE if the aio operation succeeded */
|
||
ulint array_no, /* in: array number 0 - 3 */
|
||
void** message1, /* out: the messages passed with the aio
|
||
request; note that also in the case where
|
||
the aio operation failed, these output
|
||
parameters are valid and can be used to
|
||
restart the operation, for example */
|
||
void** message2)
|
||
{
|
||
os_aio_array_t* array;
|
||
os_aio_slot_t* slot;
|
||
siginfo_t info;
|
||
sigset_t sigset;
|
||
sigset_t proc_sigset;
|
||
sigset_t thr_sigset;
|
||
int ret;
|
||
int i;
|
||
int sig;
|
||
|
||
sigemptyset(&sigset);
|
||
sigaddset(&sigset, SIGRTMIN + 1 + array_no);
|
||
|
||
pthread_sigmask(SIG_UNBLOCK, &sigset, NULL);
|
||
|
||
/*
|
||
sigprocmask(0, NULL, &proc_sigset);
|
||
pthread_sigmask(0, NULL, &thr_sigset);
|
||
|
||
for (i = 32 ; i < 40; i++) {
|
||
fprintf(stderr, "%lu : %lu %lu\n", (ulint)i,
|
||
(ulint)sigismember(&proc_sigset, i),
|
||
(ulint)sigismember(&thr_sigset, i));
|
||
}
|
||
*/
|
||
|
||
ret = sigwaitinfo(&sigset, &info);
|
||
|
||
if (sig != SIGRTMIN + 1 + array_no) {
|
||
|
||
ut_error;
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
fputs("Handling POSIX aio\n", stderr);
|
||
|
||
array = os_aio_get_array_from_no(array_no);
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
slot = info.si_value.sival_ptr;
|
||
|
||
ut_a(slot->reserved);
|
||
|
||
*message1 = slot->message1;
|
||
*message2 = slot->message2;
|
||
|
||
if (slot->type == OS_FILE_WRITE
|
||
&& !os_do_not_call_flush_at_each_write) {
|
||
ut_a(TRUE == os_file_flush(slot->file));
|
||
}
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
os_aio_array_free_slot(array, slot);
|
||
|
||
return(TRUE);
|
||
}
|
||
#endif
|
||
|
||
/**************************************************************************
|
||
Does simulated aio. This function should be called by an i/o-handler
|
||
thread. */
|
||
|
||
ibool
|
||
os_aio_simulated_handle(
|
||
/*====================*/
|
||
/* out: TRUE if the aio operation succeeded */
|
||
ulint global_segment, /* in: the number of the segment in the aio
|
||
arrays to wait for; segment 0 is the ibuf
|
||
i/o thread, segment 1 the log i/o thread,
|
||
then follow the non-ibuf read threads, and as
|
||
the last are the non-ibuf write threads */
|
||
void** message1, /* out: the messages passed with the aio
|
||
request; note that also in the case where
|
||
the aio operation failed, these output
|
||
parameters are valid and can be used to
|
||
restart the operation, for example */
|
||
void** message2,
|
||
ulint* type) /* out: OS_FILE_WRITE or ..._READ */
|
||
{
|
||
os_aio_array_t* array;
|
||
ulint segment;
|
||
os_aio_slot_t* slot;
|
||
os_aio_slot_t* slot2;
|
||
os_aio_slot_t* consecutive_ios[OS_AIO_MERGE_N_CONSECUTIVE];
|
||
ulint n_consecutive;
|
||
ulint total_len;
|
||
ulint offs;
|
||
ulint lowest_offset;
|
||
ulint biggest_age;
|
||
ulint age;
|
||
byte* combined_buf;
|
||
byte* combined_buf2;
|
||
ibool ret;
|
||
ulint n;
|
||
ulint i;
|
||
ulint len2;
|
||
|
||
segment = os_aio_get_array_and_local_segment(&array, global_segment);
|
||
|
||
restart:
|
||
/* NOTE! We only access constant fields in os_aio_array. Therefore
|
||
we do not have to acquire the protecting mutex yet */
|
||
|
||
srv_set_io_thread_op_info(global_segment,
|
||
"looking for i/o requests (a)");
|
||
ut_ad(os_aio_validate());
|
||
ut_ad(segment < array->n_segments);
|
||
|
||
n = array->n_slots / array->n_segments;
|
||
|
||
/* Look through n slots after the segment * n'th slot */
|
||
|
||
if (array == os_aio_read_array
|
||
&& os_aio_recommend_sleep_for_read_threads) {
|
||
|
||
/* Give other threads chance to add several i/os to the array
|
||
at once. */
|
||
|
||
goto recommended_sleep;
|
||
}
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
srv_set_io_thread_op_info(global_segment,
|
||
"looking for i/o requests (b)");
|
||
|
||
/* Check if there is a slot for which the i/o has already been
|
||
done */
|
||
|
||
for (i = 0; i < n; i++) {
|
||
slot = os_aio_array_get_nth_slot(array, i + segment * n);
|
||
|
||
if (slot->reserved && slot->io_already_done) {
|
||
|
||
if (os_aio_print_debug) {
|
||
fprintf(stderr,
|
||
"InnoDB: i/o for slot %lu already done, returning\n", (ulong) i);
|
||
}
|
||
|
||
ret = TRUE;
|
||
|
||
goto slot_io_done;
|
||
}
|
||
}
|
||
|
||
n_consecutive = 0;
|
||
|
||
/* If there are at least 2 seconds old requests, then pick the oldest
|
||
one to prevent starvation. If several requests have the same age,
|
||
then pick the one at the lowest offset. */
|
||
|
||
biggest_age = 0;
|
||
lowest_offset = ULINT_MAX;
|
||
|
||
for (i = 0; i < n; i++) {
|
||
slot = os_aio_array_get_nth_slot(array, i + segment * n);
|
||
|
||
if (slot->reserved) {
|
||
age = (ulint)difftime(time(NULL),
|
||
slot->reservation_time);
|
||
|
||
if ((age >= 2 && age > biggest_age)
|
||
|| (age >= 2 && age == biggest_age
|
||
&& slot->offset < lowest_offset)) {
|
||
|
||
/* Found an i/o request */
|
||
consecutive_ios[0] = slot;
|
||
|
||
n_consecutive = 1;
|
||
|
||
biggest_age = age;
|
||
lowest_offset = slot->offset;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (n_consecutive == 0) {
|
||
/* There were no old requests. Look for an i/o request at the
|
||
lowest offset in the array (we ignore the high 32 bits of the
|
||
offset in these heuristics) */
|
||
|
||
lowest_offset = ULINT_MAX;
|
||
|
||
for (i = 0; i < n; i++) {
|
||
slot = os_aio_array_get_nth_slot(array,
|
||
i + segment * n);
|
||
|
||
if (slot->reserved && slot->offset < lowest_offset) {
|
||
|
||
/* Found an i/o request */
|
||
consecutive_ios[0] = slot;
|
||
|
||
n_consecutive = 1;
|
||
|
||
lowest_offset = slot->offset;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (n_consecutive == 0) {
|
||
|
||
/* No i/o requested at the moment */
|
||
|
||
goto wait_for_io;
|
||
}
|
||
|
||
slot = consecutive_ios[0];
|
||
|
||
/* Check if there are several consecutive blocks to read or write */
|
||
|
||
consecutive_loop:
|
||
for (i = 0; i < n; i++) {
|
||
slot2 = os_aio_array_get_nth_slot(array, i + segment * n);
|
||
|
||
if (slot2->reserved && slot2 != slot
|
||
&& slot2->offset == slot->offset + slot->len
|
||
&& slot->offset + slot->len > slot->offset /* check that
|
||
sum does not wrap over */
|
||
&& slot2->offset_high == slot->offset_high
|
||
&& slot2->type == slot->type
|
||
&& slot2->file == slot->file) {
|
||
|
||
/* Found a consecutive i/o request */
|
||
|
||
consecutive_ios[n_consecutive] = slot2;
|
||
n_consecutive++;
|
||
|
||
slot = slot2;
|
||
|
||
if (n_consecutive < OS_AIO_MERGE_N_CONSECUTIVE) {
|
||
|
||
goto consecutive_loop;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
srv_set_io_thread_op_info(global_segment, "consecutive i/o requests");
|
||
|
||
/* We have now collected n_consecutive i/o requests in the array;
|
||
allocate a single buffer which can hold all data, and perform the
|
||
i/o */
|
||
|
||
total_len = 0;
|
||
slot = consecutive_ios[0];
|
||
|
||
for (i = 0; i < n_consecutive; i++) {
|
||
total_len += consecutive_ios[i]->len;
|
||
}
|
||
|
||
if (n_consecutive == 1) {
|
||
/* We can use the buffer of the i/o request */
|
||
combined_buf = slot->buf;
|
||
combined_buf2 = NULL;
|
||
} else {
|
||
combined_buf2 = ut_malloc(total_len + UNIV_PAGE_SIZE);
|
||
|
||
ut_a(combined_buf2);
|
||
|
||
combined_buf = ut_align(combined_buf2, UNIV_PAGE_SIZE);
|
||
}
|
||
|
||
/* We release the array mutex for the time of the i/o: NOTE that
|
||
this assumes that there is just one i/o-handler thread serving
|
||
a single segment of slots! */
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
if (slot->type == OS_FILE_WRITE && n_consecutive > 1) {
|
||
/* Copy the buffers to the combined buffer */
|
||
offs = 0;
|
||
|
||
for (i = 0; i < n_consecutive; i++) {
|
||
|
||
ut_memcpy(combined_buf + offs, consecutive_ios[i]->buf,
|
||
consecutive_ios[i]->len);
|
||
offs += consecutive_ios[i]->len;
|
||
}
|
||
}
|
||
|
||
srv_set_io_thread_op_info(global_segment, "doing file i/o");
|
||
|
||
if (os_aio_print_debug) {
|
||
fprintf(stderr,
|
||
"InnoDB: doing i/o of type %lu at offset %lu %lu, length %lu\n",
|
||
(ulong) slot->type, (ulong) slot->offset_high,
|
||
(ulong) slot->offset, (ulong) total_len);
|
||
}
|
||
|
||
/* Do the i/o with ordinary, synchronous i/o functions: */
|
||
if (slot->type == OS_FILE_WRITE) {
|
||
if (array == os_aio_write_array) {
|
||
if ((total_len % UNIV_PAGE_SIZE != 0)
|
||
|| (slot->offset % UNIV_PAGE_SIZE != 0)) {
|
||
fprintf(stderr,
|
||
"InnoDB: Error: trying a displaced write to %s %lu %lu, len %lu\n",
|
||
slot->name, (ulong) slot->offset_high,
|
||
(ulong) slot->offset,
|
||
(ulong) total_len);
|
||
ut_error;
|
||
}
|
||
|
||
/* Do a 'last millisecond' check that the page end
|
||
is sensible; reported page checksum errors from
|
||
Linux seem to wipe over the page end */
|
||
|
||
for (len2 = 0; len2 + UNIV_PAGE_SIZE <= total_len;
|
||
len2 += UNIV_PAGE_SIZE) {
|
||
if (mach_read_from_4(combined_buf + len2
|
||
+ FIL_PAGE_LSN + 4)
|
||
!= mach_read_from_4(combined_buf + len2
|
||
+ UNIV_PAGE_SIZE
|
||
- FIL_PAGE_END_LSN_OLD_CHKSUM + 4)) {
|
||
ut_print_timestamp(stderr);
|
||
fprintf(stderr,
|
||
" InnoDB: ERROR: The page to be written seems corrupt!\n");
|
||
fprintf(stderr,
|
||
"InnoDB: Writing a block of %lu bytes, currently writing at offset %lu\n",
|
||
(ulong)total_len, (ulong)len2);
|
||
buf_page_print(combined_buf + len2);
|
||
fprintf(stderr,
|
||
"InnoDB: ERROR: The page to be written seems corrupt!\n");
|
||
}
|
||
}
|
||
}
|
||
|
||
ret = os_file_write(slot->name, slot->file, combined_buf,
|
||
slot->offset, slot->offset_high, total_len);
|
||
} else {
|
||
ret = os_file_read(slot->file, combined_buf,
|
||
slot->offset, slot->offset_high, total_len);
|
||
}
|
||
|
||
ut_a(ret);
|
||
srv_set_io_thread_op_info(global_segment, "file i/o done");
|
||
|
||
/* fprintf(stderr,
|
||
"aio: %lu consecutive %lu:th segment, first offs %lu blocks\n",
|
||
n_consecutive, global_segment, slot->offset / UNIV_PAGE_SIZE); */
|
||
|
||
if (slot->type == OS_FILE_READ && n_consecutive > 1) {
|
||
/* Copy the combined buffer to individual buffers */
|
||
offs = 0;
|
||
|
||
for (i = 0; i < n_consecutive; i++) {
|
||
|
||
ut_memcpy(consecutive_ios[i]->buf, combined_buf + offs,
|
||
consecutive_ios[i]->len);
|
||
offs += consecutive_ios[i]->len;
|
||
}
|
||
}
|
||
|
||
if (combined_buf2) {
|
||
ut_free(combined_buf2);
|
||
}
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
/* Mark the i/os done in slots */
|
||
|
||
for (i = 0; i < n_consecutive; i++) {
|
||
consecutive_ios[i]->io_already_done = TRUE;
|
||
}
|
||
|
||
/* We return the messages for the first slot now, and if there were
|
||
several slots, the messages will be returned with subsequent calls
|
||
of this function */
|
||
|
||
slot_io_done:
|
||
|
||
ut_a(slot->reserved);
|
||
|
||
*message1 = slot->message1;
|
||
*message2 = slot->message2;
|
||
|
||
*type = slot->type;
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
os_aio_array_free_slot(array, slot);
|
||
|
||
return(ret);
|
||
|
||
wait_for_io:
|
||
srv_set_io_thread_op_info(global_segment, "resetting wait event");
|
||
|
||
/* We wait here until there again can be i/os in the segment
|
||
of this thread */
|
||
|
||
os_event_reset(os_aio_segment_wait_events[global_segment]);
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
recommended_sleep:
|
||
srv_set_io_thread_op_info(global_segment, "waiting for i/o request");
|
||
|
||
os_event_wait(os_aio_segment_wait_events[global_segment]);
|
||
|
||
if (os_aio_print_debug) {
|
||
fprintf(stderr,
|
||
"InnoDB: i/o handler thread for i/o segment %lu wakes up\n",
|
||
(ulong) global_segment);
|
||
}
|
||
|
||
goto restart;
|
||
}
|
||
|
||
/**************************************************************************
|
||
Validates the consistency of an aio array. */
|
||
static
|
||
ibool
|
||
os_aio_array_validate(
|
||
/*==================*/
|
||
/* out: TRUE if ok */
|
||
os_aio_array_t* array) /* in: aio wait array */
|
||
{
|
||
os_aio_slot_t* slot;
|
||
ulint n_reserved = 0;
|
||
ulint i;
|
||
|
||
ut_a(array);
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
ut_a(array->n_slots > 0);
|
||
ut_a(array->n_segments > 0);
|
||
|
||
for (i = 0; i < array->n_slots; i++) {
|
||
slot = os_aio_array_get_nth_slot(array, i);
|
||
|
||
if (slot->reserved) {
|
||
n_reserved++;
|
||
ut_a(slot->len > 0);
|
||
}
|
||
}
|
||
|
||
ut_a(array->n_reserved == n_reserved);
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
/**************************************************************************
|
||
Validates the consistency the aio system. */
|
||
|
||
ibool
|
||
os_aio_validate(void)
|
||
/*=================*/
|
||
/* out: TRUE if ok */
|
||
{
|
||
os_aio_array_validate(os_aio_read_array);
|
||
os_aio_array_validate(os_aio_write_array);
|
||
os_aio_array_validate(os_aio_ibuf_array);
|
||
os_aio_array_validate(os_aio_log_array);
|
||
os_aio_array_validate(os_aio_sync_array);
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
/**************************************************************************
|
||
Prints info of the aio arrays. */
|
||
|
||
void
|
||
os_aio_print(
|
||
/*=========*/
|
||
FILE* file) /* in: file where to print */
|
||
{
|
||
os_aio_array_t* array;
|
||
os_aio_slot_t* slot;
|
||
ulint n_reserved;
|
||
time_t current_time;
|
||
double time_elapsed;
|
||
double avg_bytes_read;
|
||
ulint i;
|
||
|
||
for (i = 0; i < srv_n_file_io_threads; i++) {
|
||
fprintf(file, "I/O thread %lu state: %s (%s)", (ulong) i,
|
||
srv_io_thread_op_info[i],
|
||
srv_io_thread_function[i]);
|
||
|
||
#ifndef __WIN__
|
||
if (os_aio_segment_wait_events[i]->is_set) {
|
||
fprintf(file, " ev set");
|
||
}
|
||
#endif
|
||
|
||
fprintf(file, "\n");
|
||
}
|
||
|
||
fputs("Pending normal aio reads:", file);
|
||
|
||
array = os_aio_read_array;
|
||
loop:
|
||
ut_a(array);
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
ut_a(array->n_slots > 0);
|
||
ut_a(array->n_segments > 0);
|
||
|
||
n_reserved = 0;
|
||
|
||
for (i = 0; i < array->n_slots; i++) {
|
||
slot = os_aio_array_get_nth_slot(array, i);
|
||
|
||
if (slot->reserved) {
|
||
n_reserved++;
|
||
/* fprintf(stderr, "Reserved slot, messages %p %p\n",
|
||
slot->message1, slot->message2); */
|
||
ut_a(slot->len > 0);
|
||
}
|
||
}
|
||
|
||
ut_a(array->n_reserved == n_reserved);
|
||
|
||
fprintf(file, " %lu", (ulong) n_reserved);
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
if (array == os_aio_read_array) {
|
||
fputs(", aio writes:", file);
|
||
|
||
array = os_aio_write_array;
|
||
|
||
goto loop;
|
||
}
|
||
|
||
if (array == os_aio_write_array) {
|
||
fputs(",\n ibuf aio reads:", file);
|
||
array = os_aio_ibuf_array;
|
||
|
||
goto loop;
|
||
}
|
||
|
||
if (array == os_aio_ibuf_array) {
|
||
fputs(", log i/o's:", file);
|
||
array = os_aio_log_array;
|
||
|
||
goto loop;
|
||
}
|
||
|
||
if (array == os_aio_log_array) {
|
||
fputs(", sync i/o's:", file);
|
||
array = os_aio_sync_array;
|
||
|
||
goto loop;
|
||
}
|
||
|
||
putc('\n', file);
|
||
current_time = time(NULL);
|
||
time_elapsed = 0.001 + difftime(current_time, os_last_printout);
|
||
|
||
fprintf(file,
|
||
"Pending flushes (fsync) log: %lu; buffer pool: %lu\n"
|
||
"%lu OS file reads, %lu OS file writes, %lu OS fsyncs\n",
|
||
(ulong) fil_n_pending_log_flushes,
|
||
(ulong) fil_n_pending_tablespace_flushes,
|
||
(ulong) os_n_file_reads, (ulong) os_n_file_writes,
|
||
(ulong) os_n_fsyncs);
|
||
|
||
if (os_file_n_pending_preads != 0 || os_file_n_pending_pwrites != 0) {
|
||
fprintf(file,
|
||
"%lu pending preads, %lu pending pwrites\n",
|
||
(ulong) os_file_n_pending_preads,
|
||
(ulong) os_file_n_pending_pwrites);
|
||
}
|
||
|
||
if (os_n_file_reads == os_n_file_reads_old) {
|
||
avg_bytes_read = 0.0;
|
||
} else {
|
||
avg_bytes_read = (double) os_bytes_read_since_printout /
|
||
(os_n_file_reads - os_n_file_reads_old);
|
||
}
|
||
|
||
fprintf(file,
|
||
"%.2f reads/s, %lu avg bytes/read, %.2f writes/s, %.2f fsyncs/s\n",
|
||
(os_n_file_reads - os_n_file_reads_old)
|
||
/ time_elapsed,
|
||
(ulong)avg_bytes_read,
|
||
(os_n_file_writes - os_n_file_writes_old)
|
||
/ time_elapsed,
|
||
(os_n_fsyncs - os_n_fsyncs_old)
|
||
/ time_elapsed);
|
||
|
||
os_n_file_reads_old = os_n_file_reads;
|
||
os_n_file_writes_old = os_n_file_writes;
|
||
os_n_fsyncs_old = os_n_fsyncs;
|
||
os_bytes_read_since_printout = 0;
|
||
|
||
os_last_printout = current_time;
|
||
}
|
||
|
||
/**************************************************************************
|
||
Refreshes the statistics used to print per-second averages. */
|
||
|
||
void
|
||
os_aio_refresh_stats(void)
|
||
/*======================*/
|
||
{
|
||
os_n_file_reads_old = os_n_file_reads;
|
||
os_n_file_writes_old = os_n_file_writes;
|
||
os_n_fsyncs_old = os_n_fsyncs;
|
||
os_bytes_read_since_printout = 0;
|
||
|
||
os_last_printout = time(NULL);
|
||
}
|
||
|
||
/**************************************************************************
|
||
Checks that all slots in the system have been freed, that is, there are
|
||
no pending io operations. */
|
||
|
||
ibool
|
||
os_aio_all_slots_free(void)
|
||
/*=======================*/
|
||
/* out: TRUE if all free */
|
||
{
|
||
os_aio_array_t* array;
|
||
ulint n_res = 0;
|
||
|
||
array = os_aio_read_array;
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
n_res += array->n_reserved;
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
array = os_aio_write_array;
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
n_res += array->n_reserved;
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
array = os_aio_ibuf_array;
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
n_res += array->n_reserved;
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
array = os_aio_log_array;
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
n_res += array->n_reserved;
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
array = os_aio_sync_array;
|
||
|
||
os_mutex_enter(array->mutex);
|
||
|
||
n_res += array->n_reserved;
|
||
|
||
os_mutex_exit(array->mutex);
|
||
|
||
if (n_res == 0) {
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
return(FALSE);
|
||
}
|