« back to all changes in this revision
Viewing changes to storage/innobase/os/os0file.c
- browse files at revision 641.2.3
- compare with another revision
- compare with revision 2165.1.3
- download diff
- download tarball
- view history from revision 641.2.3
- Committer: Monty Taylor
- Date: 2009-08-12 06:25:19 UTC
- mto: (1114.1.1 innodb-plugin-merge)
- mto: This revision was merged to the branch mainline in revision 1183.
- Revision ID: mordred@inaugust.com-20090812062519-cij02mrrunvnxblt
Tags: innodb-plugin-1.0.4
InnoDB Plugin 1.0.4
- files added:
- storage/innobase/COPYING.Percona
- files removed:
- storage/innobase/mysql-test/patches/bug32625.diff
- files modified:
- storage/innobase/CMakeLists.txt
added
removed
storage/innobase/os/os0file.c
15
15
Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
*****************************************************************************/
18
19
/******************************************************
18
/***********************************************************************
19
20
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
21
Copyright (c) 2009, Percona Inc.
22
23
Portions of this file contain modifications contributed and copyrighted
24
by Percona Inc.. Those modifications are
25
gratefully acknowledged and are described briefly in the InnoDB
26
documentation. The contributions by Percona Inc. are incorporated with
27
their permission, and subject to the conditions contained in the file
28
COPYING.Percona.
29
30
This program is free software; you can redistribute it and/or modify it
31
under the terms of the GNU General Public License as published by the
32
Free Software Foundation; version 2 of the License.
33
34
This program is distributed in the hope that it will be useful, but
35
WITHOUT ANY WARRANTY; without even the implied warranty of
36
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
37
Public License for more details.
38
39
You should have received a copy of the GNU General Public License along
40
with this program; if not, write to the Free Software Foundation, Inc.,
41
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
42
43
***********************************************************************/
44
45
/**************************************************//**
46
@file os/os0file.c
20
47
The interface to the operating system file i/o primitives
21
48
22
49
Created 10/21/1995 Heikki Tuuri
23
50
*******************************************************/
24
51
25
52
#include "os0file.h"
26
#include "os0sync.h"
27
#include "os0thread.h"
28
53
#include "ut0mem.h"
29
54
#include "srv0srv.h"
30
55
#include "srv0start.h"
31
56
#include "fil0fil.h"
32
57
#include "buf0buf.h"
33
34
#if defined(UNIV_HOTBACKUP) && defined(__WIN__)
58
#ifndef UNIV_HOTBACKUP
59
# include "os0sync.h"
60
# include "os0thread.h"
61
#else /* !UNIV_HOTBACKUP */
62
# ifdef __WIN__
35
63
/* Add includes for the _stat() call to compile on Windows */
36
#include <sys/types.h>
37
#include <sys/stat.h>
38
#include <errno.h>
39
#endif /* UNIV_HOTBACKUP */
64
# include <sys/types.h>
65
# include <sys/stat.h>
66
# include <errno.h>
67
# endif /* __WIN__ */
68
#endif /* !UNIV_HOTBACKUP */
40
69
41
70
/* This specifies the file permissions InnoDB uses when it creates files in
42
71
Unix; the value of os_innodb_umask is initialized in ha_innodb.cc to
43
72
my_umask */
44
73
45
74
#ifndef __WIN__
75
/** Umask for creating files */
46
76
UNIV_INTERN ulint os_innodb_umask
47
77
= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
48
78
#else
79
/** Umask for creating files */
49
80
UNIV_INTERN ulint os_innodb_umask = 0;
50
81
#endif
51
82
57
88
/* We do not call os_file_flush in every os_file_write. */
58
89
#endif /* UNIV_DO_FLUSH */
59
90
91
#ifndef UNIV_HOTBACKUP
60
92
/* We use these mutexes to protect lseek + file i/o operation, if the
61
93
OS does not provide an atomic pread or pwrite, or similar */
62
94
#define OS_FILE_N_SEEK_MUTEXES 16
65
97
/* In simulated aio, merge at most this many consecutive i/os */
66
98
#define OS_AIO_MERGE_N_CONSECUTIVE 64
67
99
68
/* If this flag is TRUE, then we will use the native aio of the
100
/** If this flag is TRUE, then we will use the native aio of the
69
101
OS (provided we compiled Innobase with it in), otherwise we will
70
102
use simulated aio we build below with threads */
71
103
72
104
UNIV_INTERN ibool os_aio_use_native_aio = FALSE;
73
105
106
/** Flag: enable debug printout for asynchronous i/o */
74
107
UNIV_INTERN ibool os_aio_print_debug = FALSE;
75
108
76
/* The aio array slot structure */
109
/** The asynchronous i/o array slot structure */
77
110
typedef struct os_aio_slot_struct os_aio_slot_t;
78
111
112
/** The asynchronous i/o array slot structure */
79
113
struct os_aio_slot_struct{
80
ibool is_read; /* TRUE if a read operation */
81
ulint pos; /* index of the slot in the aio
114
ibool is_read; /*!< TRUE if a read operation */
115
ulint pos; /*!< index of the slot in the aio
82
116
array */
83
ibool reserved; /* TRUE if this slot is reserved */
84
time_t reservation_time;/* time when reserved */
85
ulint len; /* length of the block to read or
117
ibool reserved; /*!< TRUE if this slot is reserved */
118
time_t reservation_time;/*!< time when reserved */
119
ulint len; /*!< length of the block to read or
86
120
write */
87
byte* buf; /* buffer used in i/o */
88
ulint type; /* OS_FILE_READ or OS_FILE_WRITE */
89
ulint offset; /* 32 low bits of file offset in
121
byte* buf; /*!< buffer used in i/o */
122
ulint type; /*!< OS_FILE_READ or OS_FILE_WRITE */
123
ulint offset; /*!< 32 low bits of file offset in
90
124
bytes */
91
ulint offset_high; /* 32 high bits of file offset */
92
os_file_t file; /* file where to read or write */
93
const char* name; /* file name or path */
94
ibool io_already_done;/* used only in simulated aio:
125
ulint offset_high; /*!< 32 high bits of file offset */
126
os_file_t file; /*!< file where to read or write */
127
const char* name; /*!< file name or path */
128
ibool io_already_done;/*!< used only in simulated aio:
95
129
TRUE if the physical i/o already
96
130
made and only the slot message
97
131
needs to be passed to the caller
98
132
of os_aio_simulated_handle */
99
fil_node_t* message1; /* message which is given by the */
100
void* message2; /* the requester of an aio operation
133
fil_node_t* message1; /*!< message which is given by the */
134
void* message2; /*!< the requester of an aio operation
101
135
and which can be used to identify
102
136
which pending aio operation was
103
137
completed */
104
138
#ifdef WIN_ASYNC_IO
105
os_event_t event; /* event object we need in the
139
os_event_t event; /*!< event object we need in the
106
140
OVERLAPPED struct */
107
OVERLAPPED control; /* Windows control block for the
141
OVERLAPPED control; /*!< Windows control block for the
108
142
aio request */
109
143
#endif
110
144
};
111
145
112
/* The aio array structure */
146
/** The asynchronous i/o array structure */
113
147
typedef struct os_aio_array_struct os_aio_array_t;
114
148
149
/** The asynchronous i/o array structure */
115
150
struct os_aio_array_struct{
116
os_mutex_t mutex; /* the mutex protecting the aio array */
117
os_event_t not_full; /* The event which is set to the signaled
118
state when there is space in the aio
119
outside the ibuf segment */
120
os_event_t is_empty; /* The event which is set to the signaled
121
state when there are no pending i/os
122
in this array */
123
ulint n_slots; /* Total number of slots in the aio array.
124
This must be divisible by n_threads. */
125
ulint n_segments;/* Number of segments in the aio array of
126
pending aio requests. A thread can wait
127
separately for any one of the segments. */
128
ulint n_reserved;/* Number of reserved slots in the
129
aio array outside the ibuf segment */
130
os_aio_slot_t* slots; /* Pointer to the slots in the array */
151
os_mutex_t mutex; /*!< the mutex protecting the aio array */
152
os_event_t not_full;
153
/*!< The event which is set to the
154
signaled state when there is space in
155
the aio outside the ibuf segment */
156
os_event_t is_empty;
157
/*!< The event which is set to the
158
signaled state when there are no
159
pending i/os in this array */
160
ulint n_slots;/*!< Total number of slots in the aio
161
array. This must be divisible by
162
n_threads. */
163
ulint n_segments;
164
/*!< Number of segments in the aio
165
array of pending aio requests. A
166
thread can wait separately for any one
167
of the segments. */
168
ulint n_reserved;
169
/*!< Number of reserved slots in the
170
aio array outside the ibuf segment */
171
os_aio_slot_t* slots; /*!< Pointer to the slots in the array */
131
172
#ifdef __WIN__
132
173
os_native_event_t* native_events;
133
/* Pointer to an array of OS native event
134
handles where we copied the handles from
135
slots, in the same order. This can be used
136
in WaitForMultipleObjects; used only in
137
Windows */
174
/*!< Pointer to an array of OS native
175
event handles where we copied the
176
handles from slots, in the same
177
order. This can be used in
178
WaitForMultipleObjects; used only in
179
Windows */
138
180
#endif
139
181
};
140
182
141
/* Array of events used in simulated aio */
183
/** Array of events used in simulated aio */
142
184
static os_event_t* os_aio_segment_wait_events = NULL;
143
185
144
/* The aio arrays for non-ibuf i/o and ibuf i/o, as well as sync aio. These
145
are NULL when the module has not yet been initialized. */
146
static os_aio_array_t* os_aio_read_array = NULL;
147
static os_aio_array_t* os_aio_write_array = NULL;
148
static os_aio_array_t* os_aio_ibuf_array = NULL;
149
static os_aio_array_t* os_aio_log_array = NULL;
150
static os_aio_array_t* os_aio_sync_array = NULL;
186
/** The aio arrays for non-ibuf i/o and ibuf i/o, as well as sync aio. These
187
are NULL when the module has not yet been initialized. @{ */
188
static os_aio_array_t* os_aio_read_array = NULL; /*!< Reads */
189
static os_aio_array_t* os_aio_write_array = NULL; /*!< Writes */
190
static os_aio_array_t* os_aio_ibuf_array = NULL; /*!< Insert buffer */
191
static os_aio_array_t* os_aio_log_array = NULL; /*!< Redo log */
192
static os_aio_array_t* os_aio_sync_array = NULL; /*!< Synchronous I/O */
193
/* @} */
151
194
195
/** Number of asynchronous I/O segments. Set by os_aio_init(). */
152
196
static ulint os_aio_n_segments = ULINT_UNDEFINED;
153
197
154
/* If the following is TRUE, read i/o handler threads try to
198
/** If the following is TRUE, read i/o handler threads try to
155
199
wait until a batch of new read requests have been posted */
156
200
static ibool os_aio_recommend_sleep_for_read_threads = FALSE;
201
#endif /* !UNIV_HOTBACKUP */
157
202
158
203
UNIV_INTERN ulint os_n_file_reads = 0;
159
204
UNIV_INTERN ulint os_bytes_read_since_printout = 0;
166
211
167
212
UNIV_INTERN ibool os_has_said_disk_full = FALSE;
168
213
169
/* The mutex protecting the following counts of pending I/O operations */
214
#ifndef UNIV_HOTBACKUP
215
/** The mutex protecting the following counts of pending I/O operations */
170
216
static os_mutex_t os_file_count_mutex;
217
#endif /* !UNIV_HOTBACKUP */
218
/** Number of pending os_file_pread() operations */
171
219
UNIV_INTERN ulint os_file_n_pending_preads = 0;
220
/** Number of pending os_file_pwrite() operations */
172
221
UNIV_INTERN ulint os_file_n_pending_pwrites = 0;
222
/** Number of pending write operations */
173
223
UNIV_INTERN ulint os_n_pending_writes = 0;
224
/** Number of pending read operations */
174
225
UNIV_INTERN ulint os_n_pending_reads = 0;
175
226
176
/***************************************************************************
177
Gets the operating system version. Currently works only on Windows. */
227
/***********************************************************************//**
228
Gets the operating system version. Currently works only on Windows.
229
@return OS_WIN95, OS_WIN31, OS_WINNT, OS_WIN2000 */
178
230
UNIV_INTERN
179
231
ulint
180
232
os_get_os_version(void)
181
233
/*===================*/
182
/* out: OS_WIN95, OS_WIN31, OS_WINNT, OS_WIN2000 */
183
234
{
184
235
#ifdef __WIN__
185
236
OSVERSIONINFO os_info;
209
260
#endif
210
261
}
211
262
212
/***************************************************************************
263
/***********************************************************************//**
213
264
Retrieves the last error number if an error occurs in a file io function.
214
265
The number should be retrieved before any other OS calls (because they may
215
266
overwrite the error number). If the number is not known to this program,
216
the OS error number + 100 is returned. */
267
the OS error number + 100 is returned.
268
@return error number, or OS error number + 100 */
217
269
UNIV_INTERN
218
270
ulint
219
271
os_file_get_last_error(
220
272
/*===================*/
221
/* out: error number, or OS error
222
number + 100 */
223
ibool report_all_errors) /* in: TRUE if we want an error message
273
ibool report_all_errors) /*!< in: TRUE if we want an error message
224
274
printed of all errors */
225
275
{
226
276
ulint err;
270
320
"InnoDB: Some operating system error numbers"
271
321
" are described at\n"
272
322
"InnoDB: "
273
"http://dev.mysql.com/doc/refman/5.1/en/"
323
REFMAN
274
324
"operating-system-error-codes.html\n");
275
325
}
276
326
}
329
379
"InnoDB: Some operating system"
330
380
" error numbers are described at\n"
331
381
"InnoDB: "
332
"http://dev.mysql.com/doc/refman/5.1/en/"
382
REFMAN
333
383
"operating-system-error-codes.html\n");
334
384
}
335
385
}
350
400
#endif
351
401
}
352
402
353
/********************************************************************
403
/****************************************************************//**
354
404
Does error handling when a file operation fails.
355
405
Conditionally exits (calling exit(3)) based on should_exit value and the
356
error type */
406
error type
407
@return TRUE if we should retry the operation */
357
408
static
358
409
ibool
359
410
os_file_handle_error_cond_exit(
360
411
/*===========================*/
361
/* out: TRUE if we should retry the
362
operation */
363
const char* name, /* in: name of a file or NULL */
364
const char* operation, /* in: operation */
365
ibool should_exit) /* in: call exit(3) if unknown error
412
const char* name, /*!< in: name of a file or NULL */
413
const char* operation, /*!< in: operation */
414
ibool should_exit) /*!< in: call exit(3) if unknown error
366
415
and this parameter is TRUE */
367
416
{
368
417
ulint err;
425
474
return(FALSE);
426
475
}
427
476
428
/********************************************************************
429
Does error handling when a file operation fails. */
477
/****************************************************************//**
478
Does error handling when a file operation fails.
479
@return TRUE if we should retry the operation */
430
480
static
431
481
ibool
432
482
os_file_handle_error(
433
483
/*=================*/
434
/* out: TRUE if we should retry the
435
operation */
436
const char* name, /* in: name of a file or NULL */
437
const char* operation)/* in: operation */
484
const char* name, /*!< in: name of a file or NULL */
485
const char* operation)/*!< in: operation */
438
486
{
439
487
/* exit in case of unknown error */
440
488
return(os_file_handle_error_cond_exit(name, operation, TRUE));
441
489
}
442
490
443
/********************************************************************
444
Does error handling when a file operation fails. */
491
/****************************************************************//**
492
Does error handling when a file operation fails.
493
@return TRUE if we should retry the operation */
445
494
static
446
495
ibool
447
496
os_file_handle_error_no_exit(
448
497
/*=========================*/
449
/* out: TRUE if we should retry the
450
operation */
451
const char* name, /* in: name of a file or NULL */
452
const char* operation)/* in: operation */
498
const char* name, /*!< in: name of a file or NULL */
499
const char* operation)/*!< in: operation */
453
500
{
454
501
/* don't exit in case of unknown error */
455
502
return(os_file_handle_error_cond_exit(name, operation, FALSE));
464
511
# undef USE_FILE_LOCK
465
512
#endif
466
513
#ifdef USE_FILE_LOCK
467
/********************************************************************
468
Obtain an exclusive lock on a file. */
514
/****************************************************************//**
515
Obtain an exclusive lock on a file.
516
@return 0 on success */
469
517
static
470
518
int
471
519
os_file_lock(
472
520
/*=========*/
473
/* out: 0 on success */
474
int fd, /* in: file descriptor */
475
const char* name) /* in: file name */
521
int fd, /*!< in: file descriptor */
522
const char* name) /*!< in: file name */
476
523
{
477
524
struct flock lk;
478
525
lk.l_type = F_WRLCK;
497
544
}
498
545
#endif /* USE_FILE_LOCK */
499
546
500
/********************************************************************
547
#ifndef UNIV_HOTBACKUP
548
/****************************************************************//**
501
549
Creates the seek mutexes used in positioned reads and writes. */
502
550
UNIV_INTERN
503
551
void
513
561
}
514
562
}
515
563
516
/***************************************************************************
564
/***********************************************************************//**
517
565
Creates a temporary file. This function is like tmpfile(3), but
518
566
the temporary file is created in the MySQL temporary directory.
519
567
On Netware, this function is like tmpfile(3), because the C run-time
520
library of Netware does not expose the delete-on-close flag. */
568
library of Netware does not expose the delete-on-close flag.
569
@return temporary file handle, or NULL on error */
521
570
UNIV_INTERN
522
571
FILE*
523
572
os_file_create_tmpfile(void)
524
573
/*========================*/
525
/* out: temporary file handle, or NULL on error */
526
574
{
527
#ifdef UNIV_HOTBACKUP
528
ut_error;
529
530
return(NULL);
531
#else
532
# ifdef __NETWARE__
575
#ifdef __NETWARE__
533
576
FILE* file = tmpfile();
534
# else /* __NETWARE__ */
577
#else /* __NETWARE__ */
535
578
FILE* file = NULL;
536
579
int fd = innobase_mysql_tmpfile();
537
580
538
581
if (fd >= 0) {
539
582
file = fdopen(fd, "w+b");
540
583
}
541
# endif /* __NETWARE__ */
584
#endif /* __NETWARE__ */
542
585
543
586
if (!file) {
544
587
ut_print_timestamp(stderr);
545
588
fprintf(stderr,
546
589
" InnoDB: Error: unable to create temporary file;"
547
590
" errno: %d\n", errno);
548
# ifndef __NETWARE__
591
#ifndef __NETWARE__
549
592
if (fd >= 0) {
550
593
close(fd);
551
594
}
552
# endif /* !__NETWARE__ */
595
#endif /* !__NETWARE__ */
553
596
}
554
597
555
598
return(file);
556
#endif /* UNIV_HOTBACKUP */
557
599
}
600
#endif /* !UNIV_HOTBACKUP */
558
601
559
/***************************************************************************
602
/***********************************************************************//**
560
603
The os_file_opendir() function opens a directory stream corresponding to the
561
604
directory named by the dirname argument. The directory stream is positioned
562
605
at the first entry. In both Unix and Windows we automatically skip the '.'
563
and '..' items at the start of the directory listing. */
606
and '..' items at the start of the directory listing.
607
@return directory stream, NULL if error */
564
608
UNIV_INTERN
565
609
os_file_dir_t
566
610
os_file_opendir(
567
611
/*============*/
568
/* out: directory stream, NULL if
569
error */
570
const char* dirname, /* in: directory name; it must not
612
const char* dirname, /*!< in: directory name; it must not
571
613
contain a trailing '\' or '/' */
572
ibool error_is_fatal) /* in: TRUE if we should treat an
614
ibool error_is_fatal) /*!< in: TRUE if we should treat an
573
615
error as a fatal error; if we try to
574
616
open symlinks then we do not wish a
575
617
fatal error if it happens not to be
616
658
#endif
617
659
}
618
660
619
/***************************************************************************
620
Closes a directory stream. */
661
/***********************************************************************//**
662
Closes a directory stream.
663
@return 0 if success, -1 if failure */
621
664
UNIV_INTERN
622
665
int
623
666
os_file_closedir(
624
667
/*=============*/
625
/* out: 0 if success, -1 if failure */
626
os_file_dir_t dir) /* in: directory stream */
668
os_file_dir_t dir) /*!< in: directory stream */
627
669
{
628
670
#ifdef __WIN__
629
671
BOOL ret;
650
692
#endif
651
693
}
652
694
653
/***************************************************************************
695
/***********************************************************************//**
654
696
This function returns information of the next file in the directory. We jump
655
over the '.' and '..' entries in the directory. */
697
over the '.' and '..' entries in the directory.
698
@return 0 if ok, -1 if error, 1 if at the end of the directory */
656
699
UNIV_INTERN
657
700
int
658
701
os_file_readdir_next_file(
659
702
/*======================*/
660
/* out: 0 if ok, -1 if error, 1 if at the end
661
of the directory */
662
const char* dirname,/* in: directory name or path */
663
os_file_dir_t dir, /* in: directory stream */
664
os_file_stat_t* info) /* in/out: buffer where the info is returned */
703
const char* dirname,/*!< in: directory name or path */
704
os_file_dir_t dir, /*!< in: directory stream */
705
os_file_stat_t* info) /*!< in/out: buffer where the info is returned */
665
706
{
666
707
#ifdef __WIN__
667
708
LPWIN32_FIND_DATA lpFindFileData;
693
734
/* TODO: MySQL has apparently its own symlink
694
735
implementation in Windows, dbname.sym can
695
736
redirect a database directory:
696
http://dev.mysql.com/doc/refman/5.1/en/
697
windows-symbolic-links.html */
737
REFMAN "windows-symbolic-links.html" */
698
738
info->type = OS_FILE_TYPE_LINK;
699
739
} else if (lpFindFileData->dwFileAttributes
700
740
& FILE_ATTRIBUTE_DIRECTORY) {
802
842
#endif
803
843
}
804
844
805
/*********************************************************************
845
/*****************************************************************//**
806
846
This function attempts to create a directory named pathname. The new directory
807
847
gets default permissions. On Unix the permissions are (0770 & ~umask). If the
808
848
directory exists already, nothing is done and the call succeeds, unless the
809
fail_if_exists arguments is true. */
849
fail_if_exists arguments is true.
850
@return TRUE if call succeeds, FALSE on error */
810
851
UNIV_INTERN
811
852
ibool
812
853
os_file_create_directory(
813
854
/*=====================*/
814
/* out: TRUE if call succeeds,
815
FALSE on error */
816
const char* pathname, /* in: directory name as
855
const char* pathname, /*!< in: directory name as
817
856
null-terminated string */
818
ibool fail_if_exists) /* in: if TRUE, pre-existing directory
857
ibool fail_if_exists) /*!< in: if TRUE, pre-existing directory
819
858
is treated as an error. */
820
859
{
821
860
#ifdef __WIN__
848
887
#endif
849
888
}
850
889
851
/********************************************************************
852
A simple function to open or create a file. */
890
/****************************************************************//**
891
A simple function to open or create a file.
892
@return own: handle to the file, not defined if error, error number
893
can be retrieved with os_file_get_last_error */
853
894
UNIV_INTERN
854
895
os_file_t
855
896
os_file_create_simple(
856
897
/*==================*/
857
/* out, own: handle to the file, not defined
858
if error, error number can be retrieved with
859
os_file_get_last_error */
860
const char* name, /* in: name of the file or path as a
898
const char* name, /*!< in: name of the file or path as a
861
899
null-terminated string */
862
ulint create_mode,/* in: OS_FILE_OPEN if an existing file is
900
ulint create_mode,/*!< in: OS_FILE_OPEN if an existing file is
863
901
opened (if does not exist, error), or
864
902
OS_FILE_CREATE if a new file is created
865
903
(if exists, error), or
866
904
OS_FILE_CREATE_PATH if new file
867
905
(if exists, error) and subdirectories along
868
906
its path are created (if needed)*/
869
ulint access_type,/* in: OS_FILE_READ_ONLY or
907
ulint access_type,/*!< in: OS_FILE_READ_ONLY or
870
908
OS_FILE_READ_WRITE */
871
ibool* success)/* out: TRUE if succeed, FALSE if error */
909
ibool* success)/*!< out: TRUE if succeed, FALSE if error */
872
910
{
873
911
#ifdef __WIN__
874
912
os_file_t file;
914
952
NULL, /* default security attributes */
915
953
create_flag,
916
954
attributes,
917
NULL); /* no template file */
955
NULL); /*!< no template file */
918
956
919
957
if (file == INVALID_HANDLE_VALUE) {
920
958
*success = FALSE;
990
1028
#endif /* __WIN__ */
991
1029
}
992
1030
993
/********************************************************************
994
A simple function to open or create a file. */
1031
/****************************************************************//**
1032
A simple function to open or create a file.
1033
@return own: handle to the file, not defined if error, error number
1034
can be retrieved with os_file_get_last_error */
995
1035
UNIV_INTERN
996
1036
os_file_t
997
1037
os_file_create_simple_no_error_handling(
998
1038
/*====================================*/
999
/* out, own: handle to the file, not defined
1000
if error, error number can be retrieved with
1001
os_file_get_last_error */
1002
const char* name, /* in: name of the file or path as a
1039
const char* name, /*!< in: name of the file or path as a
1003
1040
null-terminated string */
1004
ulint create_mode,/* in: OS_FILE_OPEN if an existing file
1041
ulint create_mode,/*!< in: OS_FILE_OPEN if an existing file
1005
1042
is opened (if does not exist, error), or
1006
1043
OS_FILE_CREATE if a new file is created
1007
1044
(if exists, error) */
1008
ulint access_type,/* in: OS_FILE_READ_ONLY,
1045
ulint access_type,/*!< in: OS_FILE_READ_ONLY,
1009
1046
OS_FILE_READ_WRITE, or
1010
1047
OS_FILE_READ_ALLOW_DELETE; the last option is
1011
1048
used by a backup program reading the file */
1012
ibool* success)/* out: TRUE if succeed, FALSE if error */
1049
ibool* success)/*!< out: TRUE if succeed, FALSE if error */
1013
1050
{
1014
1051
#ifdef __WIN__
1015
1052
os_file_t file;
1036
1073
} else if (access_type == OS_FILE_READ_ALLOW_DELETE) {
1037
1074
access = GENERIC_READ;
1038
1075
share_mode = FILE_SHARE_DELETE | FILE_SHARE_READ
1039
| FILE_SHARE_WRITE; /* A backup program has to give
1076
| FILE_SHARE_WRITE; /*!< A backup program has to give
1040
1077
mysqld the maximum freedom to
1041
1078
do what it likes with the
1042
1079
file */
1051
1088
NULL, /* default security attributes */
1052
1089
create_flag,
1053
1090
attributes,
1054
NULL); /* no template file */
1091
NULL); /*!< no template file */
1055
1092
1056
1093
if (file == INVALID_HANDLE_VALUE) {
1057
1094
*success = FALSE;
1103
1140
#endif /* __WIN__ */
1104
1141
}
1105
1142
1106
/********************************************************************
1143
/****************************************************************//**
1107
1144
Tries to disable OS caching on an opened file descriptor. */
1108
1145
UNIV_INTERN
1109
1146
void
1110
1147
os_file_set_nocache(
1111
1148
/*================*/
1112
int fd, /* in: file descriptor to alter */
1113
const char* file_name, /* in: file name, used in the
1149
int fd, /*!< in: file descriptor to alter */
1150
const char* file_name, /*!< in: file name, used in the
1114
1151
diagnostic message */
1115
const char* operation_name) /* in: "open" or "create"; used in the
1152
const char* operation_name) /*!< in: "open" or "create"; used in the
1116
1153
diagnostic message */
1117
1154
{
1118
1155
/* some versions of Solaris may not have DIRECTIO_ON */
1146
1183
#endif
1147
1184
}
1148
1185
1149
/********************************************************************
1150
Opens an existing file or creates a new. */
1186
/****************************************************************//**
1187
Opens an existing file or creates a new.
1188
@return own: handle to the file, not defined if error, error number
1189
can be retrieved with os_file_get_last_error */
1151
1190
UNIV_INTERN
1152
1191
os_file_t
1153
1192
os_file_create(
1154
1193
/*===========*/
1155
/* out, own: handle to the file, not defined
1156
if error, error number can be retrieved with
1157
os_file_get_last_error */
1158
const char* name, /* in: name of the file or path as a
1194
const char* name, /*!< in: name of the file or path as a
1159
1195
null-terminated string */
1160
ulint create_mode,/* in: OS_FILE_OPEN if an existing file
1196
ulint create_mode,/*!< in: OS_FILE_OPEN if an existing file
1161
1197
is opened (if does not exist, error), or
1162
1198
OS_FILE_CREATE if a new file is created
1163
1199
(if exists, error),
1165
1201
or an old overwritten;
1166
1202
OS_FILE_OPEN_RAW, if a raw device or disk
1167
1203
partition should be opened */
1168
ulint purpose,/* in: OS_FILE_AIO, if asynchronous,
1204
ulint purpose,/*!< in: OS_FILE_AIO, if asynchronous,
1169
1205
non-buffered i/o is desired,
1170
1206
OS_FILE_NORMAL, if any normal file;
1171
1207
NOTE that it also depends on type, os_aio_..
1172
1208
and srv_.. variables whether we really use
1173
1209
async i/o or unbuffered i/o: look in the
1174
1210
function source code for the exact rules */
1175
ulint type, /* in: OS_DATA_FILE or OS_LOG_FILE */
1176
ibool* success)/* out: TRUE if succeed, FALSE if error */
1211
ulint type, /*!< in: OS_DATA_FILE or OS_LOG_FILE */
1212
ibool* success)/*!< out: TRUE if succeed, FALSE if error */
1177
1213
{
1178
1214
#ifdef __WIN__
1179
1215
os_file_t file;
1252
1288
NULL, /* default security attributes */
1253
1289
create_flag,
1254
1290
attributes,
1255
NULL); /* no template file */
1291
NULL); /*!< no template file */
1256
1292
1257
1293
if (file == INVALID_HANDLE_VALUE) {
1258
1294
*success = FALSE;
1405
1441
#endif /* __WIN__ */
1406
1442
}
1407
1443
1408
/***************************************************************************
1409
Deletes a file if it exists. The file has to be closed before calling this. */
1444
/***********************************************************************//**
1445
Deletes a file if it exists. The file has to be closed before calling this.
1446
@return TRUE if success */
1410
1447
UNIV_INTERN
1411
1448
ibool
1412
1449
os_file_delete_if_exists(
1413
1450
/*=====================*/
1414
/* out: TRUE if success */
1415
const char* name) /* in: file path as a null-terminated string */
1451
const char* name) /*!< in: file path as a null-terminated string */
1416
1452
{
1417
1453
#ifdef __WIN__
1418
1454
BOOL ret;
1467
1503
#endif
1468
1504
}
1469
1505
1470
/***************************************************************************
1471
Deletes a file. The file has to be closed before calling this. */
1506
/***********************************************************************//**
1507
Deletes a file. The file has to be closed before calling this.
1508
@return TRUE if success */
1472
1509
UNIV_INTERN
1473
1510
ibool
1474
1511
os_file_delete(
1475
1512
/*===========*/
1476
/* out: TRUE if success */
1477
const char* name) /* in: file path as a null-terminated string */
1513
const char* name) /*!< in: file path as a null-terminated string */
1478
1514
{
1479
1515
#ifdef __WIN__
1480
1516
BOOL ret;
1530
1566
#endif
1531
1567
}
1532
1568
1533
/***************************************************************************
1569
/***********************************************************************//**
1534
1570
Renames a file (can also move it to another directory). It is safest that the
1535
file is closed before calling this function. */
1571
file is closed before calling this function.
1572
@return TRUE if success */
1536
1573
UNIV_INTERN
1537
1574
ibool
1538
1575
os_file_rename(
1539
1576
/*===========*/
1540
/* out: TRUE if success */
1541
const char* oldpath,/* in: old file path as a null-terminated
1577
const char* oldpath,/*!< in: old file path as a null-terminated
1542
1578
string */
1543
const char* newpath)/* in: new file path */
1579
const char* newpath)/*!< in: new file path */
1544
1580
{
1545
1581
#ifdef __WIN__
1546
1582
BOOL ret;
1569
1605
#endif
1570
1606
}
1571
1607
1572
/***************************************************************************
1608
/***********************************************************************//**
1573
1609
Closes a file handle. In case of error, error number can be retrieved with
1574
os_file_get_last_error. */
1610
os_file_get_last_error.
1611
@return TRUE if success */
1575
1612
UNIV_INTERN
1576
1613
ibool
1577
1614
os_file_close(
1578
1615
/*==========*/
1579
/* out: TRUE if success */
1580
os_file_t file) /* in, own: handle to a file */
1616
os_file_t file) /*!< in, own: handle to a file */
1581
1617
{
1582
1618
#ifdef __WIN__
1583
1619
BOOL ret;
1608
1644
#endif
1609
1645
}
1610
1646
1611
/***************************************************************************
1612
Closes a file handle. */
1647
#ifdef UNIV_HOTBACKUP
1648
/***********************************************************************//**
1649
Closes a file handle.
1650
@return TRUE if success */
1613
1651
UNIV_INTERN
1614
1652
ibool
1615
1653
os_file_close_no_error_handling(
1616
1654
/*============================*/
1617
/* out: TRUE if success */
1618
os_file_t file) /* in, own: handle to a file */
1655
os_file_t file) /*!< in, own: handle to a file */
1619
1656
{
1620
1657
#ifdef __WIN__
1621
1658
BOOL ret;
1642
1679
return(TRUE);
1643
1680
#endif
1644
1681
}
1682
#endif /* UNIV_HOTBACKUP */
1645
1683
1646
/***************************************************************************
1647
Gets a file size. */
1684
/***********************************************************************//**
1685
Gets a file size.
1686
@return TRUE if success */
1648
1687
UNIV_INTERN
1649
1688
ibool
1650
1689
os_file_get_size(
1651
1690
/*=============*/
1652
/* out: TRUE if success */
1653
os_file_t file, /* in: handle to a file */
1654
ulint* size, /* out: least significant 32 bits of file
1691
os_file_t file, /*!< in: handle to a file */
1692
ulint* size, /*!< out: least significant 32 bits of file
1655
1693
size */
1656
ulint* size_high)/* out: most significant 32 bits of size */
1694
ulint* size_high)/*!< out: most significant 32 bits of size */
1657
1695
{
1658
1696
#ifdef __WIN__
1659
1697
DWORD high;
1691
1729
#endif
1692
1730
}
1693
1731
1694
/***************************************************************************
1695
Gets file size as a 64-bit integer ib_int64_t. */
1732
/***********************************************************************//**
1733
Gets file size as a 64-bit integer ib_int64_t.
1734
@return size in bytes, -1 if error */
1696
1735
UNIV_INTERN
1697
1736
ib_int64_t
1698
1737
os_file_get_size_as_iblonglong(
1699
1738
/*===========================*/
1700
/* out: size in bytes, -1 if error */
1701
os_file_t file) /* in: handle to a file */
1739
os_file_t file) /*!< in: handle to a file */
1702
1740
{
1703
1741
ulint size;
1704
1742
ulint size_high;
1714
1752
return((((ib_int64_t)size_high) << 32) + (ib_int64_t)size);
1715
1753
}
1716
1754
1717
/***************************************************************************
1718
Write the specified number of zeros to a newly created file. */
1755
/***********************************************************************//**
1756
Write the specified number of zeros to a newly created file.
1757
@return TRUE if success */
1719
1758
UNIV_INTERN
1720
1759
ibool
1721
1760
os_file_set_size(
1722
1761
/*=============*/
1723
/* out: TRUE if success */
1724
const char* name, /* in: name of the file or path as a
1762
const char* name, /*!< in: name of the file or path as a
1725
1763
null-terminated string */
1726
os_file_t file, /* in: handle to a file */
1727
ulint size, /* in: least significant 32 bits of file
1764
os_file_t file, /*!< in: handle to a file */
1765
ulint size, /*!< in: least significant 32 bits of file
1728
1766
size */
1729
ulint size_high)/* in: most significant 32 bits of size */
1767
ulint size_high)/*!< in: most significant 32 bits of size */
1730
1768
{
1731
1769
ib_int64_t current_size;
1732
1770
ib_int64_t desired_size;
1803
1841
return(FALSE);
1804
1842
}
1805
1843
1806
/***************************************************************************
1807
Truncates a file at its current position. */
1844
/***********************************************************************//**
1845
Truncates a file at its current position.
1846
@return TRUE if success */
1808
1847
UNIV_INTERN
1809
1848
ibool
1810
1849
os_file_set_eof(
1811
1850
/*============*/
1812
/* out: TRUE if success */
1813
FILE* file) /* in: file to be truncated */
1851
FILE* file) /*!< in: file to be truncated */
1814
1852
{
1815
1853
#ifdef __WIN__
1816
1854
HANDLE h = (HANDLE) _get_osfhandle(fileno(file));
1821
1859
}
1822
1860
1823
1861
#ifndef __WIN__
1824
/***************************************************************************
1862
/***********************************************************************//**
1825
1863
Wrapper to fsync(2) that retries the call on some errors.
1826
1864
Returns the value 0 if successful; otherwise the value -1 is returned and
1827
the global variable errno is set to indicate the error. */
1865
the global variable errno is set to indicate the error.
1866
@return 0 if success, -1 otherwise */
1828
1867
1829
1868
static
1830
1869
int
1831
1870
os_file_fsync(
1832
1871
/*==========*/
1833
/* out: 0 if success, -1 otherwise */
1834
os_file_t file) /* in: handle to a file */
1872
os_file_t file) /*!< in: handle to a file */
1835
1873
{
1836
1874
int ret;
1837
1875
int failures;
1869
1907
}
1870
1908
#endif /* !__WIN__ */
1871
1909
1872
/***************************************************************************
1873
Flushes the write buffers of a given file to the disk. */
1910
/***********************************************************************//**
1911
Flushes the write buffers of a given file to the disk.
1912
@return TRUE if success */
1874
1913
UNIV_INTERN
1875
1914
ibool
1876
1915
os_file_flush(
1877
1916
/*==========*/
1878
/* out: TRUE if success */
1879
os_file_t file) /* in, own: handle to a file */
1917
os_file_t file) /*!< in, own: handle to a file */
1880
1918
{
1881
1919
#ifdef __WIN__
1882
1920
BOOL ret;
1968
2006
}
1969
2007
1970
2008
#ifndef __WIN__
1971
/***********************************************************************
1972
Does a synchronous read operation in Posix. */
2009
/*******************************************************************//**
2010
Does a synchronous read operation in Posix.
2011
@return number of bytes read, -1 if error */
1973
2012
static
1974
2013
ssize_t
1975
2014
os_file_pread(
1976
2015
/*==========*/
1977
/* out: number of bytes read, -1 if error */
1978
os_file_t file, /* in: handle to a file */
1979
void* buf, /* in: buffer where to read */
1980
ulint n, /* in: number of bytes to read */
1981
ulint offset, /* in: least significant 32 bits of file
2016
os_file_t file, /*!< in: handle to a file */
2017
void* buf, /*!< in: buffer where to read */
2018
ulint n, /*!< in: number of bytes to read */
2019
ulint offset, /*!< in: least significant 32 bits of file
1982
2020
offset from where to read */
1983
ulint offset_high) /* in: most significant 32 bits of
2021
ulint offset_high) /*!< in: most significant 32 bits of
1984
2022
offset */
1985
2023
{
1986
2024
off_t offs;
2053
2091
#endif
2054
2092
}
2055
2093
2056
/***********************************************************************
2057
Does a synchronous write operation in Posix. */
2094
/*******************************************************************//**
2095
Does a synchronous write operation in Posix.
2096
@return number of bytes written, -1 if error */
2058
2097
static
2059
2098
ssize_t
2060
2099
os_file_pwrite(
2061
2100
/*===========*/
2062
/* out: number of bytes written, -1 if error */
2063
os_file_t file, /* in: handle to a file */
2064
const void* buf, /* in: buffer from where to write */
2065
ulint n, /* in: number of bytes to write */
2066
ulint offset, /* in: least significant 32 bits of file
2101
os_file_t file, /*!< in: handle to a file */
2102
const void* buf, /*!< in: buffer from where to write */
2103
ulint n, /*!< in: number of bytes to write */
2104
ulint offset, /*!< in: least significant 32 bits of file
2067
2105
offset where to write */
2068
ulint offset_high) /* in: most significant 32 bits of
2106
ulint offset_high) /*!< in: most significant 32 bits of
2069
2107
offset */
2070
2108
{
2071
2109
ssize_t ret;
2167
2205
}
2168
2206
#endif
2169
2207
2170
/***********************************************************************
2171
Requests a synchronous positioned read operation. */
2208
/*******************************************************************//**
2209
Requests a synchronous positioned read operation.
2210
@return TRUE if request was successful, FALSE if fail */
2172
2211
UNIV_INTERN
2173
2212
ibool
2174
2213
os_file_read(
2175
2214
/*=========*/
2176
/* out: TRUE if request was
2177
successful, FALSE if fail */
2178
os_file_t file, /* in: handle to a file */
2179
void* buf, /* in: buffer where to read */
2180
ulint offset, /* in: least significant 32 bits of file
2215
os_file_t file, /*!< in: handle to a file */
2216
void* buf, /*!< in: buffer where to read */
2217
ulint offset, /*!< in: least significant 32 bits of file
2181
2218
offset where to read */
2182
ulint offset_high, /* in: most significant 32 bits of
2219
ulint offset_high, /*!< in: most significant 32 bits of
2183
2220
offset */
2184
ulint n) /* in: number of bytes to read */
2221
ulint n) /*!< in: number of bytes to read */
2185
2222
{
2186
2223
#ifdef __WIN__
2187
2224
BOOL ret;
2283
2320
return(FALSE);
2284
2321
}
2285
2322
2286
/***********************************************************************
2323
/*******************************************************************//**
2287
2324
Requests a synchronous positioned read operation. This function does not do
2288
any error handling. In case of error it returns FALSE. */
2325
any error handling. In case of error it returns FALSE.
2326
@return TRUE if request was successful, FALSE if fail */
2289
2327
UNIV_INTERN
2290
2328
ibool
2291
2329
os_file_read_no_error_handling(
2292
2330
/*===========================*/
2293
/* out: TRUE if request was
2294
successful, FALSE if fail */
2295
os_file_t file, /* in: handle to a file */
2296
void* buf, /* in: buffer where to read */
2297
ulint offset, /* in: least significant 32 bits of file
2331
os_file_t file, /*!< in: handle to a file */
2332
void* buf, /*!< in: buffer where to read */
2333
ulint offset, /*!< in: least significant 32 bits of file
2298
2334
offset where to read */
2299
ulint offset_high, /* in: most significant 32 bits of
2335
ulint offset_high, /*!< in: most significant 32 bits of
2300
2336
offset */
2301
ulint n) /* in: number of bytes to read */
2337
ulint n) /*!< in: number of bytes to read */
2302
2338
{
2303
2339
#ifdef __WIN__
2304
2340
BOOL ret;
2381
2417
return(FALSE);
2382
2418
}
2383
2419
2384
/***********************************************************************
2420
/*******************************************************************//**
2385
2421
Rewind file to its start, read at most size - 1 bytes from it to str, and
2386
2422
NUL-terminate str. All errors are silently ignored. This function is
2387
2423
mostly meant to be used with temporary files. */
2389
2425
void
2390
2426
os_file_read_string(
2391
2427
/*================*/
2392
FILE* file, /* in: file to read from */
2393
char* str, /* in: buffer where to read */
2394
ulint size) /* in: size of buffer */
2428
FILE* file, /*!< in: file to read from */
2429
char* str, /*!< in: buffer where to read */
2430
ulint size) /*!< in: size of buffer */
2395
2431
{
2396
2432
size_t flen;
2397
2433
2404
2440
str[flen] = '\0';
2405
2441
}
2406
2442
2407
/***********************************************************************
2408
Requests a synchronous write operation. */
2443
/*******************************************************************//**
2444
Requests a synchronous write operation.
2445
@return TRUE if request was successful, FALSE if fail */
2409
2446
UNIV_INTERN
2410
2447
ibool
2411
2448
os_file_write(
2412
2449
/*==========*/
2413
/* out: TRUE if request was
2414
successful, FALSE if fail */
2415
const char* name, /* in: name of the file or path as a
2450
const char* name, /*!< in: name of the file or path as a
2416
2451
null-terminated string */
2417
os_file_t file, /* in: handle to a file */
2418
const void* buf, /* in: buffer from which to write */
2419
ulint offset, /* in: least significant 32 bits of file
2452
os_file_t file, /*!< in: handle to a file */
2453
const void* buf, /*!< in: buffer from which to write */
2454
ulint offset, /*!< in: least significant 32 bits of file
2420
2455
offset where to write */
2421
ulint offset_high, /* in: most significant 32 bits of
2456
ulint offset_high, /*!< in: most significant 32 bits of
2422
2457
offset */
2423
ulint n) /* in: number of bytes to write */
2458
ulint n) /*!< in: number of bytes to write */
2424
2459
{
2425
2460
#ifdef __WIN__
2426
2461
BOOL ret;
2472
2507
"InnoDB: Some operating system error numbers"
2473
2508
" are described at\n"
2474
2509
"InnoDB: "
2475
"http://dev.mysql.com/doc/refman/5.1/en/"
2476
"operating-system-error-codes.html\n",
2510
REFMAN "operating-system-error-codes.html\n",
2477
2511
name, (ulong) offset_high, (ulong) offset,
2478
2512
(ulong) GetLastError());
2479
2513
2544
2578
"InnoDB: Some operating system error numbers"
2545
2579
" are described at\n"
2546
2580
"InnoDB: "
2547
"http://dev.mysql.com/doc/refman/5.1/en/"
2548
"operating-system-error-codes.html\n");
2581
REFMAN "operating-system-error-codes.html\n");
2549
2582
2550
2583
os_has_said_disk_full = TRUE;
2551
2584
}
2587
2620
"InnoDB: Some operating system error numbers"
2588
2621
" are described at\n"
2589
2622
"InnoDB: "
2590
"http://dev.mysql.com/doc/refman/5.1/en/"
2591
"operating-system-error-codes.html\n");
2623
REFMAN "operating-system-error-codes.html\n");
2592
2624
2593
2625
os_has_said_disk_full = TRUE;
2594
2626
}
2597
2629
#endif
2598
2630
}
2599
2631
2600
/***********************************************************************
2601
Check the existence and type of the given file. */
2632
/*******************************************************************//**
2633
Check the existence and type of the given file.
2634
@return TRUE if call succeeded */
2602
2635
UNIV_INTERN
2603
2636
ibool
2604
2637
os_file_status(
2605
2638
/*===========*/
2606
/* out: TRUE if call succeeded */
2607
const char* path, /* in: pathname of the file */
2608
ibool* exists, /* out: TRUE if file exists */
2609
os_file_type_t* type) /* out: type of the file (if it exists) */
2639
const char* path, /*!< in: pathname of the file */
2640
ibool* exists, /*!< out: TRUE if file exists */
2641
os_file_type_t* type) /*!< out: type of the file (if it exists) */
2610
2642
{
2611
2643
#ifdef __WIN__
2612
2644
int ret;
2669
2701
#endif
2670
2702
}
2671
2703
2672
/***********************************************************************
2673
This function returns information about the specified file */
2704
/*******************************************************************//**
2705
This function returns information about the specified file
2706
@return TRUE if stat information found */
2674
2707
UNIV_INTERN
2675
2708
ibool
2676
2709
os_file_get_status(
2677
2710
/*===============*/
2678
/* out: TRUE if stat
2679
information found */
2680
const char* path, /* in: pathname of the file */
2681
os_file_stat_t* stat_info) /* information of a file in a
2711
const char* path, /*!< in: pathname of the file */
2712
os_file_stat_t* stat_info) /*!< information of a file in a
2682
2713
directory */
2683
2714
{
2684
2715
#ifdef __WIN__
2755
2786
# define OS_FILE_PATH_SEPARATOR '/'
2756
2787
#endif
2757
2788
2758
/********************************************************************
2789
/****************************************************************//**
2759
2790
The function os_file_dirname returns a directory component of a
2760
2791
null-terminated pathname string. In the usual case, dirname returns
2761
2792
the string up to, but not including, the final '/', and basename
2781
2812
"/" "/" "/"
2782
2813
"." "." "."
2783
2814
".." "." ".."
2784
*/
2815
2816
@return own: directory component of the pathname */
2785
2817
UNIV_INTERN
2786
2818
char*
2787
2819
os_file_dirname(
2788
2820
/*============*/
2789
/* out, own: directory component of the
2790
pathname */
2791
const char* path) /* in: pathname */
2821
const char* path) /*!< in: pathname */
2792
2822
{
2793
2823
/* Find the offset of the last slash */
2794
2824
const char* last_slash = strrchr(path, OS_FILE_PATH_SEPARATOR);
2811
2841
return(mem_strdupl(path, last_slash - path));
2812
2842
}
2813
2843
2814
/********************************************************************
2815
Creates all missing subdirectories along the given path. */
2844
/****************************************************************//**
2845
Creates all missing subdirectories along the given path.
2846
@return TRUE if call succeeded FALSE otherwise */
2816
2847
UNIV_INTERN
2817
2848
ibool
2818
2849
os_file_create_subdirs_if_needed(
2819
2850
/*=============================*/
2820
/* out: TRUE if call succeeded
2821
FALSE otherwise */
2822
const char* path) /* in: path name */
2851
const char* path) /*!< in: path name */
2823
2852
{
2824
2853
char* subdir;
2825
2854
ibool success, subdir_exists;
2852
2881
return(success);
2853
2882
}
2854
2883
2855
/********************************************************************
2856
Returns a pointer to the nth slot in the aio array. */
2884
#ifndef UNIV_HOTBACKUP
2885
/****************************************************************//**
2886
Returns a pointer to the nth slot in the aio array.
2887
@return pointer to slot */
2857
2888
static
2858
2889
os_aio_slot_t*
2859
2890
os_aio_array_get_nth_slot(
2860
2891
/*======================*/
2861
/* out: pointer to slot */
2862
os_aio_array_t* array, /* in: aio array */
2863
ulint index) /* in: index of the slot */
2892
os_aio_array_t* array, /*!< in: aio array */
2893
ulint index) /*!< in: index of the slot */
2864
2894
{
2865
2895
ut_a(index < array->n_slots);
2866
2896
2867
2897
return((array->slots) + index);
2868
2898
}
2869
2899
2870
/****************************************************************************
2871
Creates an aio wait array. */
2900
/************************************************************************//**
2901
Creates an aio wait array.
2902
@return own: aio array */
2872
2903
static
2873
2904
os_aio_array_t*
2874
2905
os_aio_array_create(
2875
2906
/*================*/
2876
/* out, own: aio array */
2877
ulint n, /* in: maximum number of pending aio operations
2907
ulint n, /*!< in: maximum number of pending aio operations
2878
2908
allowed; n must be divisible by n_segments */
2879
ulint n_segments) /* in: number of segments in the aio array */
2909
ulint n_segments) /*!< in: number of segments in the aio array */
2880
2910
{
2881
2911
os_aio_array_t* array;
2882
2912
ulint i;
2921
2951
return(array);
2922
2952
}
2923
2953
2924
/****************************************************************************
2925
Initializes the asynchronous io system. Calls also os_io_init_simple.
2926
Creates a separate aio array for
2927
non-ibuf read and write, a third aio array for the ibuf i/o, with just one
2928
segment, two aio arrays for log reads and writes with one segment, and a
2929
synchronous aio array of the specified size. The combined number of segments
2930
in the three first aio arrays is the parameter n_segments given to the
2931
function. The caller must create an i/o handler thread for each segment in
2932
the four first arrays, but not for the sync aio array. */
2954
/***********************************************************************
2955
Initializes the asynchronous io system. Creates one array each for ibuf
2956
and log i/o. Also creates one array each for read and write where each
2957
array is divided logically into n_read_segs and n_write_segs
2958
respectively. The caller must create an i/o handler thread for each
2959
segment in these arrays. This function also creates the sync array.
2960
No i/o handler thread needs to be created for that */
2933
2961
UNIV_INTERN
2934
2962
void
2935
2963
os_aio_init(
2936
2964
/*========*/
2937
ulint n, /* in: maximum number of pending aio operations
2938
allowed; n must be divisible by n_segments */
2939
ulint n_segments, /* in: combined number of segments in the four
2940
first aio arrays; must be >= 4 */
2941
ulint n_slots_sync) /* in: number of slots in the sync aio array */
2965
ulint n_per_seg, /*<! in: maximum number of pending aio
2966
operations allowed per segment */
2967
ulint n_read_segs, /*<! in: number of reader threads */
2968
ulint n_write_segs, /*<! in: number of writer threads */
2969
ulint n_slots_sync) /*<! in: number of slots in the sync aio
2970
array */
2942
2971
{
2943
ulint n_read_segs;
2944
ulint n_write_segs;
2945
ulint n_per_seg;
2946
2972
ulint i;
2973
ulint n_segments = 2 + n_read_segs + n_write_segs;
2947
2974
2948
ut_ad(n % n_segments == 0);
2949
2975
ut_ad(n_segments >= 4);
2950
2976
2951
2977
os_io_init_simple();
2954
2980
srv_set_io_thread_op_info(i, "not started yet");
2955
2981
}
2956
2982
2957
n_per_seg = n / n_segments;
2958
n_write_segs = (n_segments - 2) / 2;
2959
n_read_segs = n_segments - 2 - n_write_segs;
2960
2983
2961
2984
/* fprintf(stderr, "Array n per seg %lu\n", n_per_seg); */
2962
2985
2999
3022
}
3000
3023
3001
3024
#ifdef WIN_ASYNC_IO
3002
/****************************************************************************
3025
/************************************************************************//**
3003
3026
Wakes up all async i/o threads in the array in Windows async i/o at
3004
3027
shutdown. */
3005
3028
static
3006
3029
void
3007
3030
os_aio_array_wake_win_aio_at_shutdown(
3008
3031
/*==================================*/
3009
os_aio_array_t* array) /* in: aio array */
3032
os_aio_array_t* array) /*!< in: aio array */
3010
3033
{
3011
3034
ulint i;
3012
3035
3017
3040
}
3018
3041
#endif
3019
3042
3020
/****************************************************************************
3043
/************************************************************************//**
3021
3044
Wakes up all async i/o threads so that they know to exit themselves in
3022
3045
shutdown. */
3023
3046
UNIV_INTERN
3042
3065
}
3043
3066
}
3044
3067
3045
/****************************************************************************
3068
/************************************************************************//**
3046
3069
Waits until there are no pending writes in os_aio_write_array. There can
3047
3070
be other, synchronous, pending writes. */
3048
3071
UNIV_INTERN
3053
3076
os_event_wait(os_aio_write_array->is_empty);
3054
3077
}
3055
3078
3056
/**************************************************************************
3057
Calculates segment number for a slot. */
3079
/**********************************************************************//**
3080
Calculates segment number for a slot.
3081
@return segment number (which is the number used by, for example,
3082
i/o-handler threads) */
3058
3083
static
3059
3084
ulint
3060
3085
os_aio_get_segment_no_from_slot(
3061
3086
/*============================*/
3062
/* out: segment number (which is the number
3063
used by, for example, i/o-handler threads) */
3064
os_aio_array_t* array, /* in: aio wait array */
3065
os_aio_slot_t* slot) /* in: slot in this array */
3087
os_aio_array_t* array, /*!< in: aio wait array */
3088
os_aio_slot_t* slot) /*!< in: slot in this array */
3066
3089
{
3067
3090
ulint segment;
3068
3091
ulint seg_len;
3090
3113
return(segment);
3091
3114
}
3092
3115
3093
/**************************************************************************
3094
Calculates local segment number and aio array from global segment number. */
3116
/**********************************************************************//**
3117
Calculates local segment number and aio array from global segment number.
3118
@return local segment number within the aio array */
3095
3119
static
3096
3120
ulint
3097
3121
os_aio_get_array_and_local_segment(
3098
3122
/*===============================*/
3099
/* out: local segment number within
3100
the aio array */
3101
os_aio_array_t** array, /* out: aio wait array */
3102
ulint global_segment)/* in: global segment number */
3123
os_aio_array_t** array, /*!< out: aio wait array */
3124
ulint global_segment)/*!< in: global segment number */
3103
3125
{
3104
3126
ulint segment;
3105
3127
3126
3148
return(segment);
3127
3149
}
3128
3150
3129
/***********************************************************************
3151
/*******************************************************************//**
3130
3152
Requests for a slot in the aio array. If no slot is available, waits until
3131
not_full-event becomes signaled. */
3153
not_full-event becomes signaled.
3154
@return pointer to slot */
3132
3155
static
3133
3156
os_aio_slot_t*
3134
3157
os_aio_array_reserve_slot(
3135
3158
/*======================*/
3136
/* out: pointer to slot */
3137
ulint type, /* in: OS_FILE_READ or OS_FILE_WRITE */
3138
os_aio_array_t* array, /* in: aio array */
3139
fil_node_t* message1,/* in: message to be passed along with
3140
the aio operation */
3141
void* message2,/* in: message to be passed along with
3142
the aio operation */
3143
os_file_t file, /* in: file handle */
3144
const char* name, /* in: name of the file or path as a
3159
ulint type, /*!< in: OS_FILE_READ or OS_FILE_WRITE */
3160
os_aio_array_t* array, /*!< in: aio array */
3161
fil_node_t* message1,/*!< in: message to be passed along with
3162
the aio operation */
3163
void* message2,/*!< in: message to be passed along with
3164
the aio operation */
3165
os_file_t file, /*!< in: file handle */
3166
const char* name, /*!< in: name of the file or path as a
3145
3167
null-terminated string */
3146
void* buf, /* in: buffer where to read or from which
3168
void* buf, /*!< in: buffer where to read or from which
3147
3169
to write */
3148
ulint offset, /* in: least significant 32 bits of file
3149
offset */
3150
ulint offset_high, /* in: most significant 32 bits of
3151
offset */
3152
ulint len) /* in: length of the block to read or write */
3170
ulint offset, /*!< in: least significant 32 bits of file
3171
offset */
3172
ulint offset_high, /*!< in: most significant 32 bits of
3173
offset */
3174
ulint len) /*!< in: length of the block to read or write */
3153
3175
{
3154
3176
os_aio_slot_t* slot;
3155
3177
#ifdef WIN_ASYNC_IO
3156
3178
OVERLAPPED* control;
3157
3179
#endif
3158
3180
ulint i;
3181
ulint slots_per_seg;
3182
ulint local_seg;
3183
3184
/* No need of a mutex. Only reading constant fields */
3185
slots_per_seg = array->n_slots / array->n_segments;
3186
3187
/* We attempt to keep adjacent blocks in the same local
3188
segment. This can help in merging IO requests when we are
3189
doing simulated AIO */
3190
local_seg = (offset >> (UNIV_PAGE_SIZE_SHIFT + 6))
3191
% array->n_segments;
3192
3159
3193
loop:
3160
3194
os_mutex_enter(array->mutex);
3161
3195
3174
3208
goto loop;
3175
3209
}
3176
3210
3211
/* First try to find a slot in the preferred local segment */
3212
for (i = local_seg * slots_per_seg; i < array->n_slots; i++) {
3213
slot = os_aio_array_get_nth_slot(array, i);
3214
3215
if (slot->reserved == FALSE) {
3216
goto found;
3217
}
3218
}
3219
3220
/* Fall back to a full scan. We are guaranteed to find a slot */
3177
3221
for (i = 0;; i++) {
3178
3222
slot = os_aio_array_get_nth_slot(array, i);
3179
3223
3180
3224
if (slot->reserved == FALSE) {
3181
break;
3225
goto found;
3182
3226
}
3183
3227
}
3184
3228
3229
found:
3230
ut_a(slot->reserved == FALSE);
3185
3231
array->n_reserved++;
3186
3232
3187
3233
if (array->n_reserved == 1) {
3217
3263
return(slot);
3218
3264
}
3219
3265
3220
/***********************************************************************
3266
/*******************************************************************//**
3221
3267
Frees a slot in the aio array. */
3222
3268
static
3223
3269
void
3224
3270
os_aio_array_free_slot(
3225
3271
/*===================*/
3226
os_aio_array_t* array, /* in: aio array */
3227
os_aio_slot_t* slot) /* in: pointer to slot */
3272
os_aio_array_t* array, /*!< in: aio array */
3273
os_aio_slot_t* slot) /*!< in: pointer to slot */
3228
3274
{
3229
3275
ut_ad(array);
3230
3276
ut_ad(slot);
3251
3297
os_mutex_exit(array->mutex);
3252
3298
}
3253
3299
3254
/**************************************************************************
3300
/**********************************************************************//**
3255
3301
Wakes up a simulated aio i/o-handler thread if it has something to do. */
3256
3302
static
3257
3303
void
3258
3304
os_aio_simulated_wake_handler_thread(
3259
3305
/*=================================*/
3260
ulint global_segment) /* in: the number of the segment in the aio
3306
ulint global_segment) /*!< in: the number of the segment in the aio
3261
3307
arrays */
3262
3308
{
3263
3309
os_aio_array_t* array;
3293
3339
}
3294
3340
}
3295
3341
3296
/**************************************************************************
3342
/**********************************************************************//**
3297
3343
Wakes up simulated aio i/o-handler threads if they have something to do. */
3298
3344
UNIV_INTERN
3299
3345
void
3315
3361
}
3316
3362
}
3317
3363
3318
/**************************************************************************
3364
/**********************************************************************//**
3319
3365
This function can be called if one wants to post a batch of reads and
3320
3366
prefers an i/o-handler thread to handle them all at once later. You must
3321
3367
call os_aio_simulated_wake_handler_threads later to ensure the threads
3340
3386
}
3341
3387
}
3342
3388
3343
/***********************************************************************
3344
Requests an asynchronous i/o operation. */
3389
/*******************************************************************//**
3390
Requests an asynchronous i/o operation.
3391
@return TRUE if request was queued successfully, FALSE if fail */
3345
3392
UNIV_INTERN
3346
3393
ibool
3347
3394
os_aio(
3348
3395
/*===*/
3349
/* out: TRUE if request was queued
3350
successfully, FALSE if fail */
3351
ulint type, /* in: OS_FILE_READ or OS_FILE_WRITE */
3352
ulint mode, /* in: OS_AIO_NORMAL, ..., possibly ORed
3396
ulint type, /*!< in: OS_FILE_READ or OS_FILE_WRITE */
3397
ulint mode, /*!< in: OS_AIO_NORMAL, ..., possibly ORed
3353
3398
to OS_AIO_SIMULATED_WAKE_LATER: the
3354
3399
last flag advises this function not to wake
3355
3400
i/o-handler threads, but the caller will
3362
3407
because i/os are not actually handled until
3363
3408
all have been posted: use with great
3364
3409
caution! */
3365
const char* name, /* in: name of the file or path as a
3410
const char* name, /*!< in: name of the file or path as a
3366
3411
null-terminated string */
3367
os_file_t file, /* in: handle to a file */
3368
void* buf, /* in: buffer where to read or from which
3412
os_file_t file, /*!< in: handle to a file */
3413
void* buf, /*!< in: buffer where to read or from which
3369
3414
to write */
3370
ulint offset, /* in: least significant 32 bits of file
3415
ulint offset, /*!< in: least significant 32 bits of file
3371
3416
offset where to read or write */
3372
ulint offset_high, /* in: most significant 32 bits of
3417
ulint offset_high, /*!< in: most significant 32 bits of
3373
3418
offset */
3374
ulint n, /* in: number of bytes to read or write */
3375
fil_node_t* message1,/* in: messages for the aio handler (these
3376
can be used to identify a completed aio
3377
operation); if mode is OS_AIO_SYNC, these
3378
are ignored */
3379
void* message2)
3419
ulint n, /*!< in: number of bytes to read or write */
3420
fil_node_t* message1,/*!< in: message for the aio handler
3421
(can be used to identify a completed
3422
aio operation); ignored if mode is
3423
OS_AIO_SYNC */
3424
void* message2)/*!< in: message for the aio handler
3425
(can be used to identify a completed
3426
aio operation); ignored if mode is
3427
OS_AIO_SYNC */
3380
3428
{
3381
3429
os_aio_array_t* array;
3382
3430
os_aio_slot_t* slot;
3532
3580
}
3533
3581
3534
3582
#ifdef WIN_ASYNC_IO
3535
/**************************************************************************
3583
/**********************************************************************//**
3536
3584
This function is only used in Windows asynchronous i/o.
3537
3585
Waits for an aio operation to complete. This function is used to wait the
3538
3586
for completed requests. The aio array of pending requests is divided
3539
3587
into segments. The thread specifies which segment or slot it wants to wait
3540
3588
for. NOTE: this function will also take care of freeing the aio slot,
3541
therefore no other thread is allowed to do the freeing! */
3589
therefore no other thread is allowed to do the freeing!
3590
@return TRUE if the aio operation succeeded */
3542
3591
UNIV_INTERN
3543
3592
ibool
3544
3593
os_aio_windows_handle(
3545
3594
/*==================*/
3546
/* out: TRUE if the aio operation succeeded */
3547
ulint segment, /* in: the number of the segment in the aio
3595
ulint segment, /*!< in: the number of the segment in the aio
3548
3596
arrays to wait for; segment 0 is the ibuf
3549
3597
i/o thread, segment 1 the log i/o thread,
3550
3598
then follow the non-ibuf read threads, and as
3552
3600
this is ULINT_UNDEFINED, then it means that
3553
3601
sync aio is used, and this parameter is
3554
3602
ignored */
3555
ulint pos, /* this parameter is used only in sync aio:
3603
ulint pos, /*!< this parameter is used only in sync aio:
3556
3604
wait for the aio slot at this position */
3557
fil_node_t**message1, /* out: the messages passed with the aio
3605
fil_node_t**message1, /*!< out: the messages passed with the aio
3558
3606
request; note that also in the case where
3559
3607
the aio operation failed, these output
3560
3608
parameters are valid and can be used to
3561
3609
restart the operation, for example */
3562
3610
void** message2,
3563
ulint* type) /* out: OS_FILE_WRITE or ..._READ */
3611
ulint* type) /*!< out: OS_FILE_WRITE or ..._READ */
3564
3612
{
3565
3613
ulint orig_seg = segment;
3566
3614
os_aio_array_t* array;
3637
3685
}
3638
3686
#endif
3639
3687
3640
/**************************************************************************
3688
/**********************************************************************//**
3641
3689
Does simulated aio. This function should be called by an i/o-handler
3642
thread. */
3690
thread.
3691
@return TRUE if the aio operation succeeded */
3643
3692
UNIV_INTERN
3644
3693
ibool
3645
3694
os_aio_simulated_handle(
3646
3695
/*====================*/
3647
/* out: TRUE if the aio operation succeeded */
3648
ulint global_segment, /* in: the number of the segment in the aio
3696
ulint global_segment, /*!< in: the number of the segment in the aio
3649
3697
arrays to wait for; segment 0 is the ibuf
3650
3698
i/o thread, segment 1 the log i/o thread,
3651
3699
then follow the non-ibuf read threads, and as
3652
3700
the last are the non-ibuf write threads */
3653
fil_node_t**message1, /* out: the messages passed with the aio
3701
fil_node_t**message1, /*!< out: the messages passed with the aio
3654
3702
request; note that also in the case where
3655
3703
the aio operation failed, these output
3656
3704
parameters are valid and can be used to
3657
3705
restart the operation, for example */
3658
3706
void** message2,
3659
ulint* type) /* out: OS_FILE_WRITE or ..._READ */
3707
ulint* type) /*!< out: OS_FILE_WRITE or ..._READ */
3660
3708
{
3661
3709
os_aio_array_t* array;
3662
3710
ulint segment;
3958
4006
goto restart;
3959
4007
}
3960
4008
3961
/**************************************************************************
3962
Validates the consistency of an aio array. */
4009
/**********************************************************************//**
4010
Validates the consistency of an aio array.
4011
@return TRUE if ok */
3963
4012
static
3964
4013
ibool
3965
4014
os_aio_array_validate(
3966
4015
/*==================*/
3967
/* out: TRUE if ok */
3968
os_aio_array_t* array) /* in: aio wait array */
4016
os_aio_array_t* array) /*!< in: aio wait array */
3969
4017
{
3970
4018
os_aio_slot_t* slot;
3971
4019
ulint n_reserved = 0;
3994
4042
return(TRUE);
3995
4043
}
3996
4044
3997
/**************************************************************************
3998
Validates the consistency the aio system. */
4045
/**********************************************************************//**
4046
Validates the consistency the aio system.
4047
@return TRUE if ok */
3999
4048
UNIV_INTERN
4000
4049
ibool
4001
4050
os_aio_validate(void)
4002
4051
/*=================*/
4003
/* out: TRUE if ok */
4004
4052
{
4005
4053
os_aio_array_validate(os_aio_read_array);
4006
4054
os_aio_array_validate(os_aio_write_array);
4011
4059
return(TRUE);
4012
4060
}
4013
4061
4014
/**************************************************************************
4062
/**********************************************************************//**
4015
4063
Prints info of the aio arrays. */
4016
4064
UNIV_INTERN
4017
4065
void
4018
4066
os_aio_print(
4019
4067
/*=========*/
4020
FILE* file) /* in: file where to print */
4068
FILE* file) /*!< in: file where to print */
4021
4069
{
4022
4070
os_aio_array_t* array;
4023
4071
os_aio_slot_t* slot;
4148
4196
os_last_printout = current_time;
4149
4197
}
4150
4198
4151
/**************************************************************************
4199
/**********************************************************************//**
4152
4200
Refreshes the statistics used to print per-second averages. */
4153
4201
UNIV_INTERN
4154
4202
void
4164
4212
}
4165
4213
4166
4214
#ifdef UNIV_DEBUG
4167
/**************************************************************************
4215
/**********************************************************************//**
4168
4216
Checks that all slots in the system have been freed, that is, there are
4169
no pending io operations. */
4217
no pending io operations.
4218
@return TRUE if all free */
4170
4219
UNIV_INTERN
4171
4220
ibool
4172
4221
os_aio_all_slots_free(void)
4173
4222
/*=======================*/
4174
/* out: TRUE if all free */
4175
4223
{
4176
4224
os_aio_array_t* array;
4177
4225
ulint n_res = 0;
4224
4272
return(FALSE);
4225
4273
}
4226
4274
#endif /* UNIV_DEBUG */
4275
4276
#endif /* !UNIV_HOTBACKUP */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1