← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/os0file.h

  • Committer: Monty Taylor
  • Date: 2008-09-16 00:00:48 UTC
  • mto: This revision was merged to the branch mainline in revision 391.
  • Revision ID: monty@inaugust.com-20080916000048-3rvrv3gv9l0ad3gs
Fixed copyright headers in drizzled/

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/os0file.h
 
1
/******************************************************
 
2
The interface to the operating system file io
 
3
 
 
4
(c) 1995 Innobase Oy
 
5
 
 
6
Created 10/21/1995 Heikki Tuuri
 
7
*******************************************************/
 
8
 
 
9
#ifndef os0file_h
 
10
#define os0file_h
 
11
 
 
12
#include "univ.i"
 
13
 
 
14
#ifndef __WIN__
 
15
#include <dirent.h>
 
16
#include <sys/stat.h>
 
17
#include <time.h>
 
18
#endif
 
19
 
 
20
typedef struct fil_node_struct  fil_node_t;
 
21
 
 
22
#ifdef UNIV_DO_FLUSH
 
23
extern ibool    os_do_not_call_flush_at_each_write;
 
24
#endif /* UNIV_DO_FLUSH */
 
25
extern ibool    os_has_said_disk_full;
 
26
extern ibool    os_aio_print_debug;
 
27
 
 
28
extern ulint    os_file_n_pending_preads;
 
29
extern ulint    os_file_n_pending_pwrites;
 
30
 
 
31
extern ulint    os_n_pending_reads;
 
32
extern ulint    os_n_pending_writes;
 
33
 
 
34
#ifdef __WIN__
 
35
 
 
36
/* We define always WIN_ASYNC_IO, and check at run-time whether
 
37
   the OS actually supports it: Win 95 does not, NT does. */
 
38
#define WIN_ASYNC_IO
 
39
 
 
40
#define UNIV_NON_BUFFERED_IO
 
41
 
 
42
#endif
 
43
 
 
44
#ifdef __WIN__
 
45
#define os_file_t       HANDLE
 
46
#else
 
47
typedef int     os_file_t;
 
48
#endif
 
49
 
 
50
extern ulint    os_innodb_umask;
 
51
 
 
52
/* If this flag is TRUE, then we will use the native aio of the
 
53
OS (provided we compiled Innobase with it in), otherwise we will
 
54
use simulated aio we build below with threads */
 
55
 
 
56
extern ibool    os_aio_use_native_aio;
 
57
 
 
58
#define OS_FILE_SECTOR_SIZE             512
 
59
 
 
60
/* The next value should be smaller or equal to the smallest sector size used
 
61
on any disk. A log block is required to be a portion of disk which is written
 
62
so that if the start and the end of a block get written to disk, then the
 
63
whole block gets written. This should be true even in most cases of a crash:
 
64
if this fails for a log block, then it is equivalent to a media failure in the
 
65
log. */
 
66
 
 
67
#define OS_FILE_LOG_BLOCK_SIZE          512
 
68
 
 
69
/* Options for file_create */
 
70
#define OS_FILE_OPEN                    51
 
71
#define OS_FILE_CREATE                  52
 
72
#define OS_FILE_OVERWRITE               53
 
73
#define OS_FILE_OPEN_RAW                54
 
74
#define OS_FILE_CREATE_PATH             55
 
75
#define OS_FILE_OPEN_RETRY              56      /* for os_file_create() on
 
76
                                                the first ibdata file */
 
77
 
 
78
#define OS_FILE_READ_ONLY               333
 
79
#define OS_FILE_READ_WRITE              444
 
80
#define OS_FILE_READ_ALLOW_DELETE       555     /* for ibbackup */
 
81
 
 
82
/* Options for file_create */
 
83
#define OS_FILE_AIO                     61
 
84
#define OS_FILE_NORMAL                  62
 
85
 
 
86
/* Types for file create */
 
87
#define OS_DATA_FILE                    100
 
88
#define OS_LOG_FILE                     101
 
89
 
 
90
/* Error codes from os_file_get_last_error */
 
91
#define OS_FILE_NOT_FOUND               71
 
92
#define OS_FILE_DISK_FULL               72
 
93
#define OS_FILE_ALREADY_EXISTS          73
 
94
#define OS_FILE_PATH_ERROR              74
 
95
#define OS_FILE_AIO_RESOURCES_RESERVED  75      /* wait for OS aio resources
 
96
                                                to become available again */
 
97
#define OS_FILE_SHARING_VIOLATION       76
 
98
#define OS_FILE_ERROR_NOT_SPECIFIED     77
 
99
 
 
100
/* Types for aio operations */
 
101
#define OS_FILE_READ    10
 
102
#define OS_FILE_WRITE   11
 
103
 
 
104
#define OS_FILE_LOG     256     /* This can be ORed to type */
 
105
 
 
106
#define OS_AIO_N_PENDING_IOS_PER_THREAD 32      /* Win NT does not allow more
 
107
                                                than 64 */
 
108
 
 
109
/* Modes for aio operations */
 
110
#define OS_AIO_NORMAL   21      /* Normal asynchronous i/o not for ibuf
 
111
                                pages or ibuf bitmap pages */
 
112
#define OS_AIO_IBUF     22      /* Asynchronous i/o for ibuf pages or ibuf
 
113
                                bitmap pages */
 
114
#define OS_AIO_LOG      23      /* Asynchronous i/o for the log */
 
115
#define OS_AIO_SYNC     24      /* Asynchronous i/o where the calling thread
 
116
                                will itself wait for the i/o to complete,
 
117
                                doing also the job of the i/o-handler thread;
 
118
                                can be used for any pages, ibuf or non-ibuf.
 
119
                                This is used to save CPU time, as we can do
 
120
                                with fewer thread switches. Plain synchronous
 
121
                                i/o is not as good, because it must serialize
 
122
                                the file seek and read or write, causing a
 
123
                                bottleneck for parallelism. */
 
124
 
 
125
#define OS_AIO_SIMULATED_WAKE_LATER     512 /* This can be ORed to mode
 
126
                                in the call of os_aio(...),
 
127
                                if the caller wants to post several i/o
 
128
                                requests in a batch, and only after that
 
129
                                wake the i/o-handler thread; this has
 
130
                                effect only in simulated aio */
 
131
#define OS_WIN31        1
 
132
#define OS_WIN95        2
 
133
#define OS_WINNT        3
 
134
#define OS_WIN2000      4
 
135
 
 
136
extern ulint    os_n_file_reads;
 
137
extern ulint    os_n_file_writes;
 
138
extern ulint    os_n_fsyncs;
 
139
 
 
140
/* File types for directory entry data type */
 
141
 
 
142
enum os_file_type_enum{
 
143
        OS_FILE_TYPE_UNKNOWN = 0,
 
144
        OS_FILE_TYPE_FILE,                      /* regular file */
 
145
        OS_FILE_TYPE_DIR,                       /* directory */
 
146
        OS_FILE_TYPE_LINK                       /* symbolic link */
 
147
};
 
148
typedef enum os_file_type_enum    os_file_type_t;
 
149
 
 
150
/* Maximum path string length in bytes when referring to tables with in the
 
151
'./databasename/tablename.ibd' path format; we can allocate at least 2 buffers
 
152
of this size from the thread stack; that is why this should not be made much
 
153
bigger than 4000 bytes */
 
154
#define OS_FILE_MAX_PATH        4000
 
155
 
 
156
/* Struct used in fetching information of a file in a directory */
 
157
struct os_file_stat_struct{
 
158
        char            name[OS_FILE_MAX_PATH]; /* path to a file */
 
159
        os_file_type_t  type;                   /* file type */
 
160
        ib_longlong     size;                   /* file size */
 
161
        time_t          ctime;                  /* creation time */
 
162
        time_t          mtime;                  /* modification time */
 
163
        time_t          atime;                  /* access time */
 
164
};
 
165
typedef struct os_file_stat_struct      os_file_stat_t;
 
166
 
 
167
#ifdef __WIN__
 
168
typedef HANDLE  os_file_dir_t;  /* directory stream */
 
169
#else
 
170
typedef DIR*    os_file_dir_t;  /* directory stream */
 
171
#endif
 
172
 
 
173
/***************************************************************************
 
174
Gets the operating system version. Currently works only on Windows. */
 
175
 
 
176
ulint
 
177
os_get_os_version(void);
 
178
/*===================*/
 
179
                  /* out: OS_WIN95, OS_WIN31, OS_WINNT, or OS_WIN2000 */
 
180
/********************************************************************
 
181
Creates the seek mutexes used in positioned reads and writes. */
 
182
 
 
183
void
 
184
os_io_init_simple(void);
 
185
/*===================*/
 
186
/***************************************************************************
 
187
Creates a temporary file.  This function is like tmpfile(3), but
 
188
the temporary file is created in the MySQL temporary directory.
 
189
On Netware, this function is like tmpfile(3), because the C run-time
 
190
library of Netware does not expose the delete-on-close flag. */
 
191
 
 
192
FILE*
 
193
os_file_create_tmpfile(void);
 
194
/*========================*/
 
195
                        /* out: temporary file handle, or NULL on error */
 
196
/***************************************************************************
 
197
The os_file_opendir() function opens a directory stream corresponding to the
 
198
directory named by the dirname argument. The directory stream is positioned
 
199
at the first entry. In both Unix and Windows we automatically skip the '.'
 
200
and '..' items at the start of the directory listing. */
 
201
 
 
202
os_file_dir_t
 
203
os_file_opendir(
 
204
/*============*/
 
205
                                        /* out: directory stream, NULL if
 
206
                                        error */
 
207
        const char*     dirname,        /* in: directory name; it must not
 
208
                                        contain a trailing '\' or '/' */
 
209
        ibool           error_is_fatal);/* in: TRUE if we should treat an
 
210
                                        error as a fatal error; if we try to
 
211
                                        open symlinks then we do not wish a
 
212
                                        fatal error if it happens not to be
 
213
                                        a directory */
 
214
/***************************************************************************
 
215
Closes a directory stream. */
 
216
 
 
217
int
 
218
os_file_closedir(
 
219
/*=============*/
 
220
                                /* out: 0 if success, -1 if failure */
 
221
        os_file_dir_t   dir);   /* in: directory stream */
 
222
/***************************************************************************
 
223
This function returns information of the next file in the directory. We jump
 
224
over the '.' and '..' entries in the directory. */
 
225
 
 
226
int
 
227
os_file_readdir_next_file(
 
228
/*======================*/
 
229
                                /* out: 0 if ok, -1 if error, 1 if at the end
 
230
                                of the directory */
 
231
        const char*     dirname,/* in: directory name or path */
 
232
        os_file_dir_t   dir,    /* in: directory stream */
 
233
        os_file_stat_t* info);  /* in/out: buffer where the info is returned */
 
234
/*********************************************************************
 
235
This function attempts to create a directory named pathname. The new directory
 
236
gets default permissions. On Unix, the permissions are (0770 & ~umask). If the
 
237
directory exists already, nothing is done and the call succeeds, unless the
 
238
fail_if_exists arguments is true. */
 
239
 
 
240
ibool
 
241
os_file_create_directory(
 
242
/*=====================*/
 
243
                                        /* out: TRUE if call succeeds,
 
244
                                        FALSE on error */
 
245
        const char*     pathname,       /* in: directory name as
 
246
                                        null-terminated string */
 
247
        ibool           fail_if_exists);/* in: if TRUE, pre-existing directory
 
248
                                        is treated as an error. */
 
249
/********************************************************************
 
250
A simple function to open or create a file. */
 
251
 
 
252
os_file_t
 
253
os_file_create_simple(
 
254
/*==================*/
 
255
                                /* out, own: handle to the file, not defined
 
256
                                if error, error number can be retrieved with
 
257
                                os_file_get_last_error */
 
258
        const char*     name,   /* in: name of the file or path as a
 
259
                                null-terminated string */
 
260
        ulint           create_mode,/* in: OS_FILE_OPEN if an existing file is
 
261
                                opened (if does not exist, error), or
 
262
                                OS_FILE_CREATE if a new file is created
 
263
                                (if exists, error), or
 
264
                                OS_FILE_CREATE_PATH if new file
 
265
                                (if exists, error) and subdirectories along
 
266
                                its path are created (if needed)*/
 
267
        ulint           access_type,/* in: OS_FILE_READ_ONLY or
 
268
                                OS_FILE_READ_WRITE */
 
269
        ibool*          success);/* out: TRUE if succeed, FALSE if error */
 
270
/********************************************************************
 
271
A simple function to open or create a file. */
 
272
 
 
273
os_file_t
 
274
os_file_create_simple_no_error_handling(
 
275
/*====================================*/
 
276
                                /* out, own: handle to the file, not defined
 
277
                                if error, error number can be retrieved with
 
278
                                os_file_get_last_error */
 
279
        const char*     name,   /* in: name of the file or path as a
 
280
                                null-terminated string */
 
281
        ulint           create_mode,/* in: OS_FILE_OPEN if an existing file
 
282
                                is opened (if does not exist, error), or
 
283
                                OS_FILE_CREATE if a new file is created
 
284
                                (if exists, error) */
 
285
        ulint           access_type,/* in: OS_FILE_READ_ONLY,
 
286
                                OS_FILE_READ_WRITE, or
 
287
                                OS_FILE_READ_ALLOW_DELETE; the last option is
 
288
                                used by a backup program reading the file */
 
289
        ibool*          success);/* out: TRUE if succeed, FALSE if error */
 
290
/********************************************************************
 
291
Opens an existing file or creates a new. */
 
292
 
 
293
os_file_t
 
294
os_file_create(
 
295
/*===========*/
 
296
                                /* out, own: handle to the file, not defined
 
297
                                if error, error number can be retrieved with
 
298
                                os_file_get_last_error */
 
299
        const char*     name,   /* in: name of the file or path as a
 
300
                                null-terminated string */
 
301
        ulint           create_mode,/* in: OS_FILE_OPEN if an existing file
 
302
                                is opened (if does not exist, error), or
 
303
                                OS_FILE_CREATE if a new file is created
 
304
                                (if exists, error),
 
305
                                OS_FILE_OVERWRITE if a new file is created
 
306
                                or an old overwritten;
 
307
                                OS_FILE_OPEN_RAW, if a raw device or disk
 
308
                                partition should be opened */
 
309
        ulint           purpose,/* in: OS_FILE_AIO, if asynchronous,
 
310
                                non-buffered i/o is desired,
 
311
                                OS_FILE_NORMAL, if any normal file;
 
312
                                NOTE that it also depends on type, os_aio_..
 
313
                                and srv_.. variables whether we really use
 
314
                                async i/o or unbuffered i/o: look in the
 
315
                                function source code for the exact rules */
 
316
        ulint           type,   /* in: OS_DATA_FILE or OS_LOG_FILE */
 
317
        ibool*          success);/* out: TRUE if succeed, FALSE if error */
 
318
/***************************************************************************
 
319
Deletes a file. The file has to be closed before calling this. */
 
320
 
 
321
ibool
 
322
os_file_delete(
 
323
/*===========*/
 
324
                                /* out: TRUE if success */
 
325
        const char*     name);  /* in: file path as a null-terminated string */
 
326
 
 
327
/***************************************************************************
 
328
Deletes a file if it exists. The file has to be closed before calling this. */
 
329
 
 
330
ibool
 
331
os_file_delete_if_exists(
 
332
/*=====================*/
 
333
                                /* out: TRUE if success */
 
334
        const char*     name);  /* in: file path as a null-terminated string */
 
335
/***************************************************************************
 
336
Renames a file (can also move it to another directory). It is safest that the
 
337
file is closed before calling this function. */
 
338
 
 
339
ibool
 
340
os_file_rename(
 
341
/*===========*/
 
342
                                        /* out: TRUE if success */
 
343
        const char*     oldpath,        /* in: old file path as a
 
344
                                        null-terminated string */
 
345
        const char*     newpath);       /* in: new file path */
 
346
/***************************************************************************
 
347
Closes a file handle. In case of error, error number can be retrieved with
 
348
os_file_get_last_error. */
 
349
 
 
350
ibool
 
351
os_file_close(
 
352
/*==========*/
 
353
                                /* out: TRUE if success */
 
354
        os_file_t       file);  /* in, own: handle to a file */
 
355
/***************************************************************************
 
356
Closes a file handle. */
 
357
 
 
358
ibool
 
359
os_file_close_no_error_handling(
 
360
/*============================*/
 
361
                                /* out: TRUE if success */
 
362
        os_file_t       file);  /* in, own: handle to a file */
 
363
/***************************************************************************
 
364
Gets a file size. */
 
365
 
 
366
ibool
 
367
os_file_get_size(
 
368
/*=============*/
 
369
                                /* out: TRUE if success */
 
370
        os_file_t       file,   /* in: handle to a file */
 
371
        ulint*          size,   /* out: least significant 32 bits of file
 
372
                                size */
 
373
        ulint*          size_high);/* out: most significant 32 bits of size */
 
374
/***************************************************************************
 
375
Gets file size as a 64-bit integer ib_longlong. */
 
376
 
 
377
ib_longlong
 
378
os_file_get_size_as_iblonglong(
 
379
/*===========================*/
 
380
                                /* out: size in bytes, -1 if error */
 
381
        os_file_t       file);  /* in: handle to a file */
 
382
/***************************************************************************
 
383
Write the specified number of zeros to a newly created file. */
 
384
 
 
385
ibool
 
386
os_file_set_size(
 
387
/*=============*/
 
388
                                /* out: TRUE if success */
 
389
        const char*     name,   /* in: name of the file or path as a
 
390
                                null-terminated string */
 
391
        os_file_t       file,   /* in: handle to a file */
 
392
        ulint           size,   /* in: least significant 32 bits of file
 
393
                                size */
 
394
        ulint           size_high);/* in: most significant 32 bits of size */
 
395
/***************************************************************************
 
396
Truncates a file at its current position. */
 
397
 
 
398
ibool
 
399
os_file_set_eof(
 
400
/*============*/
 
401
                                /* out: TRUE if success */
 
402
        FILE*           file);  /* in: file to be truncated */
 
403
/***************************************************************************
 
404
Flushes the write buffers of a given file to the disk. */
 
405
 
 
406
ibool
 
407
os_file_flush(
 
408
/*==========*/
 
409
                                /* out: TRUE if success */
 
410
        os_file_t       file);  /* in, own: handle to a file */
 
411
/***************************************************************************
 
412
Retrieves the last error number if an error occurs in a file io function.
 
413
The number should be retrieved before any other OS calls (because they may
 
414
overwrite the error number). If the number is not known to this program,
 
415
the OS error number + 100 is returned. */
 
416
 
 
417
ulint
 
418
os_file_get_last_error(
 
419
/*===================*/
 
420
                                        /* out: error number, or OS error
 
421
                                        number + 100 */
 
422
        ibool   report_all_errors);     /* in: TRUE if we want an error message
 
423
                                        printed of all errors */
 
424
/***********************************************************************
 
425
Requests a synchronous read operation. */
 
426
 
 
427
ibool
 
428
os_file_read(
 
429
/*=========*/
 
430
                                /* out: TRUE if request was
 
431
                                successful, FALSE if fail */
 
432
        os_file_t       file,   /* in: handle to a file */
 
433
        void*           buf,    /* in: buffer where to read */
 
434
        ulint           offset, /* in: least significant 32 bits of file
 
435
                                offset where to read */
 
436
        ulint           offset_high,/* in: most significant 32 bits of
 
437
                                offset */
 
438
        ulint           n);     /* in: number of bytes to read */
 
439
/***********************************************************************
 
440
Rewind file to its start, read at most size - 1 bytes from it to str, and
 
441
NUL-terminate str. All errors are silently ignored. This function is
 
442
mostly meant to be used with temporary files. */
 
443
 
 
444
void
 
445
os_file_read_string(
 
446
/*================*/
 
447
        FILE*   file,   /* in: file to read from */
 
448
        char*   str,    /* in: buffer where to read */
 
449
        ulint   size);  /* in: size of buffer */
 
450
/***********************************************************************
 
451
Requests a synchronous positioned read operation. This function does not do
 
452
any error handling. In case of error it returns FALSE. */
 
453
 
 
454
ibool
 
455
os_file_read_no_error_handling(
 
456
/*===========================*/
 
457
                                /* out: TRUE if request was
 
458
                                successful, FALSE if fail */
 
459
        os_file_t       file,   /* in: handle to a file */
 
460
        void*           buf,    /* in: buffer where to read */
 
461
        ulint           offset, /* in: least significant 32 bits of file
 
462
                                offset where to read */
 
463
        ulint           offset_high,/* in: most significant 32 bits of
 
464
                                offset */
 
465
        ulint           n);     /* in: number of bytes to read */
 
466
 
 
467
/***********************************************************************
 
468
Requests a synchronous write operation. */
 
469
 
 
470
ibool
 
471
os_file_write(
 
472
/*==========*/
 
473
                                /* out: TRUE if request was
 
474
                                successful, FALSE if fail */
 
475
        const char*     name,   /* in: name of the file or path as a
 
476
                                null-terminated string */
 
477
        os_file_t       file,   /* in: handle to a file */
 
478
        const void*     buf,    /* in: buffer from which to write */
 
479
        ulint           offset, /* in: least significant 32 bits of file
 
480
                                offset where to write */
 
481
        ulint           offset_high,/* in: most significant 32 bits of
 
482
                                offset */
 
483
        ulint           n);     /* in: number of bytes to write */
 
484
/***********************************************************************
 
485
Check the existence and type of the given file. */
 
486
 
 
487
ibool
 
488
os_file_status(
 
489
/*===========*/
 
490
                                /* out: TRUE if call succeeded */
 
491
        const char*     path,   /* in:  pathname of the file */
 
492
        ibool*          exists, /* out: TRUE if file exists */
 
493
        os_file_type_t* type);  /* out: type of the file (if it exists) */
 
494
/********************************************************************
 
495
The function os_file_dirname returns a directory component of a
 
496
null-terminated pathname string.  In the usual case, dirname returns
 
497
the string up to, but not including, the final '/', and basename
 
498
is the component following the final '/'.  Trailing '/' charac�
 
499
ters are not counted as part of the pathname.
 
500
 
 
501
If path does not contain a slash, dirname returns the string ".".
 
502
 
 
503
Concatenating the string returned by dirname, a "/", and the basename
 
504
yields a complete pathname.
 
505
 
 
506
The return value is  a copy of the directory component of the pathname.
 
507
The copy is allocated from heap. It is the caller responsibility
 
508
to free it after it is no longer needed.
 
509
 
 
510
The following list of examples (taken from SUSv2) shows the strings
 
511
returned by dirname and basename for different paths:
 
512
 
 
513
       path           dirname        basename
 
514
       "/usr/lib"     "/usr"         "lib"
 
515
       "/usr/"        "/"            "usr"
 
516
       "usr"          "."            "usr"
 
517
       "/"            "/"            "/"
 
518
       "."            "."            "."
 
519
       ".."           "."            ".."
 
520
*/
 
521
 
 
522
char*
 
523
os_file_dirname(
 
524
/*============*/
 
525
                                /* out, own: directory component of the
 
526
                                pathname */
 
527
        const char*     path);  /* in: pathname */
 
528
/********************************************************************
 
529
Creates all missing subdirectories along the given path. */
 
530
 
 
531
ibool
 
532
os_file_create_subdirs_if_needed(
 
533
/*=============================*/
 
534
                                /* out: TRUE if call succeeded
 
535
                                   FALSE otherwise */
 
536
        const char*     path);  /* in: path name */
 
537
/****************************************************************************
 
538
Initializes the asynchronous io system. Creates separate aio array for
 
539
non-ibuf read and write, a third aio array for the ibuf i/o, with just one
 
540
segment, two aio arrays for log reads and writes with one segment, and a
 
541
synchronous aio array of the specified size. The combined number of segments
 
542
in the three first aio arrays is the parameter n_segments given to the
 
543
function. The caller must create an i/o handler thread for each segment in
 
544
the four first arrays, but not for the sync aio array. */
 
545
 
 
546
void
 
547
os_aio_init(
 
548
/*========*/
 
549
        ulint   n,              /* in: maximum number of pending aio operations
 
550
                                allowed; n must be divisible by n_segments */
 
551
        ulint   n_segments,     /* in: combined number of segments in the four
 
552
                                first aio arrays; must be >= 4 */
 
553
        ulint   n_slots_sync);  /* in: number of slots in the sync aio array */
 
554
/***********************************************************************
 
555
Requests an asynchronous i/o operation. */
 
556
 
 
557
ibool
 
558
os_aio(
 
559
/*===*/
 
560
                                /* out: TRUE if request was queued
 
561
                                successfully, FALSE if fail */
 
562
        ulint           type,   /* in: OS_FILE_READ or OS_FILE_WRITE */
 
563
        ulint           mode,   /* in: OS_AIO_NORMAL, ..., possibly ORed
 
564
                                to OS_AIO_SIMULATED_WAKE_LATER: the
 
565
                                last flag advises this function not to wake
 
566
                                i/o-handler threads, but the caller will
 
567
                                do the waking explicitly later, in this
 
568
                                way the caller can post several requests in
 
569
                                a batch; NOTE that the batch must not be
 
570
                                so big that it exhausts the slots in aio
 
571
                                arrays! NOTE that a simulated batch
 
572
                                may introduce hidden chances of deadlocks,
 
573
                                because i/os are not actually handled until
 
574
                                all have been posted: use with great
 
575
                                caution! */
 
576
        const char*     name,   /* in: name of the file or path as a
 
577
                                null-terminated string */
 
578
        os_file_t       file,   /* in: handle to a file */
 
579
        void*           buf,    /* in: buffer where to read or from which
 
580
                                to write */
 
581
        ulint           offset, /* in: least significant 32 bits of file
 
582
                                offset where to read or write */
 
583
        ulint           offset_high, /* in: most significant 32 bits of
 
584
                                offset */
 
585
        ulint           n,      /* in: number of bytes to read or write */
 
586
        fil_node_t*     message1,/* in: messages for the aio handler (these
 
587
                                can be used to identify a completed aio
 
588
                                operation); if mode is OS_AIO_SYNC, these
 
589
                                are ignored */
 
590
        void*           message2);
 
591
/****************************************************************************
 
592
Wakes up all async i/o threads so that they know to exit themselves in
 
593
shutdown. */
 
594
 
 
595
void
 
596
os_aio_wake_all_threads_at_shutdown(void);
 
597
/*=====================================*/
 
598
/****************************************************************************
 
599
Waits until there are no pending writes in os_aio_write_array. There can
 
600
be other, synchronous, pending writes. */
 
601
 
 
602
void
 
603
os_aio_wait_until_no_pending_writes(void);
 
604
/*=====================================*/
 
605
/**************************************************************************
 
606
Wakes up simulated aio i/o-handler threads if they have something to do. */
 
607
 
 
608
void
 
609
os_aio_simulated_wake_handler_threads(void);
 
610
/*=======================================*/
 
611
/**************************************************************************
 
612
This function can be called if one wants to post a batch of reads and
 
613
prefers an i/o-handler thread to handle them all at once later. You must
 
614
call os_aio_simulated_wake_handler_threads later to ensure the threads
 
615
are not left sleeping! */
 
616
 
 
617
void
 
618
os_aio_simulated_put_read_threads_to_sleep(void);
 
619
/*============================================*/
 
620
 
 
621
#ifdef WIN_ASYNC_IO
 
622
/**************************************************************************
 
623
This function is only used in Windows asynchronous i/o.
 
624
Waits for an aio operation to complete. This function is used to wait the
 
625
for completed requests. The aio array of pending requests is divided
 
626
into segments. The thread specifies which segment or slot it wants to wait
 
627
for. NOTE: this function will also take care of freeing the aio slot,
 
628
therefore no other thread is allowed to do the freeing! */
 
629
 
 
630
ibool
 
631
os_aio_windows_handle(
 
632
/*==================*/
 
633
                                /* out: TRUE if the aio operation succeeded */
 
634
        ulint   segment,        /* in: the number of the segment in the aio
 
635
                                arrays to wait for; segment 0 is the ibuf
 
636
                                i/o thread, segment 1 the log i/o thread,
 
637
                                then follow the non-ibuf read threads, and as
 
638
                                the last are the non-ibuf write threads; if
 
639
                                this is ULINT_UNDEFINED, then it means that
 
640
                                sync aio is used, and this parameter is
 
641
                                ignored */
 
642
        ulint   pos,            /* this parameter is used only in sync aio:
 
643
                                wait for the aio slot at this position */
 
644
        fil_node_t**message1,   /* out: the messages passed with the aio
 
645
                                request; note that also in the case where
 
646
                                the aio operation failed, these output
 
647
                                parameters are valid and can be used to
 
648
                                restart the operation, for example */
 
649
        void**  message2,
 
650
        ulint*  type);          /* out: OS_FILE_WRITE or ..._READ */
 
651
#endif
 
652
 
 
653
/* Currently we do not use Posix async i/o */
 
654
#ifdef POSIX_ASYNC_IO
 
655
/**************************************************************************
 
656
This function is only used in Posix asynchronous i/o. Waits for an aio
 
657
operation to complete. */
 
658
 
 
659
ibool
 
660
os_aio_posix_handle(
 
661
/*================*/
 
662
                                /* out: TRUE if the aio operation succeeded */
 
663
        ulint   array_no,       /* in: array number 0 - 3 */
 
664
        fil_node_t**message1,   /* out: the messages passed with the aio
 
665
                                request; note that also in the case where
 
666
                                the aio operation failed, these output
 
667
                                parameters are valid and can be used to
 
668
                                restart the operation, for example */
 
669
        void**  message2);
 
670
#endif
 
671
/**************************************************************************
 
672
Does simulated aio. This function should be called by an i/o-handler
 
673
thread. */
 
674
 
 
675
ibool
 
676
os_aio_simulated_handle(
 
677
/*====================*/
 
678
                                /* out: TRUE if the aio operation succeeded */
 
679
        ulint   segment,        /* in: the number of the segment in the aio
 
680
                                arrays to wait for; segment 0 is the ibuf
 
681
                                i/o thread, segment 1 the log i/o thread,
 
682
                                then follow the non-ibuf read threads, and as
 
683
                                the last are the non-ibuf write threads */
 
684
        fil_node_t**message1,   /* out: the messages passed with the aio
 
685
                                request; note that also in the case where
 
686
                                the aio operation failed, these output
 
687
                                parameters are valid and can be used to
 
688
                                restart the operation, for example */
 
689
        void**  message2,
 
690
        ulint*  type);          /* out: OS_FILE_WRITE or ..._READ */
 
691
/**************************************************************************
 
692
Validates the consistency of the aio system. */
 
693
 
 
694
ibool
 
695
os_aio_validate(void);
 
696
/*=================*/
 
697
                                /* out: TRUE if ok */
 
698
/**************************************************************************
 
699
Prints info of the aio arrays. */
 
700
 
 
701
void
 
702
os_aio_print(
 
703
/*=========*/
 
704
        FILE*   file);  /* in: file where to print */
 
705
/**************************************************************************
 
706
Refreshes the statistics used to print per-second averages. */
 
707
 
 
708
void
 
709
os_aio_refresh_stats(void);
 
710
/*======================*/
 
711
 
 
712
#ifdef UNIV_DEBUG
 
713
/**************************************************************************
 
714
Checks that all slots in the system have been freed, that is, there are
 
715
no pending io operations. */
 
716
 
 
717
ibool
 
718
os_aio_all_slots_free(void);
 
719
/*=======================*/
 
720
#endif /* UNIV_DEBUG */
 
721
 
 
722
/***********************************************************************
 
723
This function returns information about the specified file */
 
724
ibool
 
725
os_file_get_status(
 
726
/*===============*/
 
727
                                        /* out: TRUE if stat
 
728
                                        information found */
 
729
        const char*     path,           /* in:  pathname of the file */
 
730
        os_file_stat_t* stat_info);     /* information of a file in a
 
731
                                        directory */
 
732
 
 
733
#endif