1
/***********************************************************************
3
Copyright (c) 1995, 2010, Innobase Oy. All Rights Reserved.
4
Copyright (c) 2009, Percona Inc.
6
Portions of this file contain modifications contributed and copyrighted
7
by Percona Inc.. Those modifications are
8
gratefully acknowledged and are described briefly in the InnoDB
9
documentation. The contributions by Percona Inc. are incorporated with
10
their permission, and subject to the conditions contained in the file
13
This program is free software; you can redistribute it and/or modify it
14
under the terms of the GNU General Public License as published by the
15
Free Software Foundation; version 2 of the License.
17
This program is distributed in the hope that it will be useful, but
18
WITHOUT ANY WARRANTY; without even the implied warranty of
19
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
20
Public License for more details.
22
You should have received a copy of the GNU General Public License along
23
with this program; if not, write to the Free Software Foundation, Inc.,
24
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26
***********************************************************************/
28
/**************************************************//**
30
The interface to the operating system file i/o primitives
32
Created 10/21/1995 Heikki Tuuri
33
*******************************************************/
43
#include "srv0start.h"
46
#ifndef UNIV_HOTBACKUP
48
# include "os0thread.h"
49
#else /* !UNIV_HOTBACKUP */
51
/* Add includes for the _stat() call to compile on Windows */
52
# include <sys/types.h>
53
# include <sys/stat.h>
56
#endif /* !UNIV_HOTBACKUP */
58
#if defined(LINUX_NATIVE_AIO)
62
/* This specifies the file permissions InnoDB uses when it creates files in
63
Unix; the value of os_innodb_umask is initialized in ha_innodb.cc to
67
/** Umask for creating files */
68
UNIV_INTERN ulint os_innodb_umask
69
= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
71
/** Umask for creating files */
72
UNIV_INTERN ulint os_innodb_umask = 0;
76
/* If the following is set to TRUE, we do not call os_file_flush in every
77
os_file_write. We can set this TRUE when the doublewrite buffer is used. */
78
UNIV_INTERN ibool os_do_not_call_flush_at_each_write = FALSE;
80
/* We do not call os_file_flush in every os_file_write. */
81
#endif /* UNIV_DO_FLUSH */
83
#ifndef UNIV_HOTBACKUP
84
/* We use these mutexes to protect lseek + file i/o operation, if the
85
OS does not provide an atomic pread or pwrite, or similar */
86
#define OS_FILE_N_SEEK_MUTEXES 16
87
UNIV_INTERN os_mutex_t os_file_seek_mutexes[OS_FILE_N_SEEK_MUTEXES];
89
/* In simulated aio, merge at most this many consecutive i/os */
90
#define OS_AIO_MERGE_N_CONSECUTIVE 64
92
/**********************************************************************
94
InnoDB AIO Implementation:
95
=========================
97
We support native AIO for windows and linux. For rest of the platforms
98
we simulate AIO by special io-threads servicing the IO-requests.
103
In platforms where we 'simulate' AIO following is a rough explanation
104
of the high level design.
105
There are four io-threads (for ibuf, log, read, write).
106
All synchronous IO requests are serviced by the calling thread using
107
os_file_write/os_file_read. The Asynchronous requests are queued up
108
in an array (there are four such arrays) by the calling thread.
109
Later these requests are picked up by the io-thread and are serviced
115
If srv_use_native_aio is not set then windows follow the same
116
code as simulated AIO. If the flag is set then native AIO interface
117
is used. On windows, one of the limitation is that if a file is opened
118
for AIO no synchronous IO can be done on it. Therefore we have an
119
extra fifth array to queue up synchronous IO requests.
120
There are innodb_file_io_threads helper threads. These threads work
121
on the four arrays mentioned above in Simulated AIO. No thread is
122
required for the sync array.
123
If a synchronous IO request is made, it is first queued in the sync
124
array. Then the calling thread itself waits on the request, thus
125
making the call synchronous.
126
If an AIO request is made the calling thread not only queues it in the
127
array but also submits the requests. The helper thread then collects
128
the completed IO request and calls completion routine on it.
133
If we have libaio installed on the system and innodb_use_native_aio
134
is set to TRUE we follow the code path of native AIO, otherwise we
136
There are innodb_file_io_threads helper threads. These threads work
137
on the four arrays mentioned above in Simulated AIO.
138
If a synchronous IO request is made, it is handled by calling
139
os_file_write/os_file_read.
140
If an AIO request is made the calling thread not only queues it in the
141
array but also submits the requests. The helper thread then collects
142
the completed IO request and calls completion routine on it.
144
**********************************************************************/
146
/** Flag: enable debug printout for asynchronous i/o */
147
UNIV_INTERN ibool os_aio_print_debug = FALSE;
150
/* Keys to register InnoDB I/O with performance schema */
151
UNIV_INTERN mysql_pfs_key_t innodb_file_data_key;
152
UNIV_INTERN mysql_pfs_key_t innodb_file_log_key;
153
UNIV_INTERN mysql_pfs_key_t innodb_file_temp_key;
154
#endif /* UNIV_PFS_IO */
156
/** The asynchronous i/o array slot structure */
157
typedef struct os_aio_slot_struct os_aio_slot_t;
159
/** The asynchronous i/o array slot structure */
160
struct os_aio_slot_struct{
161
ibool is_read; /*!< TRUE if a read operation */
162
ulint pos; /*!< index of the slot in the aio
164
ibool reserved; /*!< TRUE if this slot is reserved */
165
time_t reservation_time;/*!< time when reserved */
166
ulint len; /*!< length of the block to read or
168
byte* buf; /*!< buffer used in i/o */
169
ulint type; /*!< OS_FILE_READ or OS_FILE_WRITE */
170
ulint offset; /*!< 32 low bits of file offset in
172
ulint offset_high; /*!< 32 high bits of file offset */
173
os_file_t file; /*!< file where to read or write */
174
const char* name; /*!< file name or path */
175
ibool io_already_done;/*!< used only in simulated aio:
176
TRUE if the physical i/o already
177
made and only the slot message
178
needs to be passed to the caller
179
of os_aio_simulated_handle */
180
fil_node_t* message1; /*!< message which is given by the */
181
void* message2; /*!< the requester of an aio operation
182
and which can be used to identify
183
which pending aio operation was
186
HANDLE handle; /*!< handle object we need in the
188
OVERLAPPED control; /*!< Windows control block for the
190
#elif defined(LINUX_NATIVE_AIO)
191
struct iocb control; /* Linux control block for aio */
192
int n_bytes; /* bytes written/read. */
193
int ret; /* AIO return code */
197
/** The asynchronous i/o array structure */
198
typedef struct os_aio_array_struct os_aio_array_t;
200
/** The asynchronous i/o array structure */
201
struct os_aio_array_struct{
202
os_mutex_t mutex; /*!< the mutex protecting the aio array */
204
/*!< The event which is set to the
205
signaled state when there is space in
206
the aio outside the ibuf segment */
208
/*!< The event which is set to the
209
signaled state when there are no
210
pending i/os in this array */
211
ulint n_slots;/*!< Total number of slots in the aio
212
array. This must be divisible by
215
/*!< Number of segments in the aio
216
array of pending aio requests. A
217
thread can wait separately for any one
219
ulint cur_seg;/*!< We reserve IO requests in round
220
robin fashion to different segments.
221
This points to the segment that is to
222
be used to service next IO request. */
224
/*!< Number of reserved slots in the
225
aio array outside the ibuf segment */
226
os_aio_slot_t* slots; /*!< Pointer to the slots in the array */
229
/*!< Pointer to an array of OS native
230
event handles where we copied the
231
handles from slots, in the same
232
order. This can be used in
233
WaitForMultipleObjects; used only in
237
#if defined(LINUX_NATIVE_AIO)
238
io_context_t* aio_ctx;
239
/* completion queue for IO. There is
240
one such queue per segment. Each thread
241
will work on one ctx exclusively. */
242
struct io_event* aio_events;
243
/* The array to collect completed IOs.
244
There is one such event for each
245
possible pending IO. The size of the
246
array is equal to n_slots. */
250
#if defined(LINUX_NATIVE_AIO)
251
/** timeout for each io_getevents() call = 500ms. */
252
#define OS_AIO_REAP_TIMEOUT (500000000UL)
254
/** time to sleep, in microseconds if io_setup() returns EAGAIN. */
255
#define OS_AIO_IO_SETUP_RETRY_SLEEP (500000UL)
257
/** number of attempts before giving up on io_setup(). */
258
#define OS_AIO_IO_SETUP_RETRY_ATTEMPTS 5
261
/** Array of events used in simulated aio */
262
static os_event_t* os_aio_segment_wait_events = NULL;
264
/** The aio arrays for non-ibuf i/o and ibuf i/o, as well as sync aio. These
265
are NULL when the module has not yet been initialized. @{ */
266
static os_aio_array_t* os_aio_read_array = NULL; /*!< Reads */
267
static os_aio_array_t* os_aio_write_array = NULL; /*!< Writes */
268
static os_aio_array_t* os_aio_ibuf_array = NULL; /*!< Insert buffer */
269
static os_aio_array_t* os_aio_log_array = NULL; /*!< Redo log */
270
static os_aio_array_t* os_aio_sync_array = NULL; /*!< Synchronous I/O */
273
/** Number of asynchronous I/O segments. Set by os_aio_init(). */
274
static ulint os_aio_n_segments = ULINT_UNDEFINED;
276
/** If the following is TRUE, read i/o handler threads try to
277
wait until a batch of new read requests have been posted */
278
static ibool os_aio_recommend_sleep_for_read_threads = FALSE;
279
#endif /* !UNIV_HOTBACKUP */
281
UNIV_INTERN ulint os_n_file_reads = 0;
282
UNIV_INTERN ulint os_bytes_read_since_printout = 0;
283
UNIV_INTERN ulint os_n_file_writes = 0;
284
UNIV_INTERN ulint os_n_fsyncs = 0;
285
UNIV_INTERN ulint os_n_file_reads_old = 0;
286
UNIV_INTERN ulint os_n_file_writes_old = 0;
287
UNIV_INTERN ulint os_n_fsyncs_old = 0;
288
UNIV_INTERN time_t os_last_printout;
290
UNIV_INTERN ibool os_has_said_disk_full = FALSE;
292
#ifndef UNIV_HOTBACKUP
293
/** The mutex protecting the following counts of pending I/O operations */
294
static os_mutex_t os_file_count_mutex;
295
#endif /* !UNIV_HOTBACKUP */
296
/** Number of pending os_file_pread() operations */
297
UNIV_INTERN ulint os_file_n_pending_preads = 0;
298
/** Number of pending os_file_pwrite() operations */
299
UNIV_INTERN ulint os_file_n_pending_pwrites = 0;
300
/** Number of pending write operations */
301
UNIV_INTERN ulint os_n_pending_writes = 0;
302
/** Number of pending read operations */
303
UNIV_INTERN ulint os_n_pending_reads = 0;
306
/**********************************************************************//**
307
Validates the consistency the aio system some of the time.
308
@return TRUE if ok or the check was skipped */
311
os_aio_validate_skip(void)
312
/*======================*/
314
/** Try os_aio_validate() every this many times */
315
# define OS_AIO_VALIDATE_SKIP 13
317
/** The os_aio_validate() call skip counter.
318
Use a signed type because of the race condition below. */
319
static int os_aio_validate_count = OS_AIO_VALIDATE_SKIP;
321
/* There is a race condition below, but it does not matter,
322
because this call is only for heuristic purposes. We want to
323
reduce the call frequency of the costly os_aio_validate()
324
check in debug builds. */
325
if (--os_aio_validate_count > 0) {
329
os_aio_validate_count = OS_AIO_VALIDATE_SKIP;
330
return(os_aio_validate());
332
#endif /* UNIV_DEBUG */
335
/***********************************************************************//**
336
Gets the operating system version. Currently works only on Windows.
337
@return OS_WIN95, OS_WIN31, OS_WINNT, OS_WIN2000, OS_WINXP, OS_WINVISTA,
341
os_get_os_version(void)
342
/*===================*/
344
OSVERSIONINFO os_info;
346
os_info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
348
ut_a(GetVersionEx(&os_info));
350
if (os_info.dwPlatformId == VER_PLATFORM_WIN32s) {
352
} else if (os_info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
354
} else if (os_info.dwPlatformId == VER_PLATFORM_WIN32_NT) {
355
switch (os_info.dwMajorVersion) {
360
return (os_info.dwMinorVersion == 0) ? OS_WIN2000
363
return (os_info.dwMinorVersion == 0) ? OS_WINVISTA
375
/***********************************************************************//**
376
Retrieves the last error number if an error occurs in a file io function.
377
The number should be retrieved before any other OS calls (because they may
378
overwrite the error number). If the number is not known to this program,
379
the OS error number + 100 is returned.
380
@return error number, or OS error number + 100 */
383
os_file_get_last_error(
384
/*===================*/
385
ibool report_all_errors) /*!< in: TRUE if we want an error message
386
printed of all errors */
392
err = (ulint) GetLastError();
394
if (report_all_errors
395
|| (err != ERROR_DISK_FULL && err != ERROR_FILE_EXISTS)) {
397
ut_print_timestamp(stderr);
399
" InnoDB: Operating system error number %lu"
400
" in a file operation.\n", (ulong) err);
402
if (err == ERROR_PATH_NOT_FOUND) {
404
"InnoDB: The error means the system"
405
" cannot find the path specified.\n");
407
if (srv_is_being_started) {
409
"InnoDB: If you are installing InnoDB,"
410
" remember that you must create\n"
411
"InnoDB: directories yourself, InnoDB"
412
" does not create them.\n");
414
} else if (err == ERROR_ACCESS_DENIED) {
416
"InnoDB: The error means mysqld does not have"
417
" the access rights to\n"
418
"InnoDB: the directory. It may also be"
419
" you have created a subdirectory\n"
420
"InnoDB: of the same name as a data file.\n");
421
} else if (err == ERROR_SHARING_VIOLATION
422
|| err == ERROR_LOCK_VIOLATION) {
424
"InnoDB: The error means that another program"
425
" is using InnoDB's files.\n"
426
"InnoDB: This might be a backup or antivirus"
427
" software or another instance\n"
429
" Please close it to get rid of this error.\n");
430
} else if (err == ERROR_WORKING_SET_QUOTA
431
|| err == ERROR_NO_SYSTEM_RESOURCES) {
433
"InnoDB: The error means that there are no"
434
" sufficient system resources or quota to"
435
" complete the operation.\n");
436
} else if (err == ERROR_OPERATION_ABORTED) {
438
"InnoDB: The error means that the I/O"
439
" operation has been aborted\n"
440
"InnoDB: because of either a thread exit"
441
" or an application request.\n"
442
"InnoDB: Retry attempt is made.\n");
445
"InnoDB: Some operating system error numbers"
446
" are described at\n"
449
"operating-system-error-codes.html\n");
455
if (err == ERROR_FILE_NOT_FOUND) {
456
return(OS_FILE_NOT_FOUND);
457
} else if (err == ERROR_DISK_FULL) {
458
return(OS_FILE_DISK_FULL);
459
} else if (err == ERROR_FILE_EXISTS) {
460
return(OS_FILE_ALREADY_EXISTS);
461
} else if (err == ERROR_SHARING_VIOLATION
462
|| err == ERROR_LOCK_VIOLATION) {
463
return(OS_FILE_SHARING_VIOLATION);
464
} else if (err == ERROR_WORKING_SET_QUOTA
465
|| err == ERROR_NO_SYSTEM_RESOURCES) {
466
return(OS_FILE_INSUFFICIENT_RESOURCE);
467
} else if (err == ERROR_OPERATION_ABORTED) {
468
return(OS_FILE_OPERATION_ABORTED);
475
if (report_all_errors
476
|| (err != ENOSPC && err != EEXIST)) {
478
ut_print_timestamp(stderr);
480
" InnoDB: Operating system error number %lu"
481
" in a file operation.\n", (ulong) err);
485
"InnoDB: The error means the system"
486
" cannot find the path specified.\n");
488
if (srv_is_being_started) {
490
"InnoDB: If you are installing InnoDB,"
491
" remember that you must create\n"
492
"InnoDB: directories yourself, InnoDB"
493
" does not create them.\n");
495
} else if (err == EACCES) {
497
"InnoDB: The error means mysqld does not have"
498
" the access rights to\n"
499
"InnoDB: the directory.\n");
501
if (strerror((int)err) != NULL) {
503
"InnoDB: Error number %lu"
505
err, strerror((int)err));
509
"InnoDB: Some operating system"
510
" error numbers are described at\n"
513
"operating-system-error-codes.html\n");
521
return(OS_FILE_DISK_FULL);
523
return(OS_FILE_NOT_FOUND);
525
return(OS_FILE_ALREADY_EXISTS);
529
return(OS_FILE_PATH_ERROR);
531
if (srv_use_native_aio) {
532
return(OS_FILE_AIO_RESOURCES_RESERVED);
536
if (srv_use_native_aio) {
537
return(OS_FILE_AIO_INTERRUPTED);
545
/****************************************************************//**
546
Does error handling when a file operation fails.
547
Conditionally exits (calling exit(3)) based on should_exit value and the
549
@return TRUE if we should retry the operation */
552
os_file_handle_error_cond_exit(
553
/*===========================*/
554
const char* name, /*!< in: name of a file or NULL */
555
const char* operation, /*!< in: operation */
556
ibool should_exit) /*!< in: call exit(3) if unknown error
557
and this parameter is TRUE */
561
err = os_file_get_last_error(FALSE);
563
if (err == OS_FILE_DISK_FULL) {
564
/* We only print a warning about disk full once */
566
if (os_has_said_disk_full) {
572
ut_print_timestamp(stderr);
574
" InnoDB: Encountered a problem with"
578
ut_print_timestamp(stderr);
580
" InnoDB: Disk is full. Try to clean the disk"
581
" to free space.\n");
583
os_has_said_disk_full = TRUE;
588
} else if (err == OS_FILE_AIO_RESOURCES_RESERVED) {
591
} else if (err == OS_FILE_AIO_INTERRUPTED) {
594
} else if (err == OS_FILE_ALREADY_EXISTS
595
|| err == OS_FILE_PATH_ERROR) {
598
} else if (err == OS_FILE_SHARING_VIOLATION) {
600
os_thread_sleep(10000000); /* 10 sec */
602
} else if (err == OS_FILE_INSUFFICIENT_RESOURCE) {
604
os_thread_sleep(100000); /* 100 ms */
606
} else if (err == OS_FILE_OPERATION_ABORTED) {
608
os_thread_sleep(100000); /* 100 ms */
612
fprintf(stderr, "InnoDB: File name %s\n", name);
615
fprintf(stderr, "InnoDB: File operation call: '%s'.\n",
619
fprintf(stderr, "InnoDB: Cannot continue operation.\n");
630
/****************************************************************//**
631
Does error handling when a file operation fails.
632
@return TRUE if we should retry the operation */
635
os_file_handle_error(
636
/*=================*/
637
const char* name, /*!< in: name of a file or NULL */
638
const char* operation)/*!< in: operation */
640
/* exit in case of unknown error */
641
return(os_file_handle_error_cond_exit(name, operation, TRUE));
644
/****************************************************************//**
645
Does error handling when a file operation fails.
646
@return TRUE if we should retry the operation */
649
os_file_handle_error_no_exit(
650
/*=========================*/
651
const char* name, /*!< in: name of a file or NULL */
652
const char* operation)/*!< in: operation */
654
/* don't exit in case of unknown error */
655
return(os_file_handle_error_cond_exit(name, operation, FALSE));
659
#define USE_FILE_LOCK
660
#if defined(UNIV_HOTBACKUP) || defined(__WIN__)
661
/* InnoDB Hot Backup does not lock the data files.
662
* On Windows, mandatory locking is used.
664
# undef USE_FILE_LOCK
667
/****************************************************************//**
668
Obtain an exclusive lock on a file.
669
@return 0 on success */
674
int fd, /*!< in: file descriptor */
675
const char* name) /*!< in: file name */
679
lk.l_whence = SEEK_SET;
680
lk.l_start = lk.l_len = 0;
681
if (fcntl(fd, F_SETLK, &lk) == -1) {
683
"InnoDB: Unable to lock %s, error: %d\n", name, errno);
685
if (errno == EAGAIN || errno == EACCES) {
687
"InnoDB: Check that you do not already have"
688
" another mysqld process\n"
689
"InnoDB: using the same InnoDB data"
698
#endif /* USE_FILE_LOCK */
700
#ifndef UNIV_HOTBACKUP
701
/****************************************************************//**
702
Creates the seek mutexes used in positioned reads and writes. */
705
os_io_init_simple(void)
706
/*===================*/
710
os_file_count_mutex = os_mutex_create();
712
for (i = 0; i < OS_FILE_N_SEEK_MUTEXES; i++) {
713
os_file_seek_mutexes[i] = os_mutex_create();
717
/***********************************************************************//**
718
Creates a temporary file. This function is like tmpfile(3), but
719
the temporary file is created in the MySQL temporary directory.
720
@return temporary file handle, or NULL on error */
723
os_file_create_tmpfile(void)
724
/*========================*/
727
int fd = innobase_mysql_tmpfile();
730
file = fdopen(fd, "w+b");
734
ut_print_timestamp(stderr);
736
" InnoDB: Error: unable to create temporary file;"
737
" errno: %d\n", errno);
745
#endif /* !UNIV_HOTBACKUP */
747
/***********************************************************************//**
748
The os_file_opendir() function opens a directory stream corresponding to the
749
directory named by the dirname argument. The directory stream is positioned
750
at the first entry. In both Unix and Windows we automatically skip the '.'
751
and '..' items at the start of the directory listing.
752
@return directory stream, NULL if error */
757
const char* dirname, /*!< in: directory name; it must not
758
contain a trailing '\' or '/' */
759
ibool error_is_fatal) /*!< in: TRUE if we should treat an
760
error as a fatal error; if we try to
761
open symlinks then we do not wish a
762
fatal error if it happens not to be
767
LPWIN32_FIND_DATA lpFindFileData;
768
char path[OS_FILE_MAX_PATH + 3];
770
ut_a(strlen(dirname) < OS_FILE_MAX_PATH);
772
strcpy(path, dirname);
773
strcpy(path + strlen(path), "\\*");
775
/* Note that in Windows opening the 'directory stream' also retrieves
776
the first entry in the directory. Since it is '.', that is no problem,
777
as we will skip over the '.' and '..' entries anyway. */
779
lpFindFileData = ut_malloc(sizeof(WIN32_FIND_DATA));
781
dir = FindFirstFile((LPCTSTR) path, lpFindFileData);
783
ut_free(lpFindFileData);
785
if (dir == INVALID_HANDLE_VALUE) {
787
if (error_is_fatal) {
788
os_file_handle_error(dirname, "opendir");
796
dir = opendir(dirname);
798
if (dir == NULL && error_is_fatal) {
799
os_file_handle_error(dirname, "opendir");
806
/***********************************************************************//**
807
Closes a directory stream.
808
@return 0 if success, -1 if failure */
813
os_file_dir_t dir) /*!< in: directory stream */
818
ret = FindClose(dir);
821
os_file_handle_error_no_exit(NULL, "closedir");
833
os_file_handle_error_no_exit(NULL, "closedir");
840
/***********************************************************************//**
841
This function returns information of the next file in the directory. We jump
842
over the '.' and '..' entries in the directory.
843
@return 0 if ok, -1 if error, 1 if at the end of the directory */
846
os_file_readdir_next_file(
847
/*======================*/
848
const char* dirname,/*!< in: directory name or path */
849
os_file_dir_t dir, /*!< in: directory stream */
850
os_file_stat_t* info) /*!< in/out: buffer where the info is returned */
853
LPWIN32_FIND_DATA lpFindFileData;
856
lpFindFileData = ut_malloc(sizeof(WIN32_FIND_DATA));
858
ret = FindNextFile(dir, lpFindFileData);
861
ut_a(strlen((char *) lpFindFileData->cFileName)
864
if (strcmp((char *) lpFindFileData->cFileName, ".") == 0
865
|| strcmp((char *) lpFindFileData->cFileName, "..") == 0) {
870
strcpy(info->name, (char *) lpFindFileData->cFileName);
872
info->size = (ib_int64_t)(lpFindFileData->nFileSizeLow)
873
+ (((ib_int64_t)(lpFindFileData->nFileSizeHigh))
876
if (lpFindFileData->dwFileAttributes
877
& FILE_ATTRIBUTE_REPARSE_POINT) {
878
/* TODO: test Windows symlinks */
879
/* TODO: MySQL has apparently its own symlink
880
implementation in Windows, dbname.sym can
881
redirect a database directory:
882
REFMAN "windows-symbolic-links.html" */
883
info->type = OS_FILE_TYPE_LINK;
884
} else if (lpFindFileData->dwFileAttributes
885
& FILE_ATTRIBUTE_DIRECTORY) {
886
info->type = OS_FILE_TYPE_DIR;
888
/* It is probably safest to assume that all other
889
file types are normal. Better to check them rather
890
than blindly skip them. */
892
info->type = OS_FILE_TYPE_FILE;
896
ut_free(lpFindFileData);
900
} else if (GetLastError() == ERROR_NO_MORE_FILES) {
904
os_file_handle_error_no_exit(dirname,
905
"readdir_next_file");
912
struct stat statinfo;
913
#ifdef HAVE_READDIR_R
914
char dirent_buf[sizeof(struct dirent)
915
+ _POSIX_PATH_MAX + 100];
916
/* In /mysys/my_lib.c, _POSIX_PATH_MAX + 1 is used as
917
the max file name len; but in most standards, the
918
length is NAME_MAX; we add 100 to be even safer */
923
#ifdef HAVE_READDIR_R
924
ret = readdir_r(dir, (struct dirent*)dirent_buf, &ent);
928
/* On AIX, only if we got non-NULL 'ent' (result) value and
929
a non-zero 'ret' (return) value, it indicates a failed
930
readdir_r() call. An NULL 'ent' with an non-zero 'ret'
931
would indicate the "end of the directory" is reached. */
936
"InnoDB: cannot read directory %s, error %lu\n",
937
dirname, (ulong)ret);
943
/* End of directory */
948
ut_a(strlen(ent->d_name) < _POSIX_PATH_MAX + 100 - 1);
957
ut_a(strlen(ent->d_name) < OS_FILE_MAX_PATH);
959
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0) {
964
strcpy(info->name, ent->d_name);
966
full_path = ut_malloc(strlen(dirname) + strlen(ent->d_name) + 10);
968
sprintf(full_path, "%s/%s", dirname, ent->d_name);
970
ret = stat(full_path, &statinfo);
974
if (errno == ENOENT) {
975
/* readdir() returned a file that does not exist,
976
it must have been deleted in the meantime. Do what
977
would have happened if the file was deleted before
978
readdir() - ignore and go to the next entry.
979
If this is the last entry then info->name will still
980
contain the name of the deleted file when this
981
function returns, but this is not an issue since the
982
caller shouldn't be looking at info when end of
983
directory is returned. */
990
os_file_handle_error_no_exit(full_path, "stat");
997
info->size = (ib_int64_t)statinfo.st_size;
999
if (S_ISDIR(statinfo.st_mode)) {
1000
info->type = OS_FILE_TYPE_DIR;
1001
} else if (S_ISLNK(statinfo.st_mode)) {
1002
info->type = OS_FILE_TYPE_LINK;
1003
} else if (S_ISREG(statinfo.st_mode)) {
1004
info->type = OS_FILE_TYPE_FILE;
1006
info->type = OS_FILE_TYPE_UNKNOWN;
1015
/*****************************************************************//**
1016
This function attempts to create a directory named pathname. The new directory
1017
gets default permissions. On Unix the permissions are (0770 & ~umask). If the
1018
directory exists already, nothing is done and the call succeeds, unless the
1019
fail_if_exists arguments is true.
1020
@return TRUE if call succeeds, FALSE on error */
1023
os_file_create_directory(
1024
/*=====================*/
1025
const char* pathname, /*!< in: directory name as
1026
null-terminated string */
1027
ibool fail_if_exists) /*!< in: if TRUE, pre-existing directory
1028
is treated as an error. */
1033
rcode = CreateDirectory((LPCTSTR) pathname, NULL);
1035
|| (GetLastError() == ERROR_ALREADY_EXISTS
1036
&& !fail_if_exists))) {
1038
os_file_handle_error(pathname, "CreateDirectory");
1047
rcode = mkdir(pathname, 0770);
1049
if (!(rcode == 0 || (errno == EEXIST && !fail_if_exists))) {
1051
os_file_handle_error(pathname, "mkdir");
1060
/****************************************************************//**
1061
NOTE! Use the corresponding macro os_file_create_simple(), not directly
1063
A simple function to open or create a file.
1064
@return own: handle to the file, not defined if error, error number
1065
can be retrieved with os_file_get_last_error */
1068
os_file_create_simple_func(
1069
/*=======================*/
1070
const char* name, /*!< in: name of the file or path as a
1071
null-terminated string */
1072
ulint create_mode,/*!< in: OS_FILE_OPEN if an existing file is
1073
opened (if does not exist, error), or
1074
OS_FILE_CREATE if a new file is created
1075
(if exists, error), or
1076
OS_FILE_CREATE_PATH if new file
1077
(if exists, error) and subdirectories along
1078
its path are created (if needed)*/
1079
ulint access_type,/*!< in: OS_FILE_READ_ONLY or
1080
OS_FILE_READ_WRITE */
1081
ibool* success)/*!< out: TRUE if succeed, FALSE if error */
1087
DWORD attributes = 0;
1093
if (create_mode == OS_FILE_OPEN) {
1094
create_flag = OPEN_EXISTING;
1095
} else if (create_mode == OS_FILE_CREATE) {
1096
create_flag = CREATE_NEW;
1097
} else if (create_mode == OS_FILE_CREATE_PATH) {
1098
/* create subdirs along the path if needed */
1099
*success = os_file_create_subdirs_if_needed(name);
1103
create_flag = CREATE_NEW;
1104
create_mode = OS_FILE_CREATE;
1110
if (access_type == OS_FILE_READ_ONLY) {
1111
access = GENERIC_READ;
1112
} else if (access_type == OS_FILE_READ_WRITE) {
1113
access = GENERIC_READ | GENERIC_WRITE;
1119
file = CreateFile((LPCTSTR) name,
1121
FILE_SHARE_READ | FILE_SHARE_WRITE,
1122
/* file can be read and written also
1123
by other processes */
1124
NULL, /* default security attributes */
1127
NULL); /*!< no template file */
1129
if (file == INVALID_HANDLE_VALUE) {
1132
retry = os_file_handle_error(name,
1133
create_mode == OS_FILE_OPEN ?
1151
if (create_mode == OS_FILE_OPEN) {
1152
if (access_type == OS_FILE_READ_ONLY) {
1153
create_flag = O_RDONLY;
1155
create_flag = O_RDWR;
1157
} else if (create_mode == OS_FILE_CREATE) {
1158
create_flag = O_RDWR | O_CREAT | O_EXCL;
1159
} else if (create_mode == OS_FILE_CREATE_PATH) {
1160
/* create subdirs along the path if needed */
1161
*success = os_file_create_subdirs_if_needed(name);
1165
create_flag = O_RDWR | O_CREAT | O_EXCL;
1166
create_mode = OS_FILE_CREATE;
1172
if (create_mode == OS_FILE_CREATE) {
1173
file = open(name, create_flag, S_IRUSR | S_IWUSR
1174
| S_IRGRP | S_IWGRP);
1176
file = open(name, create_flag);
1182
retry = os_file_handle_error(name,
1183
create_mode == OS_FILE_OPEN ?
1188
#ifdef USE_FILE_LOCK
1189
} else if (access_type == OS_FILE_READ_WRITE
1190
&& os_file_lock(file, name)) {
1200
#endif /* __WIN__ */
1203
/****************************************************************//**
1204
NOTE! Use the corresponding macro
1205
os_file_create_simple_no_error_handling(), not directly this function!
1206
A simple function to open or create a file.
1207
@return own: handle to the file, not defined if error, error number
1208
can be retrieved with os_file_get_last_error */
1211
os_file_create_simple_no_error_handling_func(
1212
/*=========================================*/
1213
const char* name, /*!< in: name of the file or path as a
1214
null-terminated string */
1215
ulint create_mode,/*!< in: OS_FILE_OPEN if an existing file
1216
is opened (if does not exist, error), or
1217
OS_FILE_CREATE if a new file is created
1218
(if exists, error) */
1219
ulint access_type,/*!< in: OS_FILE_READ_ONLY,
1220
OS_FILE_READ_WRITE, or
1221
OS_FILE_READ_ALLOW_DELETE; the last option is
1222
used by a backup program reading the file */
1223
ibool* success)/*!< out: TRUE if succeed, FALSE if error */
1229
DWORD attributes = 0;
1230
DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
1234
if (create_mode == OS_FILE_OPEN) {
1235
create_flag = OPEN_EXISTING;
1236
} else if (create_mode == OS_FILE_CREATE) {
1237
create_flag = CREATE_NEW;
1243
if (access_type == OS_FILE_READ_ONLY) {
1244
access = GENERIC_READ;
1245
} else if (access_type == OS_FILE_READ_WRITE) {
1246
access = GENERIC_READ | GENERIC_WRITE;
1247
} else if (access_type == OS_FILE_READ_ALLOW_DELETE) {
1248
access = GENERIC_READ;
1249
share_mode = FILE_SHARE_DELETE | FILE_SHARE_READ
1250
| FILE_SHARE_WRITE; /*!< A backup program has to give
1251
mysqld the maximum freedom to
1252
do what it likes with the
1259
file = CreateFile((LPCTSTR) name,
1262
NULL, /* default security attributes */
1265
NULL); /*!< no template file */
1267
if (file == INVALID_HANDLE_VALUE) {
1280
if (create_mode == OS_FILE_OPEN) {
1281
if (access_type == OS_FILE_READ_ONLY) {
1282
create_flag = O_RDONLY;
1284
create_flag = O_RDWR;
1286
} else if (create_mode == OS_FILE_CREATE) {
1287
create_flag = O_RDWR | O_CREAT | O_EXCL;
1293
if (create_mode == OS_FILE_CREATE) {
1294
file = open(name, create_flag, S_IRUSR | S_IWUSR
1295
| S_IRGRP | S_IWGRP);
1297
file = open(name, create_flag);
1302
#ifdef USE_FILE_LOCK
1303
} else if (access_type == OS_FILE_READ_WRITE
1304
&& os_file_lock(file, name)) {
1314
#endif /* __WIN__ */
1317
/****************************************************************//**
1318
Tries to disable OS caching on an opened file descriptor. */
1321
os_file_set_nocache(
1322
/*================*/
1323
int fd /*!< in: file descriptor to alter */
1324
__attribute__((unused)),
1325
const char* file_name /*!< in: used in the diagnostic message */
1326
__attribute__((unused)),
1327
const char* operation_name __attribute__((unused)))
1328
/*!< in: "open" or "create"; used in the
1329
diagnostic message */
1331
/* some versions of Solaris may not have DIRECTIO_ON */
1332
#if defined(UNIV_SOLARIS) && defined(DIRECTIO_ON)
1333
if (directio(fd, DIRECTIO_ON) == -1) {
1335
errno_save = (int)errno;
1336
ut_print_timestamp(stderr);
1338
" InnoDB: Failed to set DIRECTIO_ON "
1339
"on file %s: %s: %s, continuing anyway\n",
1340
file_name, operation_name, strerror(errno_save));
1342
#elif defined(O_DIRECT)
1343
if (fcntl(fd, F_SETFL, O_DIRECT) == -1) {
1345
errno_save = (int)errno;
1346
ut_print_timestamp(stderr);
1348
" InnoDB: Failed to set O_DIRECT "
1349
"on file %s: %s: %s, continuing anyway\n",
1350
file_name, operation_name, strerror(errno_save));
1351
if (errno_save == EINVAL) {
1352
ut_print_timestamp(stderr);
1354
" InnoDB: O_DIRECT is known to result in "
1355
"'Invalid argument' on Linux on tmpfs, "
1356
"see MySQL Bug#26662\n");
1362
/****************************************************************//**
1363
NOTE! Use the corresponding macro os_file_create(), not directly
1365
Opens an existing file or creates a new.
1366
@return own: handle to the file, not defined if error, error number
1367
can be retrieved with os_file_get_last_error */
1370
os_file_create_func(
1371
/*================*/
1372
const char* name, /*!< in: name of the file or path as a
1373
null-terminated string */
1374
ulint create_mode,/*!< in: OS_FILE_OPEN if an existing file
1375
is opened (if does not exist, error), or
1376
OS_FILE_CREATE if a new file is created
1378
OS_FILE_OVERWRITE if a new file is created
1379
or an old overwritten;
1380
OS_FILE_OPEN_RAW, if a raw device or disk
1381
partition should be opened */
1382
ulint purpose,/*!< in: OS_FILE_AIO, if asynchronous,
1383
non-buffered i/o is desired,
1384
OS_FILE_NORMAL, if any normal file;
1385
NOTE that it also depends on type, os_aio_..
1386
and srv_.. variables whether we really use
1387
async i/o or unbuffered i/o: look in the
1388
function source code for the exact rules */
1389
ulint type, /*!< in: OS_DATA_FILE or OS_LOG_FILE */
1390
ibool* success)/*!< out: TRUE if succeed, FALSE if error */
1394
DWORD share_mode = FILE_SHARE_READ;
1401
if (create_mode == OS_FILE_OPEN_RAW) {
1402
create_flag = OPEN_EXISTING;
1403
share_mode = FILE_SHARE_WRITE;
1404
} else if (create_mode == OS_FILE_OPEN
1405
|| create_mode == OS_FILE_OPEN_RETRY) {
1406
create_flag = OPEN_EXISTING;
1407
} else if (create_mode == OS_FILE_CREATE) {
1408
create_flag = CREATE_NEW;
1409
} else if (create_mode == OS_FILE_OVERWRITE) {
1410
create_flag = CREATE_ALWAYS;
1416
if (purpose == OS_FILE_AIO) {
1417
/* If specified, use asynchronous (overlapped) io and no
1418
buffering of writes in the OS */
1421
if (srv_use_native_aio) {
1422
attributes = attributes | FILE_FLAG_OVERLAPPED;
1425
#ifdef UNIV_NON_BUFFERED_IO
1426
# ifndef UNIV_HOTBACKUP
1427
if (type == OS_LOG_FILE && srv_flush_log_at_trx_commit == 2) {
1428
/* Do not use unbuffered i/o to log files because
1429
value 2 denotes that we do not flush the log at every
1430
commit, but only once per second */
1431
} else if (srv_win_file_flush_method
1432
== SRV_WIN_IO_UNBUFFERED) {
1433
attributes = attributes | FILE_FLAG_NO_BUFFERING;
1435
# else /* !UNIV_HOTBACKUP */
1436
attributes = attributes | FILE_FLAG_NO_BUFFERING;
1437
# endif /* !UNIV_HOTBACKUP */
1438
#endif /* UNIV_NON_BUFFERED_IO */
1439
} else if (purpose == OS_FILE_NORMAL) {
1441
#ifdef UNIV_NON_BUFFERED_IO
1442
# ifndef UNIV_HOTBACKUP
1443
if (type == OS_LOG_FILE && srv_flush_log_at_trx_commit == 2) {
1444
/* Do not use unbuffered i/o to log files because
1445
value 2 denotes that we do not flush the log at every
1446
commit, but only once per second */
1447
} else if (srv_win_file_flush_method
1448
== SRV_WIN_IO_UNBUFFERED) {
1449
attributes = attributes | FILE_FLAG_NO_BUFFERING;
1451
# else /* !UNIV_HOTBACKUP */
1452
attributes = attributes | FILE_FLAG_NO_BUFFERING;
1453
# endif /* !UNIV_HOTBACKUP */
1454
#endif /* UNIV_NON_BUFFERED_IO */
1460
file = CreateFile((LPCTSTR) name,
1461
GENERIC_READ | GENERIC_WRITE, /* read and write
1463
share_mode, /* File can be read also by other
1464
processes; we must give the read
1465
permission because of ibbackup. We do
1466
not give the write permission to
1467
others because if one would succeed to
1468
start 2 instances of mysqld on the
1469
SAME files, that could cause severe
1470
database corruption! When opening
1471
raw disk partitions, Microsoft manuals
1472
say that we must give also the write
1474
NULL, /* default security attributes */
1477
NULL); /*!< no template file */
1479
if (file == INVALID_HANDLE_VALUE) {
1482
/* When srv_file_per_table is on, file creation failure may not
1483
be critical to the whole instance. Do not crash the server in
1484
case of unknown errors.
1485
Please note "srv_file_per_table" is a global variable with
1486
no explicit synchronization protection. It could be
1487
changed during this execution path. It might not have the
1488
same value as the one when building the table definition */
1489
if (srv_file_per_table) {
1490
retry = os_file_handle_error_no_exit(name,
1491
create_mode == OS_FILE_CREATE ?
1494
retry = os_file_handle_error(name,
1495
create_mode == OS_FILE_CREATE ?
1511
const char* mode_str = NULL;
1516
if (create_mode == OS_FILE_OPEN || create_mode == OS_FILE_OPEN_RAW
1517
|| create_mode == OS_FILE_OPEN_RETRY) {
1519
create_flag = O_RDWR;
1520
} else if (create_mode == OS_FILE_CREATE) {
1521
mode_str = "CREATE";
1522
create_flag = O_RDWR | O_CREAT | O_EXCL;
1523
} else if (create_mode == OS_FILE_OVERWRITE) {
1524
mode_str = "OVERWRITE";
1525
create_flag = O_RDWR | O_CREAT | O_TRUNC;
1531
ut_a(type == OS_LOG_FILE || type == OS_DATA_FILE);
1532
ut_a(purpose == OS_FILE_AIO || purpose == OS_FILE_NORMAL);
1535
/* We let O_SYNC only affect log files; note that we map O_DSYNC to
1536
O_SYNC because the datasync options seemed to corrupt files in 2001
1537
in both Linux and Solaris */
1538
if (type == OS_LOG_FILE
1539
&& srv_unix_file_flush_method == SRV_UNIX_O_DSYNC) {
1542
fprintf(stderr, "Using O_SYNC for file %s\n", name);
1545
create_flag = create_flag | O_SYNC;
1549
file = open(name, create_flag, os_innodb_umask);
1554
/* When srv_file_per_table is on, file creation failure may not
1555
be critical to the whole instance. Do not crash the server in
1556
case of unknown errors.
1557
Please note "srv_file_per_table" is a global variable with
1558
no explicit synchronization protection. It could be
1559
changed during this execution path. It might not have the
1560
same value as the one when building the table definition */
1561
if (srv_file_per_table) {
1562
retry = os_file_handle_error_no_exit(name,
1563
create_mode == OS_FILE_CREATE ?
1566
retry = os_file_handle_error(name,
1567
create_mode == OS_FILE_CREATE ?
1574
return(file /* -1 */);
1581
/* We disable OS caching (O_DIRECT) only on data files */
1582
if (type != OS_LOG_FILE
1583
&& srv_unix_file_flush_method == SRV_UNIX_O_DIRECT) {
1585
os_file_set_nocache(file, name, mode_str);
1588
#ifdef USE_FILE_LOCK
1589
if (create_mode != OS_FILE_OPEN_RAW && os_file_lock(file, name)) {
1591
if (create_mode == OS_FILE_OPEN_RETRY) {
1593
ut_print_timestamp(stderr);
1594
fputs(" InnoDB: Retrying to lock"
1595
" the first data file\n",
1597
for (i = 0; i < 100; i++) {
1598
os_thread_sleep(1000000);
1599
if (!os_file_lock(file, name)) {
1604
ut_print_timestamp(stderr);
1605
fputs(" InnoDB: Unable to open the first data file\n",
1613
#endif /* USE_FILE_LOCK */
1616
#endif /* __WIN__ */
1619
/***********************************************************************//**
1620
Deletes a file if it exists. The file has to be closed before calling this.
1621
@return TRUE if success */
1624
os_file_delete_if_exists(
1625
/*=====================*/
1626
const char* name) /*!< in: file path as a null-terminated string */
1632
/* In Windows, deleting an .ibd file may fail if ibbackup is copying
1635
ret = DeleteFile((LPCTSTR)name);
1641
if (GetLastError() == ERROR_FILE_NOT_FOUND) {
1642
/* the file does not exist, this not an error */
1649
if (count > 100 && 0 == (count % 10)) {
1651
"InnoDB: Warning: cannot delete file %s\n"
1652
"InnoDB: Are you running ibbackup"
1653
" to back up the file?\n", name);
1655
os_file_get_last_error(TRUE); /* print error information */
1658
os_thread_sleep(1000000); /* sleep for a second */
1671
if (ret != 0 && errno != ENOENT) {
1672
os_file_handle_error_no_exit(name, "delete");
1681
/***********************************************************************//**
1682
Deletes a file. The file has to be closed before calling this.
1683
@return TRUE if success */
1688
const char* name) /*!< in: file path as a null-terminated string */
1694
/* In Windows, deleting an .ibd file may fail if ibbackup is copying
1697
ret = DeleteFile((LPCTSTR)name);
1703
if (GetLastError() == ERROR_FILE_NOT_FOUND) {
1704
/* If the file does not exist, we classify this as a 'mild'
1712
if (count > 100 && 0 == (count % 10)) {
1714
"InnoDB: Warning: cannot delete file %s\n"
1715
"InnoDB: Are you running ibbackup"
1716
" to back up the file?\n", name);
1718
os_file_get_last_error(TRUE); /* print error information */
1721
os_thread_sleep(1000000); /* sleep for a second */
1735
os_file_handle_error_no_exit(name, "delete");
1744
/***********************************************************************//**
1745
NOTE! Use the corresponding macro os_file_rename(), not directly this function!
1746
Renames a file (can also move it to another directory). It is safest that the
1747
file is closed before calling this function.
1748
@return TRUE if success */
1751
os_file_rename_func(
1752
/*================*/
1753
const char* oldpath,/*!< in: old file path as a null-terminated
1755
const char* newpath)/*!< in: new file path */
1760
ret = MoveFile((LPCTSTR)oldpath, (LPCTSTR)newpath);
1766
os_file_handle_error_no_exit(oldpath, "rename");
1772
ret = rename(oldpath, newpath);
1775
os_file_handle_error_no_exit(oldpath, "rename");
1784
/***********************************************************************//**
1785
NOTE! Use the corresponding macro os_file_close(), not directly this function!
1786
Closes a file handle. In case of error, error number can be retrieved with
1787
os_file_get_last_error.
1788
@return TRUE if success */
1793
os_file_t file) /*!< in, own: handle to a file */
1800
ret = CloseHandle(file);
1806
os_file_handle_error(NULL, "close");
1815
os_file_handle_error(NULL, "close");
1824
#ifdef UNIV_HOTBACKUP
1825
/***********************************************************************//**
1826
Closes a file handle.
1827
@return TRUE if success */
1830
os_file_close_no_error_handling(
1831
/*============================*/
1832
os_file_t file) /*!< in, own: handle to a file */
1839
ret = CloseHandle(file);
1859
#endif /* UNIV_HOTBACKUP */
1861
/***********************************************************************//**
1863
@return TRUE if success */
1868
os_file_t file, /*!< in: handle to a file */
1869
ulint* size, /*!< out: least significant 32 bits of file
1871
ulint* size_high)/*!< out: most significant 32 bits of size */
1877
low = GetFileSize(file, &high);
1879
if ((low == 0xFFFFFFFF) && (GetLastError() != NO_ERROR)) {
1890
offs = lseek(file, 0, SEEK_END);
1892
if (offs == ((off_t)-1)) {
1897
if (sizeof(off_t) > 4) {
1898
*size = (ulint)(offs & 0xFFFFFFFFUL);
1899
*size_high = (ulint)(offs >> 32);
1901
*size = (ulint) offs;
1909
/***********************************************************************//**
1910
Gets file size as a 64-bit integer ib_int64_t.
1911
@return size in bytes, -1 if error */
1914
os_file_get_size_as_iblonglong(
1915
/*===========================*/
1916
os_file_t file) /*!< in: handle to a file */
1922
success = os_file_get_size(file, &size, &size_high);
1929
return((((ib_int64_t)size_high) << 32) + (ib_int64_t)size);
1932
/***********************************************************************//**
1933
Write the specified number of zeros to a newly created file.
1934
@return TRUE if success */
1939
const char* name, /*!< in: name of the file or path as a
1940
null-terminated string */
1941
os_file_t file, /*!< in: handle to a file */
1942
ulint size, /*!< in: least significant 32 bits of file
1944
ulint size_high)/*!< in: most significant 32 bits of size */
1946
ib_int64_t current_size;
1947
ib_int64_t desired_size;
1953
ut_a(size == (size & 0xFFFFFFFF));
1956
desired_size = (ib_int64_t)size + (((ib_int64_t)size_high) << 32);
1958
/* Write up to 1 megabyte at a time. */
1959
buf_size = ut_min(64, (ulint) (desired_size / UNIV_PAGE_SIZE))
1961
buf2 = ut_malloc(buf_size + UNIV_PAGE_SIZE);
1963
/* Align the buffer for possible raw i/o */
1964
buf = ut_align(buf2, UNIV_PAGE_SIZE);
1966
/* Write buffer full of zeros */
1967
memset(buf, 0, buf_size);
1969
if (desired_size >= (ib_int64_t)(100 * 1024 * 1024)) {
1971
fprintf(stderr, "InnoDB: Progress in MB:");
1974
while (current_size < desired_size) {
1977
if (desired_size - current_size < (ib_int64_t) buf_size) {
1978
n_bytes = (ulint) (desired_size - current_size);
1983
ret = os_file_write(name, file, buf,
1984
(ulint)(current_size & 0xFFFFFFFF),
1985
(ulint)(current_size >> 32),
1989
goto error_handling;
1992
/* Print about progress for each 100 MB written */
1993
if ((ib_int64_t) (current_size + n_bytes) / (ib_int64_t)(100 * 1024 * 1024)
1994
!= current_size / (ib_int64_t)(100 * 1024 * 1024)) {
1996
fprintf(stderr, " %lu00",
1997
(ulong) ((current_size + n_bytes)
1998
/ (ib_int64_t)(100 * 1024 * 1024)));
2001
current_size += n_bytes;
2004
if (desired_size >= (ib_int64_t)(100 * 1024 * 1024)) {
2006
fprintf(stderr, "\n");
2011
ret = os_file_flush(file);
2021
/***********************************************************************//**
2022
Truncates a file at its current position.
2023
@return TRUE if success */
2028
FILE* file) /*!< in: file to be truncated */
2031
HANDLE h = (HANDLE) _get_osfhandle(fileno(file));
2032
return(SetEndOfFile(h));
2034
return(!ftruncate(fileno(file), ftell(file)));
2035
#endif /* __WIN__ */
2039
/***********************************************************************//**
2040
Wrapper to fsync(2) that retries the call on some errors.
2041
Returns the value 0 if successful; otherwise the value -1 is returned and
2042
the global variable errno is set to indicate the error.
2043
@return 0 if success, -1 otherwise */
2049
os_file_t file) /*!< in: handle to a file */
2062
if (ret == -1 && errno == ENOLCK) {
2064
if (failures % 100 == 0) {
2066
ut_print_timestamp(stderr);
2068
" InnoDB: fsync(): "
2069
"No locks available; retrying\n");
2072
os_thread_sleep(200000 /* 0.2 sec */);
2085
#endif /* !__WIN__ */
2087
/***********************************************************************//**
2088
NOTE! Use the corresponding macro os_file_flush(), not directly this function!
2089
Flushes the write buffers of a given file to the disk.
2090
@return TRUE if success */
2095
os_file_t file) /*!< in, own: handle to a file */
2104
ret = FlushFileBuffers(file);
2110
/* Since Windows returns ERROR_INVALID_FUNCTION if the 'file' is
2111
actually a raw device, we choose to ignore that error if we are using
2114
if (srv_start_raw_disk_in_use && GetLastError()
2115
== ERROR_INVALID_FUNCTION) {
2119
os_file_handle_error(NULL, "flush");
2121
/* It is a fatal error if a file flush does not succeed, because then
2122
the database can get corrupt on disk */
2129
#if defined(HAVE_DARWIN_THREADS)
2130
# ifndef F_FULLFSYNC
2131
/* The following definition is from the Mac OS X 10.3 <sys/fcntl.h> */
2132
# define F_FULLFSYNC 51 /* fsync + ask the drive to flush to the media */
2133
# elif F_FULLFSYNC != 51
2134
# error "F_FULLFSYNC != 51: ABI incompatibility with Mac OS X 10.3"
2136
/* Apple has disabled fsync() for internal disk drives in OS X. That
2137
caused corruption for a user when he tested a power outage. Let us in
2138
OS X use a nonstandard flush method recommended by an Apple
2141
if (!srv_have_fullfsync) {
2142
/* If we are not on an operating system that supports this,
2143
then fall back to a plain fsync. */
2145
ret = os_file_fsync(file);
2147
ret = fcntl(file, F_FULLFSYNC, NULL);
2150
/* If we are not on a file system that supports this,
2151
then fall back to a plain fsync. */
2152
ret = os_file_fsync(file);
2156
ret = os_file_fsync(file);
2163
/* Since Linux returns EINVAL if the 'file' is actually a raw device,
2164
we choose to ignore that error if we are using raw disks */
2166
if (srv_start_raw_disk_in_use && errno == EINVAL) {
2171
ut_print_timestamp(stderr);
2174
" InnoDB: Error: the OS said file flush did not succeed\n");
2176
os_file_handle_error(NULL, "flush");
2178
/* It is a fatal error if a file flush does not succeed, because then
2179
the database can get corrupt on disk */
2187
/*******************************************************************//**
2188
Does a synchronous read operation in Posix.
2189
@return number of bytes read, -1 if error */
2194
os_file_t file, /*!< in: handle to a file */
2195
void* buf, /*!< in: buffer where to read */
2196
ulint n, /*!< in: number of bytes to read */
2197
ulint offset, /*!< in: least significant 32 bits of file
2198
offset from where to read */
2199
ulint offset_high) /*!< in: most significant 32 bits of
2203
#if defined(HAVE_PREAD) && !defined(HAVE_BROKEN_PREAD)
2205
#endif /* HAVE_PREAD && !HAVE_BROKEN_PREAD */
2207
ut_a((offset & 0xFFFFFFFFUL) == offset);
2209
/* If off_t is > 4 bytes in size, then we assume we can pass a
2212
if (sizeof(off_t) > 4) {
2213
offs = (off_t)offset + (((off_t)offset_high) << 32);
2216
offs = (off_t)offset;
2218
if (offset_high > 0) {
2220
"InnoDB: Error: file read at offset > 4 GB\n");
2226
#if defined(HAVE_PREAD) && !defined(HAVE_BROKEN_PREAD)
2227
os_mutex_enter(os_file_count_mutex);
2228
os_file_n_pending_preads++;
2229
os_n_pending_reads++;
2230
os_mutex_exit(os_file_count_mutex);
2232
n_bytes = pread(file, buf, (ssize_t)n, offs);
2234
os_mutex_enter(os_file_count_mutex);
2235
os_file_n_pending_preads--;
2236
os_n_pending_reads--;
2237
os_mutex_exit(os_file_count_mutex);
2244
#ifndef UNIV_HOTBACKUP
2246
#endif /* !UNIV_HOTBACKUP */
2248
os_mutex_enter(os_file_count_mutex);
2249
os_n_pending_reads++;
2250
os_mutex_exit(os_file_count_mutex);
2252
#ifndef UNIV_HOTBACKUP
2253
/* Protect the seek / read operation with a mutex */
2254
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
2256
os_mutex_enter(os_file_seek_mutexes[i]);
2257
#endif /* !UNIV_HOTBACKUP */
2259
ret_offset = lseek(file, offs, SEEK_SET);
2261
if (ret_offset < 0) {
2264
ret = read(file, buf, (ssize_t)n);
2267
#ifndef UNIV_HOTBACKUP
2268
os_mutex_exit(os_file_seek_mutexes[i]);
2269
#endif /* !UNIV_HOTBACKUP */
2271
os_mutex_enter(os_file_count_mutex);
2272
os_n_pending_reads--;
2273
os_mutex_exit(os_file_count_mutex);
2280
/*******************************************************************//**
2281
Does a synchronous write operation in Posix.
2282
@return number of bytes written, -1 if error */
2287
os_file_t file, /*!< in: handle to a file */
2288
const void* buf, /*!< in: buffer from where to write */
2289
ulint n, /*!< in: number of bytes to write */
2290
ulint offset, /*!< in: least significant 32 bits of file
2291
offset where to write */
2292
ulint offset_high) /*!< in: most significant 32 bits of
2298
ut_a((offset & 0xFFFFFFFFUL) == offset);
2300
/* If off_t is > 4 bytes in size, then we assume we can pass a
2303
if (sizeof(off_t) > 4) {
2304
offs = (off_t)offset + (((off_t)offset_high) << 32);
2306
offs = (off_t)offset;
2308
if (offset_high > 0) {
2310
"InnoDB: Error: file write"
2311
" at offset > 4 GB\n");
2317
#if defined(HAVE_PWRITE) && !defined(HAVE_BROKEN_PREAD)
2318
os_mutex_enter(os_file_count_mutex);
2319
os_file_n_pending_pwrites++;
2320
os_n_pending_writes++;
2321
os_mutex_exit(os_file_count_mutex);
2323
ret = pwrite(file, buf, (ssize_t)n, offs);
2325
os_mutex_enter(os_file_count_mutex);
2326
os_file_n_pending_pwrites--;
2327
os_n_pending_writes--;
2328
os_mutex_exit(os_file_count_mutex);
2330
# ifdef UNIV_DO_FLUSH
2331
if (srv_unix_file_flush_method != SRV_UNIX_LITTLESYNC
2332
&& srv_unix_file_flush_method != SRV_UNIX_NOSYNC
2333
&& !os_do_not_call_flush_at_each_write) {
2335
/* Always do fsync to reduce the probability that when
2336
the OS crashes, a database page is only partially
2337
physically written to disk. */
2339
ut_a(TRUE == os_file_flush(file));
2341
# endif /* UNIV_DO_FLUSH */
2347
# ifndef UNIV_HOTBACKUP
2349
# endif /* !UNIV_HOTBACKUP */
2351
os_mutex_enter(os_file_count_mutex);
2352
os_n_pending_writes++;
2353
os_mutex_exit(os_file_count_mutex);
2355
# ifndef UNIV_HOTBACKUP
2356
/* Protect the seek / write operation with a mutex */
2357
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
2359
os_mutex_enter(os_file_seek_mutexes[i]);
2360
# endif /* UNIV_HOTBACKUP */
2362
ret_offset = lseek(file, offs, SEEK_SET);
2364
if (ret_offset < 0) {
2370
ret = write(file, buf, (ssize_t)n);
2372
# ifdef UNIV_DO_FLUSH
2373
if (srv_unix_file_flush_method != SRV_UNIX_LITTLESYNC
2374
&& srv_unix_file_flush_method != SRV_UNIX_NOSYNC
2375
&& !os_do_not_call_flush_at_each_write) {
2377
/* Always do fsync to reduce the probability that when
2378
the OS crashes, a database page is only partially
2379
physically written to disk. */
2381
ut_a(TRUE == os_file_flush(file));
2383
# endif /* UNIV_DO_FLUSH */
2386
# ifndef UNIV_HOTBACKUP
2387
os_mutex_exit(os_file_seek_mutexes[i]);
2388
# endif /* !UNIV_HOTBACKUP */
2390
os_mutex_enter(os_file_count_mutex);
2391
os_n_pending_writes--;
2392
os_mutex_exit(os_file_count_mutex);
2400
/*******************************************************************//**
2401
NOTE! Use the corresponding macro os_file_read(), not directly this
2403
Requests a synchronous positioned read operation.
2404
@return TRUE if request was successful, FALSE if fail */
2409
os_file_t file, /*!< in: handle to a file */
2410
void* buf, /*!< in: buffer where to read */
2411
ulint offset, /*!< in: least significant 32 bits of file
2412
offset where to read */
2413
ulint offset_high, /*!< in: most significant 32 bits of
2415
ulint n) /*!< in: number of bytes to read */
2424
#ifndef UNIV_HOTBACKUP
2426
#endif /* !UNIV_HOTBACKUP */
2428
/* On 64-bit Windows, ulint is 64 bits. But offset and n should be
2429
no more than 32 bits. */
2430
ut_a((offset & 0xFFFFFFFFUL) == offset);
2431
ut_a((n & 0xFFFFFFFFUL) == n);
2434
os_bytes_read_since_printout += n;
2441
low = (DWORD) offset;
2442
high = (DWORD) offset_high;
2444
os_mutex_enter(os_file_count_mutex);
2445
os_n_pending_reads++;
2446
os_mutex_exit(os_file_count_mutex);
2448
#ifndef UNIV_HOTBACKUP
2449
/* Protect the seek / read operation with a mutex */
2450
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
2452
os_mutex_enter(os_file_seek_mutexes[i]);
2453
#endif /* !UNIV_HOTBACKUP */
2455
ret2 = SetFilePointer(file, low, &high, FILE_BEGIN);
2457
if (ret2 == 0xFFFFFFFF && GetLastError() != NO_ERROR) {
2459
#ifndef UNIV_HOTBACKUP
2460
os_mutex_exit(os_file_seek_mutexes[i]);
2461
#endif /* !UNIV_HOTBACKUP */
2463
os_mutex_enter(os_file_count_mutex);
2464
os_n_pending_reads--;
2465
os_mutex_exit(os_file_count_mutex);
2467
goto error_handling;
2470
ret = ReadFile(file, buf, (DWORD) n, &len, NULL);
2472
#ifndef UNIV_HOTBACKUP
2473
os_mutex_exit(os_file_seek_mutexes[i]);
2474
#endif /* !UNIV_HOTBACKUP */
2476
os_mutex_enter(os_file_count_mutex);
2477
os_n_pending_reads--;
2478
os_mutex_exit(os_file_count_mutex);
2480
if (ret && len == n) {
2487
os_bytes_read_since_printout += n;
2490
ret = os_file_pread(file, buf, n, offset, offset_high);
2492
if ((ulint)ret == n) {
2498
"InnoDB: Error: tried to read %lu bytes at offset %lu %lu.\n"
2499
"InnoDB: Was only able to read %ld.\n",
2500
(ulong)n, (ulong)offset_high,
2501
(ulong)offset, (long)ret);
2502
#endif /* __WIN__ */
2506
retry = os_file_handle_error(NULL, "read");
2513
"InnoDB: Fatal error: cannot read from file."
2514
" OS error number %lu.\n",
2516
(ulong) GetLastError()
2528
/*******************************************************************//**
2529
NOTE! Use the corresponding macro os_file_read_no_error_handling(),
2530
not directly this function!
2531
Requests a synchronous positioned read operation. This function does not do
2532
any error handling. In case of error it returns FALSE.
2533
@return TRUE if request was successful, FALSE if fail */
2536
os_file_read_no_error_handling_func(
2537
/*================================*/
2538
os_file_t file, /*!< in: handle to a file */
2539
void* buf, /*!< in: buffer where to read */
2540
ulint offset, /*!< in: least significant 32 bits of file
2541
offset where to read */
2542
ulint offset_high, /*!< in: most significant 32 bits of
2544
ulint n) /*!< in: number of bytes to read */
2553
#ifndef UNIV_HOTBACKUP
2555
#endif /* !UNIV_HOTBACKUP */
2557
/* On 64-bit Windows, ulint is 64 bits. But offset and n should be
2558
no more than 32 bits. */
2559
ut_a((offset & 0xFFFFFFFFUL) == offset);
2560
ut_a((n & 0xFFFFFFFFUL) == n);
2563
os_bytes_read_since_printout += n;
2570
low = (DWORD) offset;
2571
high = (DWORD) offset_high;
2573
os_mutex_enter(os_file_count_mutex);
2574
os_n_pending_reads++;
2575
os_mutex_exit(os_file_count_mutex);
2577
#ifndef UNIV_HOTBACKUP
2578
/* Protect the seek / read operation with a mutex */
2579
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
2581
os_mutex_enter(os_file_seek_mutexes[i]);
2582
#endif /* !UNIV_HOTBACKUP */
2584
ret2 = SetFilePointer(file, low, &high, FILE_BEGIN);
2586
if (ret2 == 0xFFFFFFFF && GetLastError() != NO_ERROR) {
2588
#ifndef UNIV_HOTBACKUP
2589
os_mutex_exit(os_file_seek_mutexes[i]);
2590
#endif /* !UNIV_HOTBACKUP */
2592
os_mutex_enter(os_file_count_mutex);
2593
os_n_pending_reads--;
2594
os_mutex_exit(os_file_count_mutex);
2596
goto error_handling;
2599
ret = ReadFile(file, buf, (DWORD) n, &len, NULL);
2601
#ifndef UNIV_HOTBACKUP
2602
os_mutex_exit(os_file_seek_mutexes[i]);
2603
#endif /* !UNIV_HOTBACKUP */
2605
os_mutex_enter(os_file_count_mutex);
2606
os_n_pending_reads--;
2607
os_mutex_exit(os_file_count_mutex);
2609
if (ret && len == n) {
2616
os_bytes_read_since_printout += n;
2619
ret = os_file_pread(file, buf, n, offset, offset_high);
2621
if ((ulint)ret == n) {
2625
#endif /* __WIN__ */
2629
retry = os_file_handle_error_no_exit(NULL, "read");
2638
/*******************************************************************//**
2639
Rewind file to its start, read at most size - 1 bytes from it to str, and
2640
NUL-terminate str. All errors are silently ignored. This function is
2641
mostly meant to be used with temporary files. */
2644
os_file_read_string(
2645
/*================*/
2646
FILE* file, /*!< in: file to read from */
2647
char* str, /*!< in: buffer where to read */
2648
ulint size) /*!< in: size of buffer */
2657
flen = fread(str, 1, size - 1, file);
2661
/*******************************************************************//**
2662
NOTE! Use the corresponding macro os_file_write(), not directly
2664
Requests a synchronous write operation.
2665
@return TRUE if request was successful, FALSE if fail */
2670
const char* name, /*!< in: name of the file or path as a
2671
null-terminated string */
2672
os_file_t file, /*!< in: handle to a file */
2673
const void* buf, /*!< in: buffer from which to write */
2674
ulint offset, /*!< in: least significant 32 bits of file
2675
offset where to write */
2676
ulint offset_high, /*!< in: most significant 32 bits of
2678
ulint n) /*!< in: number of bytes to write */
2686
ulint n_retries = 0;
2688
#ifndef UNIV_HOTBACKUP
2690
#endif /* !UNIV_HOTBACKUP */
2692
/* On 64-bit Windows, ulint is 64 bits. But offset and n should be
2693
no more than 32 bits. */
2694
ut_a((offset & 0xFFFFFFFFUL) == offset);
2695
ut_a((n & 0xFFFFFFFFUL) == n);
2703
low = (DWORD) offset;
2704
high = (DWORD) offset_high;
2706
os_mutex_enter(os_file_count_mutex);
2707
os_n_pending_writes++;
2708
os_mutex_exit(os_file_count_mutex);
2710
#ifndef UNIV_HOTBACKUP
2711
/* Protect the seek / write operation with a mutex */
2712
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
2714
os_mutex_enter(os_file_seek_mutexes[i]);
2715
#endif /* !UNIV_HOTBACKUP */
2717
ret2 = SetFilePointer(file, low, &high, FILE_BEGIN);
2719
if (ret2 == 0xFFFFFFFF && GetLastError() != NO_ERROR) {
2721
#ifndef UNIV_HOTBACKUP
2722
os_mutex_exit(os_file_seek_mutexes[i]);
2723
#endif /* !UNIV_HOTBACKUP */
2725
os_mutex_enter(os_file_count_mutex);
2726
os_n_pending_writes--;
2727
os_mutex_exit(os_file_count_mutex);
2729
ut_print_timestamp(stderr);
2732
" InnoDB: Error: File pointer positioning to"
2733
" file %s failed at\n"
2734
"InnoDB: offset %lu %lu. Operating system"
2735
" error number %lu.\n"
2736
"InnoDB: Some operating system error numbers"
2737
" are described at\n"
2739
REFMAN "operating-system-error-codes.html\n",
2740
name, (ulong) offset_high, (ulong) offset,
2741
(ulong) GetLastError());
2746
ret = WriteFile(file, buf, (DWORD) n, &len, NULL);
2748
/* Always do fsync to reduce the probability that when the OS crashes,
2749
a database page is only partially physically written to disk. */
2751
# ifdef UNIV_DO_FLUSH
2752
if (!os_do_not_call_flush_at_each_write) {
2753
ut_a(TRUE == os_file_flush(file));
2755
# endif /* UNIV_DO_FLUSH */
2757
#ifndef UNIV_HOTBACKUP
2758
os_mutex_exit(os_file_seek_mutexes[i]);
2759
#endif /* !UNIV_HOTBACKUP */
2761
os_mutex_enter(os_file_count_mutex);
2762
os_n_pending_writes--;
2763
os_mutex_exit(os_file_count_mutex);
2765
if (ret && len == n) {
2770
/* If some background file system backup tool is running, then, at
2771
least in Windows 2000, we may get here a specific error. Let us
2772
retry the operation 100 times, with 1 second waits. */
2774
if (GetLastError() == ERROR_LOCK_VIOLATION && n_retries < 100) {
2776
os_thread_sleep(1000000);
2783
if (!os_has_said_disk_full) {
2785
err = (ulint)GetLastError();
2787
ut_print_timestamp(stderr);
2790
" InnoDB: Error: Write to file %s failed"
2791
" at offset %lu %lu.\n"
2792
"InnoDB: %lu bytes should have been written,"
2793
" only %lu were written.\n"
2794
"InnoDB: Operating system error number %lu.\n"
2795
"InnoDB: Check that your OS and file system"
2796
" support files of this size.\n"
2797
"InnoDB: Check also that the disk is not full"
2798
" or a disk quota exceeded.\n",
2799
name, (ulong) offset_high, (ulong) offset,
2800
(ulong) n, (ulong) len, (ulong) err);
2802
if (strerror((int)err) != NULL) {
2804
"InnoDB: Error number %lu means '%s'.\n",
2805
(ulong) err, strerror((int)err));
2809
"InnoDB: Some operating system error numbers"
2810
" are described at\n"
2812
REFMAN "operating-system-error-codes.html\n");
2814
os_has_said_disk_full = TRUE;
2821
ret = os_file_pwrite(file, buf, n, offset, offset_high);
2823
if ((ulint)ret == n) {
2828
if (!os_has_said_disk_full) {
2830
ut_print_timestamp(stderr);
2833
" InnoDB: Error: Write to file %s failed"
2834
" at offset %lu %lu.\n"
2835
"InnoDB: %lu bytes should have been written,"
2836
" only %ld were written.\n"
2837
"InnoDB: Operating system error number %lu.\n"
2838
"InnoDB: Check that your OS and file system"
2839
" support files of this size.\n"
2840
"InnoDB: Check also that the disk is not full"
2841
" or a disk quota exceeded.\n",
2842
name, offset_high, offset, n, (long int)ret,
2844
if (strerror(errno) != NULL) {
2846
"InnoDB: Error number %lu means '%s'.\n",
2847
(ulint)errno, strerror(errno));
2851
"InnoDB: Some operating system error numbers"
2852
" are described at\n"
2854
REFMAN "operating-system-error-codes.html\n");
2856
os_has_said_disk_full = TRUE;
2863
/*******************************************************************//**
2864
Check the existence and type of the given file.
2865
@return TRUE if call succeeded */
2870
const char* path, /*!< in: pathname of the file */
2871
ibool* exists, /*!< out: TRUE if file exists */
2872
os_file_type_t* type) /*!< out: type of the file (if it exists) */
2876
struct _stat statinfo;
2878
ret = _stat(path, &statinfo);
2879
if (ret && (errno == ENOENT || errno == ENOTDIR)) {
2880
/* file does not exist */
2884
/* file exists, but stat call failed */
2886
os_file_handle_error_no_exit(path, "stat");
2891
if (_S_IFDIR & statinfo.st_mode) {
2892
*type = OS_FILE_TYPE_DIR;
2893
} else if (_S_IFREG & statinfo.st_mode) {
2894
*type = OS_FILE_TYPE_FILE;
2896
*type = OS_FILE_TYPE_UNKNOWN;
2904
struct stat statinfo;
2906
ret = stat(path, &statinfo);
2907
if (ret && (errno == ENOENT || errno == ENOTDIR)) {
2908
/* file does not exist */
2912
/* file exists, but stat call failed */
2914
os_file_handle_error_no_exit(path, "stat");
2919
if (S_ISDIR(statinfo.st_mode)) {
2920
*type = OS_FILE_TYPE_DIR;
2921
} else if (S_ISLNK(statinfo.st_mode)) {
2922
*type = OS_FILE_TYPE_LINK;
2923
} else if (S_ISREG(statinfo.st_mode)) {
2924
*type = OS_FILE_TYPE_FILE;
2926
*type = OS_FILE_TYPE_UNKNOWN;
2935
/*******************************************************************//**
2936
This function returns information about the specified file
2937
@return TRUE if stat information found */
2942
const char* path, /*!< in: pathname of the file */
2943
os_file_stat_t* stat_info) /*!< information of a file in a
2948
struct _stat statinfo;
2950
ret = _stat(path, &statinfo);
2951
if (ret && (errno == ENOENT || errno == ENOTDIR)) {
2952
/* file does not exist */
2956
/* file exists, but stat call failed */
2958
os_file_handle_error_no_exit(path, "stat");
2962
if (_S_IFDIR & statinfo.st_mode) {
2963
stat_info->type = OS_FILE_TYPE_DIR;
2964
} else if (_S_IFREG & statinfo.st_mode) {
2965
stat_info->type = OS_FILE_TYPE_FILE;
2967
stat_info->type = OS_FILE_TYPE_UNKNOWN;
2970
stat_info->ctime = statinfo.st_ctime;
2971
stat_info->atime = statinfo.st_atime;
2972
stat_info->mtime = statinfo.st_mtime;
2973
stat_info->size = statinfo.st_size;
2978
struct stat statinfo;
2980
ret = stat(path, &statinfo);
2982
if (ret && (errno == ENOENT || errno == ENOTDIR)) {
2983
/* file does not exist */
2987
/* file exists, but stat call failed */
2989
os_file_handle_error_no_exit(path, "stat");
2994
if (S_ISDIR(statinfo.st_mode)) {
2995
stat_info->type = OS_FILE_TYPE_DIR;
2996
} else if (S_ISLNK(statinfo.st_mode)) {
2997
stat_info->type = OS_FILE_TYPE_LINK;
2998
} else if (S_ISREG(statinfo.st_mode)) {
2999
stat_info->type = OS_FILE_TYPE_FILE;
3001
stat_info->type = OS_FILE_TYPE_UNKNOWN;
3004
stat_info->ctime = statinfo.st_ctime;
3005
stat_info->atime = statinfo.st_atime;
3006
stat_info->mtime = statinfo.st_mtime;
3007
stat_info->size = statinfo.st_size;
3013
/* path name separator character */
3015
# define OS_FILE_PATH_SEPARATOR '\\'
3017
# define OS_FILE_PATH_SEPARATOR '/'
3020
/****************************************************************//**
3021
The function os_file_dirname returns a directory component of a
3022
null-terminated pathname string. In the usual case, dirname returns
3023
the string up to, but not including, the final '/', and basename
3024
is the component following the final '/'. Trailing '/' charac�
3025
ters are not counted as part of the pathname.
3027
If path does not contain a slash, dirname returns the string ".".
3029
Concatenating the string returned by dirname, a "/", and the basename
3030
yields a complete pathname.
3032
The return value is a copy of the directory component of the pathname.
3033
The copy is allocated from heap. It is the caller responsibility
3034
to free it after it is no longer needed.
3036
The following list of examples (taken from SUSv2) shows the strings
3037
returned by dirname and basename for different paths:
3039
path dirname basename
3040
"/usr/lib" "/usr" "lib"
3047
@return own: directory component of the pathname */
3052
const char* path) /*!< in: pathname */
3054
/* Find the offset of the last slash */
3055
const char* last_slash = strrchr(path, OS_FILE_PATH_SEPARATOR);
3057
/* No slash in the path, return "." */
3059
return(mem_strdup("."));
3062
/* Ok, there is a slash */
3064
if (last_slash == path) {
3065
/* last slash is the first char of the path */
3067
return(mem_strdup("/"));
3070
/* Non-trivial directory component */
3072
return(mem_strdupl(path, last_slash - path));
3075
/****************************************************************//**
3076
Creates all missing subdirectories along the given path.
3077
@return TRUE if call succeeded FALSE otherwise */
3080
os_file_create_subdirs_if_needed(
3081
/*=============================*/
3082
const char* path) /*!< in: path name */
3085
ibool success, subdir_exists;
3086
os_file_type_t type;
3088
subdir = os_file_dirname(path);
3089
if (strlen(subdir) == 1
3090
&& (*subdir == OS_FILE_PATH_SEPARATOR || *subdir == '.')) {
3091
/* subdir is root or cwd, nothing to do */
3097
/* Test if subdir exists */
3098
success = os_file_status(subdir, &subdir_exists, &type);
3099
if (success && !subdir_exists) {
3100
/* subdir does not exist, create it */
3101
success = os_file_create_subdirs_if_needed(subdir);
3107
success = os_file_create_directory(subdir, FALSE);
3115
#ifndef UNIV_HOTBACKUP
3116
/****************************************************************//**
3117
Returns a pointer to the nth slot in the aio array.
3118
@return pointer to slot */
3121
os_aio_array_get_nth_slot(
3122
/*======================*/
3123
os_aio_array_t* array, /*!< in: aio array */
3124
ulint index) /*!< in: index of the slot */
3126
ut_a(index < array->n_slots);
3128
return((array->slots) + index);
3131
#if defined(LINUX_NATIVE_AIO)
3132
/******************************************************************//**
3133
Creates an io_context for native linux AIO.
3134
@return TRUE on success. */
3137
os_aio_linux_create_io_ctx(
3138
/*=======================*/
3139
ulint max_events, /*!< in: number of events. */
3140
io_context_t* io_ctx) /*!< out: io_ctx to initialize. */
3146
memset(io_ctx, 0x0, sizeof(*io_ctx));
3148
/* Initialize the io_ctx. Tell it how many pending
3149
IO requests this context will handle. */
3151
ret = io_setup(max_events, io_ctx);
3153
#if defined(UNIV_AIO_DEBUG)
3155
"InnoDB: Linux native AIO:"
3156
" initialized io_ctx for segment\n");
3158
/* Success. Return now. */
3162
/* If we hit EAGAIN we'll make a few attempts before failing. */
3167
/* First time around. */
3168
ut_print_timestamp(stderr);
3170
" InnoDB: Warning: io_setup() failed"
3171
" with EAGAIN. Will make %d attempts"
3172
" before giving up.\n",
3173
OS_AIO_IO_SETUP_RETRY_ATTEMPTS);
3176
if (retries < OS_AIO_IO_SETUP_RETRY_ATTEMPTS) {
3179
"InnoDB: Warning: io_setup() attempt"
3182
os_thread_sleep(OS_AIO_IO_SETUP_RETRY_SLEEP);
3186
/* Have tried enough. Better call it a day. */
3187
ut_print_timestamp(stderr);
3189
" InnoDB: Error: io_setup() failed"
3190
" with EAGAIN after %d attempts.\n",
3191
OS_AIO_IO_SETUP_RETRY_ATTEMPTS);
3195
ut_print_timestamp(stderr);
3197
" InnoDB: Error: Linux Native AIO interface"
3198
" is not supported on this platform. Please"
3199
" check your OS documentation and install"
3200
" appropriate binary of InnoDB.\n");
3205
ut_print_timestamp(stderr);
3207
" InnoDB: Error: Linux Native AIO setup"
3208
" returned following error[%d]\n", -ret);
3213
"InnoDB: You can disable Linux Native AIO by"
3214
" setting innodb_native_aio = off in my.cnf\n");
3217
#endif /* LINUX_NATIVE_AIO */
3219
/******************************************************************//**
3220
Creates an aio wait array. Note that we return NULL in case of failure.
3221
We don't care about freeing memory here because we assume that a
3222
failure will result in server refusing to start up.
3223
@return own: aio array, NULL on failure */
3226
os_aio_array_create(
3227
/*================*/
3228
ulint n, /*!< in: maximum number of pending aio
3229
operations allowed; n must be
3230
divisible by n_segments */
3231
ulint n_segments) /*!< in: number of segments in the aio array */
3233
os_aio_array_t* array;
3235
os_aio_slot_t* slot;
3238
#elif defined(LINUX_NATIVE_AIO)
3239
struct io_event* io_event = NULL;
3242
ut_a(n_segments > 0);
3244
array = ut_malloc(sizeof(os_aio_array_t));
3246
array->mutex = os_mutex_create();
3247
array->not_full = os_event_create(NULL);
3248
array->is_empty = os_event_create(NULL);
3250
os_event_set(array->is_empty);
3253
array->n_segments = n_segments;
3254
array->n_reserved = 0;
3256
array->slots = ut_malloc(n * sizeof(os_aio_slot_t));
3258
array->handles = ut_malloc(n * sizeof(HANDLE));
3261
#if defined(LINUX_NATIVE_AIO)
3262
array->aio_ctx = NULL;
3263
array->aio_events = NULL;
3265
/* If we are not using native aio interface then skip this
3266
part of initialization. */
3267
if (!srv_use_native_aio) {
3268
goto skip_native_aio;
3271
/* Initialize the io_context array. One io_context
3272
per segment in the array. */
3274
array->aio_ctx = ut_malloc(n_segments *
3275
sizeof(*array->aio_ctx));
3276
for (i = 0; i < n_segments; ++i) {
3277
if (!os_aio_linux_create_io_ctx(n/n_segments,
3278
&array->aio_ctx[i])) {
3279
/* If something bad happened during aio setup
3280
we should call it a day and return right away.
3281
We don't care about any leaks because a failure
3282
to initialize the io subsystem means that the
3283
server (or atleast the innodb storage engine)
3284
is not going to startup. */
3289
/* Initialize the event array. One event per slot. */
3290
io_event = ut_malloc(n * sizeof(*io_event));
3291
memset(io_event, 0x0, sizeof(*io_event) * n);
3292
array->aio_events = io_event;
3295
#endif /* LINUX_NATIVE_AIO */
3296
for (i = 0; i < n; i++) {
3297
slot = os_aio_array_get_nth_slot(array, i);
3300
slot->reserved = FALSE;
3302
slot->handle = CreateEvent(NULL,TRUE, FALSE, NULL);
3304
over = &(slot->control);
3306
over->hEvent = slot->handle;
3308
*((array->handles) + i) = over->hEvent;
3310
#elif defined(LINUX_NATIVE_AIO)
3312
memset(&slot->control, 0x0, sizeof(slot->control));
3321
/************************************************************************//**
3322
Frees an aio wait array. */
3327
os_aio_array_t* array) /*!< in, own: array to free */
3332
for (i = 0; i < array->n_slots; i++) {
3333
os_aio_slot_t* slot = os_aio_array_get_nth_slot(array, i);
3334
CloseHandle(slot->handle);
3336
#endif /* WIN_ASYNC_IO */
3339
ut_free(array->handles);
3340
#endif /* __WIN__ */
3341
os_mutex_free(array->mutex);
3342
os_event_free(array->not_full);
3343
os_event_free(array->is_empty);
3345
#if defined(LINUX_NATIVE_AIO)
3346
if (srv_use_native_aio) {
3347
ut_free(array->aio_events);
3348
ut_free(array->aio_ctx);
3350
#endif /* LINUX_NATIVE_AIO */
3352
ut_free(array->slots);
3356
/***********************************************************************
3357
Initializes the asynchronous io system. Creates one array each for ibuf
3358
and log i/o. Also creates one array each for read and write where each
3359
array is divided logically into n_read_segs and n_write_segs
3360
respectively. The caller must create an i/o handler thread for each
3361
segment in these arrays. This function also creates the sync array.
3362
No i/o handler thread needs to be created for that */
3367
ulint n_per_seg, /*<! in: maximum number of pending aio
3368
operations allowed per segment */
3369
ulint n_read_segs, /*<! in: number of reader threads */
3370
ulint n_write_segs, /*<! in: number of writer threads */
3371
ulint n_slots_sync) /*<! in: number of slots in the sync aio
3375
ulint n_segments = 2 + n_read_segs + n_write_segs;
3377
ut_ad(n_segments >= 4);
3379
os_io_init_simple();
3381
for (i = 0; i < n_segments; i++) {
3382
srv_set_io_thread_op_info(i, "not started yet");
3386
/* fprintf(stderr, "Array n per seg %lu\n", n_per_seg); */
3388
os_aio_ibuf_array = os_aio_array_create(n_per_seg, 1);
3389
if (os_aio_ibuf_array == NULL) {
3393
srv_io_thread_function[0] = "insert buffer thread";
3395
os_aio_log_array = os_aio_array_create(n_per_seg, 1);
3396
if (os_aio_log_array == NULL) {
3400
srv_io_thread_function[1] = "log thread";
3402
os_aio_read_array = os_aio_array_create(n_read_segs * n_per_seg,
3404
if (os_aio_read_array == NULL) {
3408
for (i = 2; i < 2 + n_read_segs; i++) {
3409
ut_a(i < SRV_MAX_N_IO_THREADS);
3410
srv_io_thread_function[i] = "read thread";
3413
os_aio_write_array = os_aio_array_create(n_write_segs * n_per_seg,
3415
if (os_aio_write_array == NULL) {
3419
for (i = 2 + n_read_segs; i < n_segments; i++) {
3420
ut_a(i < SRV_MAX_N_IO_THREADS);
3421
srv_io_thread_function[i] = "write thread";
3424
os_aio_sync_array = os_aio_array_create(n_slots_sync, 1);
3425
if (os_aio_sync_array == NULL) {
3430
os_aio_n_segments = n_segments;
3434
os_aio_segment_wait_events = ut_malloc(n_segments * sizeof(void*));
3436
for (i = 0; i < n_segments; i++) {
3437
os_aio_segment_wait_events[i] = os_event_create(NULL);
3440
os_last_printout = time(NULL);
3449
/***********************************************************************
3450
Frees the asynchronous io system. */
3458
os_aio_array_free(os_aio_ibuf_array);
3459
os_aio_ibuf_array = NULL;
3460
os_aio_array_free(os_aio_log_array);
3461
os_aio_log_array = NULL;
3462
os_aio_array_free(os_aio_read_array);
3463
os_aio_read_array = NULL;
3464
os_aio_array_free(os_aio_write_array);
3465
os_aio_write_array = NULL;
3466
os_aio_array_free(os_aio_sync_array);
3467
os_aio_sync_array = NULL;
3469
for (i = 0; i < os_aio_n_segments; i++) {
3470
os_event_free(os_aio_segment_wait_events[i]);
3473
ut_free(os_aio_segment_wait_events);
3474
os_aio_segment_wait_events = 0;
3475
os_aio_n_segments = 0;
3479
/************************************************************************//**
3480
Wakes up all async i/o threads in the array in Windows async i/o at
3484
os_aio_array_wake_win_aio_at_shutdown(
3485
/*==================================*/
3486
os_aio_array_t* array) /*!< in: aio array */
3490
for (i = 0; i < array->n_slots; i++) {
3492
SetEvent((array->slots + i)->handle);
3497
/************************************************************************//**
3498
Wakes up all async i/o threads so that they know to exit themselves in
3502
os_aio_wake_all_threads_at_shutdown(void)
3503
/*=====================================*/
3508
/* This code wakes up all ai/o threads in Windows native aio */
3509
os_aio_array_wake_win_aio_at_shutdown(os_aio_read_array);
3510
os_aio_array_wake_win_aio_at_shutdown(os_aio_write_array);
3511
os_aio_array_wake_win_aio_at_shutdown(os_aio_ibuf_array);
3512
os_aio_array_wake_win_aio_at_shutdown(os_aio_log_array);
3514
#elif defined(LINUX_NATIVE_AIO)
3516
/* When using native AIO interface the io helper threads
3517
wait on io_getevents with a timeout value of 500ms. At
3518
each wake up these threads check the server status.
3519
No need to do anything to wake them up. */
3521
if (srv_use_native_aio) {
3524
/* Fall through to simulated AIO handler wakeup if we are
3525
not using native AIO. */
3527
/* This loop wakes up all simulated ai/o threads */
3529
for (i = 0; i < os_aio_n_segments; i++) {
3531
os_event_set(os_aio_segment_wait_events[i]);
3535
/************************************************************************//**
3536
Waits until there are no pending writes in os_aio_write_array. There can
3537
be other, synchronous, pending writes. */
3540
os_aio_wait_until_no_pending_writes(void)
3541
/*=====================================*/
3543
os_event_wait(os_aio_write_array->is_empty);
3546
/**********************************************************************//**
3547
Calculates segment number for a slot.
3548
@return segment number (which is the number used by, for example,
3549
i/o-handler threads) */
3552
os_aio_get_segment_no_from_slot(
3553
/*============================*/
3554
os_aio_array_t* array, /*!< in: aio wait array */
3555
os_aio_slot_t* slot) /*!< in: slot in this array */
3560
if (array == os_aio_ibuf_array) {
3563
} else if (array == os_aio_log_array) {
3566
} else if (array == os_aio_read_array) {
3567
seg_len = os_aio_read_array->n_slots
3568
/ os_aio_read_array->n_segments;
3570
segment = 2 + slot->pos / seg_len;
3572
ut_a(array == os_aio_write_array);
3573
seg_len = os_aio_write_array->n_slots
3574
/ os_aio_write_array->n_segments;
3576
segment = os_aio_read_array->n_segments + 2
3577
+ slot->pos / seg_len;
3583
/**********************************************************************//**
3584
Calculates local segment number and aio array from global segment number.
3585
@return local segment number within the aio array */
3588
os_aio_get_array_and_local_segment(
3589
/*===============================*/
3590
os_aio_array_t** array, /*!< out: aio wait array */
3591
ulint global_segment)/*!< in: global segment number */
3595
ut_a(global_segment < os_aio_n_segments);
3597
if (global_segment == 0) {
3598
*array = os_aio_ibuf_array;
3601
} else if (global_segment == 1) {
3602
*array = os_aio_log_array;
3605
} else if (global_segment < os_aio_read_array->n_segments + 2) {
3606
*array = os_aio_read_array;
3608
segment = global_segment - 2;
3610
*array = os_aio_write_array;
3612
segment = global_segment - (os_aio_read_array->n_segments + 2);
3618
/*******************************************************************//**
3619
Requests for a slot in the aio array. If no slot is available, waits until
3620
not_full-event becomes signaled.
3621
@return pointer to slot */
3624
os_aio_array_reserve_slot(
3625
/*======================*/
3626
ulint type, /*!< in: OS_FILE_READ or OS_FILE_WRITE */
3627
os_aio_array_t* array, /*!< in: aio array */
3628
fil_node_t* message1,/*!< in: message to be passed along with
3629
the aio operation */
3630
void* message2,/*!< in: message to be passed along with
3631
the aio operation */
3632
os_file_t file, /*!< in: file handle */
3633
const char* name, /*!< in: name of the file or path as a
3634
null-terminated string */
3635
void* buf, /*!< in: buffer where to read or from which
3637
ulint offset, /*!< in: least significant 32 bits of file
3639
ulint offset_high, /*!< in: most significant 32 bits of
3641
ulint len) /*!< in: length of the block to read or write */
3643
os_aio_slot_t* slot = NULL;
3645
OVERLAPPED* control;
3647
#elif defined(LINUX_NATIVE_AIO)
3655
ulint slots_per_seg;
3659
ut_a((len & 0xFFFFFFFFUL) == len);
3662
/* No need of a mutex. Only reading constant fields */
3663
slots_per_seg = array->n_slots / array->n_segments;
3665
/* We attempt to keep adjacent blocks in the same local
3666
segment. This can help in merging IO requests when we are
3667
doing simulated AIO */
3668
local_seg = (offset >> (UNIV_PAGE_SIZE_SHIFT + 6))
3669
% array->n_segments;
3672
os_mutex_enter(array->mutex);
3674
if (array->n_reserved == array->n_slots) {
3675
os_mutex_exit(array->mutex);
3677
if (!srv_use_native_aio) {
3678
/* If the handler threads are suspended, wake them
3679
so that we get more slots */
3681
os_aio_simulated_wake_handler_threads();
3684
os_event_wait(array->not_full);
3689
/* We start our search for an available slot from our preferred
3690
local segment and do a full scan of the array. We are
3691
guaranteed to find a slot in full scan. */
3692
for (i = local_seg * slots_per_seg, counter = 0;
3693
counter < array->n_slots; i++, counter++) {
3695
i %= array->n_slots;
3696
slot = os_aio_array_get_nth_slot(array, i);
3698
if (slot->reserved == FALSE) {
3703
/* We MUST always be able to get hold of a reserved slot. */
3707
ut_a(slot->reserved == FALSE);
3708
array->n_reserved++;
3710
if (array->n_reserved == 1) {
3711
os_event_reset(array->is_empty);
3714
if (array->n_reserved == array->n_slots) {
3715
os_event_reset(array->not_full);
3718
slot->reserved = TRUE;
3719
slot->reservation_time = time(NULL);
3720
slot->message1 = message1;
3721
slot->message2 = message2;
3727
slot->offset = offset;
3728
slot->offset_high = offset_high;
3729
slot->io_already_done = FALSE;
3732
control = &(slot->control);
3733
control->Offset = (DWORD)offset;
3734
control->OffsetHigh = (DWORD)offset_high;
3735
ResetEvent(slot->handle);
3737
#elif defined(LINUX_NATIVE_AIO)
3739
/* If we are not using native AIO skip this part. */
3740
if (!srv_use_native_aio) {
3741
goto skip_native_aio;
3744
/* Check if we are dealing with 64 bit arch.
3745
If not then make sure that offset fits in 32 bits. */
3746
if (sizeof(aio_offset) == 8) {
3747
aio_offset = offset_high;
3749
aio_offset += offset;
3751
ut_a(offset_high == 0);
3752
aio_offset = offset;
3755
iocb = &slot->control;
3757
if (type == OS_FILE_READ) {
3758
io_prep_pread(iocb, file, buf, len, aio_offset);
3760
ut_a(type == OS_FILE_WRITE);
3761
io_prep_pwrite(iocb, file, buf, len, aio_offset);
3764
iocb->data = (void*)slot;
3767
/*fprintf(stderr, "Filled up Linux native iocb.\n");*/
3771
#endif /* LINUX_NATIVE_AIO */
3772
os_mutex_exit(array->mutex);
3777
/*******************************************************************//**
3778
Frees a slot in the aio array. */
3781
os_aio_array_free_slot(
3782
/*===================*/
3783
os_aio_array_t* array, /*!< in: aio array */
3784
os_aio_slot_t* slot) /*!< in: pointer to slot */
3789
os_mutex_enter(array->mutex);
3791
ut_ad(slot->reserved);
3793
slot->reserved = FALSE;
3795
array->n_reserved--;
3797
if (array->n_reserved == array->n_slots - 1) {
3798
os_event_set(array->not_full);
3801
if (array->n_reserved == 0) {
3802
os_event_set(array->is_empty);
3807
ResetEvent(slot->handle);
3809
#elif defined(LINUX_NATIVE_AIO)
3811
if (srv_use_native_aio) {
3812
memset(&slot->control, 0x0, sizeof(slot->control));
3815
/*fprintf(stderr, "Freed up Linux native slot.\n");*/
3817
/* These fields should not be used if we are not
3818
using native AIO. */
3819
ut_ad(slot->n_bytes == 0);
3820
ut_ad(slot->ret == 0);
3824
os_mutex_exit(array->mutex);
3827
/**********************************************************************//**
3828
Wakes up a simulated aio i/o-handler thread if it has something to do. */
3831
os_aio_simulated_wake_handler_thread(
3832
/*=================================*/
3833
ulint global_segment) /*!< in: the number of the segment in the aio
3836
os_aio_array_t* array;
3837
os_aio_slot_t* slot;
3842
ut_ad(!srv_use_native_aio);
3844
segment = os_aio_get_array_and_local_segment(&array, global_segment);
3846
n = array->n_slots / array->n_segments;
3848
/* Look through n slots after the segment * n'th slot */
3850
os_mutex_enter(array->mutex);
3852
for (i = 0; i < n; i++) {
3853
slot = os_aio_array_get_nth_slot(array, i + segment * n);
3855
if (slot->reserved) {
3856
/* Found an i/o request */
3862
os_mutex_exit(array->mutex);
3865
os_event_set(os_aio_segment_wait_events[global_segment]);
3869
/**********************************************************************//**
3870
Wakes up simulated aio i/o-handler threads if they have something to do. */
3873
os_aio_simulated_wake_handler_threads(void)
3874
/*=======================================*/
3878
if (srv_use_native_aio) {
3879
/* We do not use simulated aio: do nothing */
3884
os_aio_recommend_sleep_for_read_threads = FALSE;
3886
for (i = 0; i < os_aio_n_segments; i++) {
3887
os_aio_simulated_wake_handler_thread(i);
3891
/**********************************************************************//**
3892
This function can be called if one wants to post a batch of reads and
3893
prefers an i/o-handler thread to handle them all at once later. You must
3894
call os_aio_simulated_wake_handler_threads later to ensure the threads
3895
are not left sleeping! */
3898
os_aio_simulated_put_read_threads_to_sleep(void)
3899
/*============================================*/
3902
/* The idea of putting background IO threads to sleep is only for
3903
Windows when using simulated AIO. Windows XP seems to schedule
3904
background threads too eagerly to allow for coalescing during
3905
readahead requests. */
3907
os_aio_array_t* array;
3910
if (srv_use_native_aio) {
3911
/* We do not use simulated aio: do nothing */
3916
os_aio_recommend_sleep_for_read_threads = TRUE;
3918
for (g = 0; g < os_aio_n_segments; g++) {
3919
os_aio_get_array_and_local_segment(&array, g);
3921
if (array == os_aio_read_array) {
3923
os_event_reset(os_aio_segment_wait_events[g]);
3926
#endif /* __WIN__ */
3929
#if defined(LINUX_NATIVE_AIO)
3930
/*******************************************************************//**
3931
Dispatch an AIO request to the kernel.
3932
@return TRUE on success. */
3935
os_aio_linux_dispatch(
3936
/*==================*/
3937
os_aio_array_t* array, /*!< in: io request array. */
3938
os_aio_slot_t* slot) /*!< in: an already reserved slot. */
3944
ut_ad(slot != NULL);
3947
ut_a(slot->reserved);
3949
/* Find out what we are going to work with.
3950
The iocb struct is directly in the slot.
3951
The io_context is one per segment. */
3953
iocb = &slot->control;
3954
io_ctx_index = (slot->pos * array->n_segments) / array->n_slots;
3956
ret = io_submit(array->aio_ctx[io_ctx_index], 1, &iocb);
3958
#if defined(UNIV_AIO_DEBUG)
3960
"io_submit[%c] ret[%d]: slot[%p] ctx[%p] seg[%lu]\n",
3961
(slot->type == OS_FILE_WRITE) ? 'w' : 'r', ret, slot,
3962
array->aio_ctx[io_ctx_index], (ulong)io_ctx_index);
3965
/* io_submit returns number of successfully
3966
queued requests or -errno. */
3967
if (UNIV_UNLIKELY(ret != 1)) {
3974
#endif /* LINUX_NATIVE_AIO */
3977
/*******************************************************************//**
3978
NOTE! Use the corresponding macro os_aio(), not directly this function!
3979
Requests an asynchronous i/o operation.
3980
@return TRUE if request was queued successfully, FALSE if fail */
3985
ulint type, /*!< in: OS_FILE_READ or OS_FILE_WRITE */
3986
ulint mode, /*!< in: OS_AIO_NORMAL, ..., possibly ORed
3987
to OS_AIO_SIMULATED_WAKE_LATER: the
3988
last flag advises this function not to wake
3989
i/o-handler threads, but the caller will
3990
do the waking explicitly later, in this
3991
way the caller can post several requests in
3992
a batch; NOTE that the batch must not be
3993
so big that it exhausts the slots in aio
3994
arrays! NOTE that a simulated batch
3995
may introduce hidden chances of deadlocks,
3996
because i/os are not actually handled until
3997
all have been posted: use with great
3999
const char* name, /*!< in: name of the file or path as a
4000
null-terminated string */
4001
os_file_t file, /*!< in: handle to a file */
4002
void* buf, /*!< in: buffer where to read or from which
4004
ulint offset, /*!< in: least significant 32 bits of file
4005
offset where to read or write */
4006
ulint offset_high, /*!< in: most significant 32 bits of
4008
ulint n, /*!< in: number of bytes to read or write */
4009
fil_node_t* message1,/*!< in: message for the aio handler
4010
(can be used to identify a completed
4011
aio operation); ignored if mode is
4013
void* message2)/*!< in: message for the aio handler
4014
(can be used to identify a completed
4015
aio operation); ignored if mode is
4018
os_aio_array_t* array;
4019
os_aio_slot_t* slot;
4023
DWORD len = (DWORD) n;
4024
struct fil_node_struct * dummy_mess1;
4027
#endif /* WIN_ASYNC_IO */
4034
ut_ad(n % OS_FILE_LOG_BLOCK_SIZE == 0);
4035
ut_ad(offset % OS_FILE_LOG_BLOCK_SIZE == 0);
4036
ut_ad(os_aio_validate_skip());
4038
ut_ad((n & 0xFFFFFFFFUL) == n);
4041
wake_later = mode & OS_AIO_SIMULATED_WAKE_LATER;
4042
mode = mode & (~OS_AIO_SIMULATED_WAKE_LATER);
4044
if (mode == OS_AIO_SYNC
4046
&& !srv_use_native_aio
4047
#endif /* WIN_ASYNC_IO */
4049
/* This is actually an ordinary synchronous read or write:
4050
no need to use an i/o-handler thread. NOTE that if we use
4051
Windows async i/o, Windows does not allow us to use
4052
ordinary synchronous os_file_read etc. on the same file,
4053
therefore we have built a special mechanism for synchronous
4054
wait in the Windows case.
4055
Also note that the Performance Schema instrumentation has
4056
been performed by current os_aio_func()'s wrapper function
4057
pfs_os_aio_func(). So we would no longer need to call
4058
Performance Schema instrumented os_file_read() and
4059
os_file_write(). Instead, we should use os_file_read_func()
4060
and os_file_write_func() */
4062
if (type == OS_FILE_READ) {
4063
return(os_file_read_func(file, buf, offset,
4067
ut_a(type == OS_FILE_WRITE);
4069
return(os_file_write_func(name, file, buf, offset,
4076
array = (type == OS_FILE_READ)
4078
: os_aio_write_array;
4081
ut_ad(type == OS_FILE_READ);
4082
/* Reduce probability of deadlock bugs in connection with ibuf:
4083
do not let the ibuf i/o handler sleep */
4087
array = os_aio_ibuf_array;
4090
array = os_aio_log_array;
4093
array = os_aio_sync_array;
4095
#if defined(LINUX_NATIVE_AIO)
4096
/* In Linux native AIO we don't use sync IO array. */
4097
ut_a(!srv_use_native_aio);
4098
#endif /* LINUX_NATIVE_AIO */
4102
array = NULL; /* Eliminate compiler warning */
4105
slot = os_aio_array_reserve_slot(type, array, message1, message2, file,
4106
name, buf, offset, offset_high, n);
4107
if (type == OS_FILE_READ) {
4108
if (srv_use_native_aio) {
4110
os_bytes_read_since_printout += n;
4112
ret = ReadFile(file, buf, (DWORD)n, &len,
4115
#elif defined(LINUX_NATIVE_AIO)
4116
if (!os_aio_linux_dispatch(array, slot)) {
4122
os_aio_simulated_wake_handler_thread(
4123
os_aio_get_segment_no_from_slot(
4127
} else if (type == OS_FILE_WRITE) {
4128
if (srv_use_native_aio) {
4131
ret = WriteFile(file, buf, (DWORD)n, &len,
4134
#elif defined(LINUX_NATIVE_AIO)
4135
if (!os_aio_linux_dispatch(array, slot)) {
4141
os_aio_simulated_wake_handler_thread(
4142
os_aio_get_segment_no_from_slot(
4151
if (srv_use_native_aio) {
4152
if ((ret && len == n)
4153
|| (!ret && GetLastError() == ERROR_IO_PENDING)) {
4154
/* aio was queued successfully! */
4156
if (mode == OS_AIO_SYNC) {
4157
/* We want a synchronous i/o operation on a
4158
file where we also use async i/o: in Windows
4159
we must use the same wait mechanism as for
4162
retval = os_aio_windows_handle(ULINT_UNDEFINED,
4176
#endif /* WIN_ASYNC_IO */
4177
/* aio was queued successfully! */
4180
#if defined LINUX_NATIVE_AIO || defined WIN_ASYNC_IO
4182
#endif /* LINUX_NATIVE_AIO || WIN_ASYNC_IO */
4183
os_aio_array_free_slot(array, slot);
4185
retry = os_file_handle_error(name,
4186
type == OS_FILE_READ
4187
? "aio read" : "aio write");
4197
/**********************************************************************//**
4198
This function is only used in Windows asynchronous i/o.
4199
Waits for an aio operation to complete. This function is used to wait the
4200
for completed requests. The aio array of pending requests is divided
4201
into segments. The thread specifies which segment or slot it wants to wait
4202
for. NOTE: this function will also take care of freeing the aio slot,
4203
therefore no other thread is allowed to do the freeing!
4204
@return TRUE if the aio operation succeeded */
4207
os_aio_windows_handle(
4208
/*==================*/
4209
ulint segment, /*!< in: the number of the segment in the aio
4210
arrays to wait for; segment 0 is the ibuf
4211
i/o thread, segment 1 the log i/o thread,
4212
then follow the non-ibuf read threads, and as
4213
the last are the non-ibuf write threads; if
4214
this is ULINT_UNDEFINED, then it means that
4215
sync aio is used, and this parameter is
4217
ulint pos, /*!< this parameter is used only in sync aio:
4218
wait for the aio slot at this position */
4219
fil_node_t**message1, /*!< out: the messages passed with the aio
4220
request; note that also in the case where
4221
the aio operation failed, these output
4222
parameters are valid and can be used to
4223
restart the operation, for example */
4225
ulint* type) /*!< out: OS_FILE_WRITE or ..._READ */
4227
ulint orig_seg = segment;
4228
os_aio_array_t* array;
4229
os_aio_slot_t* slot;
4237
if (segment == ULINT_UNDEFINED) {
4238
array = os_aio_sync_array;
4241
segment = os_aio_get_array_and_local_segment(&array, segment);
4244
/* NOTE! We only access constant fields in os_aio_array. Therefore
4245
we do not have to acquire the protecting mutex yet */
4247
ut_ad(os_aio_validate_skip());
4248
ut_ad(segment < array->n_segments);
4250
n = array->n_slots / array->n_segments;
4252
if (array == os_aio_sync_array) {
4253
WaitForSingleObject(
4254
os_aio_array_get_nth_slot(array, pos)->handle,
4258
srv_set_io_thread_op_info(orig_seg, "wait Windows aio");
4259
i = WaitForMultipleObjects((DWORD) n,
4260
array->handles + segment * n,
4265
os_mutex_enter(array->mutex);
4267
if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS
4268
&& array->n_reserved == 0) {
4271
os_mutex_exit(array->mutex);
4275
ut_a(i >= WAIT_OBJECT_0 && i <= WAIT_OBJECT_0 + n);
4277
slot = os_aio_array_get_nth_slot(array, i + segment * n);
4279
ut_a(slot->reserved);
4281
if (orig_seg != ULINT_UNDEFINED) {
4282
srv_set_io_thread_op_info(orig_seg,
4283
"get windows aio return value");
4286
ret = GetOverlappedResult(slot->file, &(slot->control), &len, TRUE);
4288
*message1 = slot->message1;
4289
*message2 = slot->message2;
4293
if (ret && len == slot->len) {
4296
#ifdef UNIV_DO_FLUSH
4297
if (slot->type == OS_FILE_WRITE
4298
&& !os_do_not_call_flush_at_each_write) {
4299
if (!os_file_flush(slot->file)) {
4303
#endif /* UNIV_DO_FLUSH */
4304
} else if (os_file_handle_error(slot->name, "Windows aio")) {
4312
os_mutex_exit(array->mutex);
4315
/* retry failed read/write operation synchronously.
4316
No need to hold array->mutex. */
4319
/* This read/write does not go through os_file_read
4320
and os_file_write APIs, need to register with
4321
performance schema explicitly here. */
4322
struct PSI_file_locker* locker = NULL;
4323
register_pfs_file_io_begin(locker, slot->file, slot->len,
4324
(slot->type == OS_FILE_WRITE)
4327
__FILE__, __LINE__);
4330
ut_a((slot->len & 0xFFFFFFFFUL) == slot->len);
4332
switch (slot->type) {
4334
ret = WriteFile(slot->file, slot->buf,
4335
(DWORD) slot->len, &len,
4340
ret = ReadFile(slot->file, slot->buf,
4341
(DWORD) slot->len, &len,
4350
register_pfs_file_io_end(locker, len);
4353
if (!ret && GetLastError() == ERROR_IO_PENDING) {
4354
/* aio was queued successfully!
4355
We want a synchronous i/o operation on a
4356
file where we also use async i/o: in Windows
4357
we must use the same wait mechanism as for
4360
ret = GetOverlappedResult(slot->file,
4365
ret_val = ret && len == slot->len;
4368
os_aio_array_free_slot(array, slot);
4374
#if defined(LINUX_NATIVE_AIO)
4375
/******************************************************************//**
4376
This function is only used in Linux native asynchronous i/o. This is
4377
called from within the io-thread. If there are no completed IO requests
4378
in the slot array, the thread calls this function to collect more
4379
requests from the kernel.
4380
The io-thread waits on io_getevents(), which is a blocking call, with
4381
a timeout value. Unless the system is very heavy loaded, keeping the
4382
io-thread very busy, the io-thread will spend most of its time waiting
4384
The io-thread also exits in this function. It checks server status at
4385
each wakeup and that is why we use timed wait in io_getevents(). */
4388
os_aio_linux_collect(
4389
/*=================*/
4390
os_aio_array_t* array, /*!< in/out: slot array. */
4391
ulint segment, /*!< in: local segment no. */
4392
ulint seg_size) /*!< in: segment size. */
4398
struct timespec timeout;
4399
struct io_event* events;
4400
struct io_context* io_ctx;
4402
/* sanity checks. */
4403
ut_ad(array != NULL);
4404
ut_ad(seg_size > 0);
4405
ut_ad(segment < array->n_segments);
4407
/* Which part of event array we are going to work on. */
4408
events = &array->aio_events[segment * seg_size];
4410
/* Which io_context we are going to use. */
4411
io_ctx = array->aio_ctx[segment];
4413
/* Starting point of the segment we will be working on. */
4414
start_pos = segment * seg_size;
4417
end_pos = start_pos + seg_size;
4421
/* Initialize the events. The timeout value is arbitrary.
4422
We probably need to experiment with it a little. */
4423
memset(events, 0, sizeof(*events) * seg_size);
4425
timeout.tv_nsec = OS_AIO_REAP_TIMEOUT;
4427
ret = io_getevents(io_ctx, 1, seg_size, events, &timeout);
4430
for (i = 0; i < ret; i++) {
4431
os_aio_slot_t* slot;
4432
struct iocb* control;
4434
control = (struct iocb *)events[i].obj;
4435
ut_a(control != NULL);
4437
slot = (os_aio_slot_t *) control->data;
4439
/* Some sanity checks. */
4441
ut_a(slot->reserved);
4443
#if defined(UNIV_AIO_DEBUG)
4445
"io_getevents[%c]: slot[%p] ctx[%p]"
4447
(slot->type == OS_FILE_WRITE) ? 'w' : 'r',
4448
slot, io_ctx, segment);
4451
/* We are not scribbling previous segment. */
4452
ut_a(slot->pos >= start_pos);
4454
/* We have not overstepped to next segment. */
4455
ut_a(slot->pos < end_pos);
4457
/* Mark this request as completed. The error handling
4458
will be done in the calling function. */
4459
os_mutex_enter(array->mutex);
4460
slot->n_bytes = events[i].res;
4461
slot->ret = events[i].res2;
4462
slot->io_already_done = TRUE;
4463
os_mutex_exit(array->mutex);
4468
if (UNIV_UNLIKELY(srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS)) {
4472
/* This error handling is for any error in collecting the
4473
IO requests. The errors, if any, for any particular IO
4474
request are simply passed on to the calling routine. */
4478
/* Not enough resources! Try again. */
4480
/* Interrupted! I have tested the behaviour in case of an
4481
interrupt. If we have some completed IOs available then
4482
the return code will be the number of IOs. We get EINTR only
4483
if there are no completed IOs and we have been interrupted. */
4485
/* No pending request! Go back and check again. */
4489
/* All other errors should cause a trap for now. */
4490
ut_print_timestamp(stderr);
4492
" InnoDB: unexpected ret_code[%d] from io_getevents()!\n",
4497
/**********************************************************************//**
4498
This function is only used in Linux native asynchronous i/o.
4499
Waits for an aio operation to complete. This function is used to wait for
4500
the completed requests. The aio array of pending requests is divided
4501
into segments. The thread specifies which segment or slot it wants to wait
4502
for. NOTE: this function will also take care of freeing the aio slot,
4503
therefore no other thread is allowed to do the freeing!
4504
@return TRUE if the IO was successful */
4507
os_aio_linux_handle(
4508
/*================*/
4509
ulint global_seg, /*!< in: segment number in the aio array
4510
to wait for; segment 0 is the ibuf
4511
i/o thread, segment 1 is log i/o thread,
4512
then follow the non-ibuf read threads,
4513
and the last are the non-ibuf write
4515
fil_node_t**message1, /*!< out: the messages passed with the */
4516
void** message2, /*!< aio request; note that in case the
4517
aio operation failed, these output
4518
parameters are valid and can be used to
4519
restart the operation. */
4520
ulint* type) /*!< out: OS_FILE_WRITE or ..._READ */
4523
os_aio_array_t* array;
4524
os_aio_slot_t* slot;
4529
/* Should never be doing Sync IO here. */
4530
ut_a(global_seg != ULINT_UNDEFINED);
4532
/* Find the array and the local segment. */
4533
segment = os_aio_get_array_and_local_segment(&array, global_seg);
4534
n = array->n_slots / array->n_segments;
4536
/* Loop until we have found a completed request. */
4538
ibool any_reserved = FALSE;
4539
os_mutex_enter(array->mutex);
4540
for (i = 0; i < n; ++i) {
4541
slot = os_aio_array_get_nth_slot(
4542
array, i + segment * n);
4543
if (!slot->reserved) {
4545
} else if (slot->io_already_done) {
4546
/* Something for us to work on. */
4549
any_reserved = TRUE;
4553
os_mutex_exit(array->mutex);
4555
/* There is no completed request.
4556
If there is no pending request at all,
4557
and the system is being shut down, exit. */
4560
&& srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS)) {
4566
/* Wait for some request. Note that we return
4567
from wait iff we have found a request. */
4569
srv_set_io_thread_op_info(global_seg,
4570
"waiting for completed aio requests");
4571
os_aio_linux_collect(array, segment, n);
4575
/* Note that it may be that there are more then one completed
4576
IO requests. We process them one at a time. We may have a case
4577
here to improve the performance slightly by dealing with all
4578
requests in one sweep. */
4579
srv_set_io_thread_op_info(global_seg,
4580
"processing completed aio requests");
4582
/* Ensure that we are scribbling only our segment. */
4585
ut_ad(slot != NULL);
4586
ut_ad(slot->reserved);
4587
ut_ad(slot->io_already_done);
4589
*message1 = slot->message1;
4590
*message2 = slot->message2;
4594
if ((slot->ret == 0) && (slot->n_bytes == (long)slot->len)) {
4597
#ifdef UNIV_DO_FLUSH
4598
if (slot->type == OS_FILE_WRITE
4599
&& !os_do_not_call_flush_at_each_write)
4600
&& !os_file_flush(slot->file) {
4603
#endif /* UNIV_DO_FLUSH */
4607
/* os_file_handle_error does tell us if we should retry
4608
this IO. As it stands now, we don't do this retry when
4609
reaping requests from a different context than
4610
the dispatcher. This non-retry logic is the same for
4611
windows and linux native AIO.
4612
We should probably look into this to transparently
4613
re-submit the IO. */
4614
os_file_handle_error(slot->name, "Linux aio");
4619
os_mutex_exit(array->mutex);
4621
os_aio_array_free_slot(array, slot);
4625
#endif /* LINUX_NATIVE_AIO */
4627
/**********************************************************************//**
4628
Does simulated aio. This function should be called by an i/o-handler
4630
@return TRUE if the aio operation succeeded */
4633
os_aio_simulated_handle(
4634
/*====================*/
4635
ulint global_segment, /*!< in: the number of the segment in the aio
4636
arrays to wait for; segment 0 is the ibuf
4637
i/o thread, segment 1 the log i/o thread,
4638
then follow the non-ibuf read threads, and as
4639
the last are the non-ibuf write threads */
4640
fil_node_t**message1, /*!< out: the messages passed with the aio
4641
request; note that also in the case where
4642
the aio operation failed, these output
4643
parameters are valid and can be used to
4644
restart the operation, for example */
4646
ulint* type) /*!< out: OS_FILE_WRITE or ..._READ */
4648
os_aio_array_t* array;
4650
os_aio_slot_t* slot;
4651
os_aio_slot_t* slot2;
4652
os_aio_slot_t* consecutive_ios[OS_AIO_MERGE_N_CONSECUTIVE];
4653
ulint n_consecutive;
4656
ulint lowest_offset;
4660
byte* combined_buf2;
4666
/* Fix compiler warning */
4667
*consecutive_ios = NULL;
4669
segment = os_aio_get_array_and_local_segment(&array, global_segment);
4672
/* NOTE! We only access constant fields in os_aio_array. Therefore
4673
we do not have to acquire the protecting mutex yet */
4675
srv_set_io_thread_op_info(global_segment,
4676
"looking for i/o requests (a)");
4677
ut_ad(os_aio_validate_skip());
4678
ut_ad(segment < array->n_segments);
4680
n = array->n_slots / array->n_segments;
4682
/* Look through n slots after the segment * n'th slot */
4684
if (array == os_aio_read_array
4685
&& os_aio_recommend_sleep_for_read_threads) {
4687
/* Give other threads chance to add several i/os to the array
4690
goto recommended_sleep;
4693
srv_set_io_thread_op_info(global_segment,
4694
"looking for i/o requests (b)");
4696
/* Check if there is a slot for which the i/o has already been
4698
any_reserved = FALSE;
4700
os_mutex_enter(array->mutex);
4702
for (i = 0; i < n; i++) {
4703
slot = os_aio_array_get_nth_slot(array, i + segment * n);
4705
if (!slot->reserved) {
4707
} else if (slot->io_already_done) {
4709
if (os_aio_print_debug) {
4711
"InnoDB: i/o for slot %lu"
4712
" already done, returning\n",
4720
any_reserved = TRUE;
4724
/* There is no completed request.
4725
If there is no pending request at all,
4726
and the system is being shut down, exit. */
4729
&& srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS)) {
4730
os_mutex_exit(array->mutex);
4738
/* If there are at least 2 seconds old requests, then pick the oldest
4739
one to prevent starvation. If several requests have the same age,
4740
then pick the one at the lowest offset. */
4743
lowest_offset = ULINT_MAX;
4745
for (i = 0; i < n; i++) {
4746
slot = os_aio_array_get_nth_slot(array, i + segment * n);
4748
if (slot->reserved) {
4749
age = (ulint)difftime(time(NULL),
4750
slot->reservation_time);
4752
if ((age >= 2 && age > biggest_age)
4753
|| (age >= 2 && age == biggest_age
4754
&& slot->offset < lowest_offset)) {
4756
/* Found an i/o request */
4757
consecutive_ios[0] = slot;
4762
lowest_offset = slot->offset;
4767
if (n_consecutive == 0) {
4768
/* There were no old requests. Look for an i/o request at the
4769
lowest offset in the array (we ignore the high 32 bits of the
4770
offset in these heuristics) */
4772
lowest_offset = ULINT_MAX;
4774
for (i = 0; i < n; i++) {
4775
slot = os_aio_array_get_nth_slot(array,
4778
if (slot->reserved && slot->offset < lowest_offset) {
4780
/* Found an i/o request */
4781
consecutive_ios[0] = slot;
4785
lowest_offset = slot->offset;
4790
if (n_consecutive == 0) {
4792
/* No i/o requested at the moment */
4797
/* if n_consecutive != 0, then we have assigned
4798
something valid to consecutive_ios[0] */
4799
ut_ad(n_consecutive != 0);
4800
ut_ad(consecutive_ios[0] != NULL);
4802
slot = consecutive_ios[0];
4804
/* Check if there are several consecutive blocks to read or write */
4807
for (i = 0; i < n; i++) {
4808
slot2 = os_aio_array_get_nth_slot(array, i + segment * n);
4810
if (slot2->reserved && slot2 != slot
4811
&& slot2->offset == slot->offset + slot->len
4812
/* check that sum does not wrap over */
4813
&& slot->offset + slot->len > slot->offset
4814
&& slot2->offset_high == slot->offset_high
4815
&& slot2->type == slot->type
4816
&& slot2->file == slot->file) {
4818
/* Found a consecutive i/o request */
4820
consecutive_ios[n_consecutive] = slot2;
4825
if (n_consecutive < OS_AIO_MERGE_N_CONSECUTIVE) {
4827
goto consecutive_loop;
4834
srv_set_io_thread_op_info(global_segment, "consecutive i/o requests");
4836
/* We have now collected n_consecutive i/o requests in the array;
4837
allocate a single buffer which can hold all data, and perform the
4841
slot = consecutive_ios[0];
4843
for (i = 0; i < n_consecutive; i++) {
4844
total_len += consecutive_ios[i]->len;
4847
if (n_consecutive == 1) {
4848
/* We can use the buffer of the i/o request */
4849
combined_buf = slot->buf;
4850
combined_buf2 = NULL;
4852
combined_buf2 = ut_malloc(total_len + UNIV_PAGE_SIZE);
4854
ut_a(combined_buf2);
4856
combined_buf = ut_align(combined_buf2, UNIV_PAGE_SIZE);
4859
/* We release the array mutex for the time of the i/o: NOTE that
4860
this assumes that there is just one i/o-handler thread serving
4861
a single segment of slots! */
4863
os_mutex_exit(array->mutex);
4865
if (slot->type == OS_FILE_WRITE && n_consecutive > 1) {
4866
/* Copy the buffers to the combined buffer */
4869
for (i = 0; i < n_consecutive; i++) {
4871
ut_memcpy(combined_buf + offs, consecutive_ios[i]->buf,
4872
consecutive_ios[i]->len);
4873
offs += consecutive_ios[i]->len;
4877
srv_set_io_thread_op_info(global_segment, "doing file i/o");
4879
if (os_aio_print_debug) {
4881
"InnoDB: doing i/o of type %lu at offset %lu %lu,"
4883
(ulong) slot->type, (ulong) slot->offset_high,
4884
(ulong) slot->offset, (ulong) total_len);
4887
/* Do the i/o with ordinary, synchronous i/o functions: */
4888
if (slot->type == OS_FILE_WRITE) {
4889
ret = os_file_write(slot->name, slot->file, combined_buf,
4890
slot->offset, slot->offset_high,
4893
ret = os_file_read(slot->file, combined_buf,
4894
slot->offset, slot->offset_high, total_len);
4898
srv_set_io_thread_op_info(global_segment, "file i/o done");
4902
"aio: %lu consecutive %lu:th segment, first offs %lu blocks\n",
4903
n_consecutive, global_segment, slot->offset / UNIV_PAGE_SIZE);
4906
if (slot->type == OS_FILE_READ && n_consecutive > 1) {
4907
/* Copy the combined buffer to individual buffers */
4910
for (i = 0; i < n_consecutive; i++) {
4912
ut_memcpy(consecutive_ios[i]->buf, combined_buf + offs,
4913
consecutive_ios[i]->len);
4914
offs += consecutive_ios[i]->len;
4918
if (combined_buf2) {
4919
ut_free(combined_buf2);
4922
os_mutex_enter(array->mutex);
4924
/* Mark the i/os done in slots */
4926
for (i = 0; i < n_consecutive; i++) {
4927
consecutive_ios[i]->io_already_done = TRUE;
4930
/* We return the messages for the first slot now, and if there were
4931
several slots, the messages will be returned with subsequent calls
4936
ut_a(slot->reserved);
4938
*message1 = slot->message1;
4939
*message2 = slot->message2;
4943
os_mutex_exit(array->mutex);
4945
os_aio_array_free_slot(array, slot);
4950
srv_set_io_thread_op_info(global_segment, "resetting wait event");
4952
/* We wait here until there again can be i/os in the segment
4955
os_event_reset(os_aio_segment_wait_events[global_segment]);
4957
os_mutex_exit(array->mutex);
4960
srv_set_io_thread_op_info(global_segment, "waiting for i/o request");
4962
os_event_wait(os_aio_segment_wait_events[global_segment]);
4964
if (os_aio_print_debug) {
4966
"InnoDB: i/o handler thread for i/o"
4967
" segment %lu wakes up\n",
4968
(ulong) global_segment);
4974
/**********************************************************************//**
4975
Validates the consistency of an aio array.
4976
@return TRUE if ok */
4979
os_aio_array_validate(
4980
/*==================*/
4981
os_aio_array_t* array) /*!< in: aio wait array */
4983
os_aio_slot_t* slot;
4984
ulint n_reserved = 0;
4989
os_mutex_enter(array->mutex);
4991
ut_a(array->n_slots > 0);
4992
ut_a(array->n_segments > 0);
4994
for (i = 0; i < array->n_slots; i++) {
4995
slot = os_aio_array_get_nth_slot(array, i);
4997
if (slot->reserved) {
4999
ut_a(slot->len > 0);
5003
ut_a(array->n_reserved == n_reserved);
5005
os_mutex_exit(array->mutex);
5010
/**********************************************************************//**
5011
Validates the consistency the aio system.
5012
@return TRUE if ok */
5015
os_aio_validate(void)
5016
/*=================*/
5018
os_aio_array_validate(os_aio_read_array);
5019
os_aio_array_validate(os_aio_write_array);
5020
os_aio_array_validate(os_aio_ibuf_array);
5021
os_aio_array_validate(os_aio_log_array);
5022
os_aio_array_validate(os_aio_sync_array);
5027
/**********************************************************************//**
5028
Prints pending IO requests per segment of an aio array.
5029
We probably don't need per segment statistics but they can help us
5030
during development phase to see if the IO requests are being
5031
distributed as expected. */
5034
os_aio_print_segment_info(
5035
/*======================*/
5036
FILE* file, /*!< in: file where to print */
5037
ulint* n_seg, /*!< in: pending IO array */
5038
os_aio_array_t* array) /*!< in: array to process */
5044
ut_ad(array->n_segments > 0);
5046
if (array->n_segments == 1) {
5050
fprintf(file, " [");
5051
for (i = 0; i < array->n_segments; i++) {
5053
fprintf(file, ", ");
5056
fprintf(file, "%lu", n_seg[i]);
5058
fprintf(file, "] ");
5061
/**********************************************************************//**
5062
Prints info of the aio arrays. */
5067
FILE* file) /*!< in: file where to print */
5069
os_aio_array_t* array;
5070
os_aio_slot_t* slot;
5072
ulint n_res_seg[SRV_MAX_N_IO_THREADS];
5073
time_t current_time;
5074
double time_elapsed;
5075
double avg_bytes_read;
5078
for (i = 0; i < srv_n_file_io_threads; i++) {
5079
fprintf(file, "I/O thread %lu state: %s (%s)", (ulong) i,
5080
srv_io_thread_op_info[i],
5081
srv_io_thread_function[i]);
5084
if (os_aio_segment_wait_events[i]->is_set) {
5085
fprintf(file, " ev set");
5089
fprintf(file, "\n");
5092
fputs("Pending normal aio reads:", file);
5094
array = os_aio_read_array;
5098
os_mutex_enter(array->mutex);
5100
ut_a(array->n_slots > 0);
5101
ut_a(array->n_segments > 0);
5105
memset(n_res_seg, 0x0, sizeof(n_res_seg));
5107
for (i = 0; i < array->n_slots; i++) {
5110
slot = os_aio_array_get_nth_slot(array, i);
5112
seg_no = (i * array->n_segments) / array->n_slots;
5113
if (slot->reserved) {
5115
n_res_seg[seg_no]++;
5117
fprintf(stderr, "Reserved slot, messages %p %p\n",
5118
(void*) slot->message1,
5119
(void*) slot->message2);
5121
ut_a(slot->len > 0);
5125
ut_a(array->n_reserved == n_reserved);
5127
fprintf(file, " %lu", (ulong) n_reserved);
5129
os_aio_print_segment_info(file, n_res_seg, array);
5131
os_mutex_exit(array->mutex);
5133
if (array == os_aio_read_array) {
5134
fputs(", aio writes:", file);
5136
array = os_aio_write_array;
5141
if (array == os_aio_write_array) {
5142
fputs(",\n ibuf aio reads:", file);
5143
array = os_aio_ibuf_array;
5148
if (array == os_aio_ibuf_array) {
5149
fputs(", log i/o's:", file);
5150
array = os_aio_log_array;
5155
if (array == os_aio_log_array) {
5156
fputs(", sync i/o's:", file);
5157
array = os_aio_sync_array;
5163
current_time = time(NULL);
5164
time_elapsed = 0.001 + difftime(current_time, os_last_printout);
5167
"Pending flushes (fsync) log: %lu; buffer pool: %lu\n"
5168
"%lu OS file reads, %lu OS file writes, %lu OS fsyncs\n",
5169
(ulong) fil_n_pending_log_flushes,
5170
(ulong) fil_n_pending_tablespace_flushes,
5171
(ulong) os_n_file_reads, (ulong) os_n_file_writes,
5172
(ulong) os_n_fsyncs);
5174
if (os_file_n_pending_preads != 0 || os_file_n_pending_pwrites != 0) {
5176
"%lu pending preads, %lu pending pwrites\n",
5177
(ulong) os_file_n_pending_preads,
5178
(ulong) os_file_n_pending_pwrites);
5181
if (os_n_file_reads == os_n_file_reads_old) {
5182
avg_bytes_read = 0.0;
5184
avg_bytes_read = (double) os_bytes_read_since_printout
5185
/ (os_n_file_reads - os_n_file_reads_old);
5189
"%.2f reads/s, %lu avg bytes/read,"
5190
" %.2f writes/s, %.2f fsyncs/s\n",
5191
(os_n_file_reads - os_n_file_reads_old)
5193
(ulong)avg_bytes_read,
5194
(os_n_file_writes - os_n_file_writes_old)
5196
(os_n_fsyncs - os_n_fsyncs_old)
5199
os_n_file_reads_old = os_n_file_reads;
5200
os_n_file_writes_old = os_n_file_writes;
5201
os_n_fsyncs_old = os_n_fsyncs;
5202
os_bytes_read_since_printout = 0;
5204
os_last_printout = current_time;
5207
/**********************************************************************//**
5208
Refreshes the statistics used to print per-second averages. */
5211
os_aio_refresh_stats(void)
5212
/*======================*/
5214
os_n_file_reads_old = os_n_file_reads;
5215
os_n_file_writes_old = os_n_file_writes;
5216
os_n_fsyncs_old = os_n_fsyncs;
5217
os_bytes_read_since_printout = 0;
5219
os_last_printout = time(NULL);
5223
/**********************************************************************//**
5224
Checks that all slots in the system have been freed, that is, there are
5225
no pending io operations.
5226
@return TRUE if all free */
5229
os_aio_all_slots_free(void)
5230
/*=======================*/
5232
os_aio_array_t* array;
5235
array = os_aio_read_array;
5237
os_mutex_enter(array->mutex);
5239
n_res += array->n_reserved;
5241
os_mutex_exit(array->mutex);
5243
array = os_aio_write_array;
5245
os_mutex_enter(array->mutex);
5247
n_res += array->n_reserved;
5249
os_mutex_exit(array->mutex);
5251
array = os_aio_ibuf_array;
5253
os_mutex_enter(array->mutex);
5255
n_res += array->n_reserved;
5257
os_mutex_exit(array->mutex);
5259
array = os_aio_log_array;
5261
os_mutex_enter(array->mutex);
5263
n_res += array->n_reserved;
5265
os_mutex_exit(array->mutex);
5267
array = os_aio_sync_array;
5269
os_mutex_enter(array->mutex);
5271
n_res += array->n_reserved;
5273
os_mutex_exit(array->mutex);
5282
#endif /* UNIV_DEBUG */
5284
#endif /* !UNIV_HOTBACKUP */
added
removed
storage/innobase/os/os0file.c
