← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

Merge initial InnoDB+ import.

This was applied by generating a patch between MySQL 5.1.50 InnoDB plugin and
the just-merged innodb+ from mysql-trunk revision-id: vasil.dimov@oracle.com-20100422110752-1zowoqxel5xx3z2e

Then, some manual merge resolving and it worked. This should make it much
easier to merge the rest of InnoDB 1.1 and 1.2 from the mysql tree using
my bzr-reapply script.

This takes us to InnoDB 1.1.1(ish).

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/os0file.h
76
76
 
77
77
#ifdef __WIN__
78
78
/** File handle */
79
 
#define os_file_t       HANDLE
 
79
# define os_file_t      HANDLE
80
80
/** Convert a C file descriptor to a native file handle
81
81
@param fd       file descriptor
82
82
@return         native file handle */
83
 
#define OS_FILE_FROM_FD(fd) (HANDLE) _get_osfhandle(fd)
 
83
# define OS_FILE_FROM_FD(fd) (HANDLE) _get_osfhandle(fd)
84
84
#else
85
85
/** File handle */
86
86
typedef int     os_file_t;
87
87
/** Convert a C file descriptor to a native file handle
88
88
@param fd       file descriptor
89
89
@return         native file handle */
90
 
#define OS_FILE_FROM_FD(fd) fd
 
90
# define OS_FILE_FROM_FD(fd) fd
91
91
#endif
92
92
 
93
93
/** Umask for creating files */
94
94
extern ulint    os_innodb_umask;
95
95
 
96
 
/** If this flag is TRUE, then we will use the native aio of the
97
 
OS (provided we compiled Innobase with it in), otherwise we will
98
 
use simulated aio we build below with threads */
99
 
 
100
 
extern ibool    os_aio_use_native_aio;
101
 
 
102
96
/** The next value should be smaller or equal to the smallest sector size used
103
97
on any disk. A log block is required to be a portion of disk which is written
104
98
so that if the start and the end of a block get written to disk, then the
141
135
#define OS_FILE_SHARING_VIOLATION       76
142
136
#define OS_FILE_ERROR_NOT_SPECIFIED     77
143
137
#define OS_FILE_INSUFFICIENT_RESOURCE   78
144
 
#define OS_FILE_OPERATION_ABORTED       79
 
138
#define OS_FILE_AIO_INTERRUPTED         79
 
139
#define OS_FILE_OPERATION_ABORTED       80
145
140
/* @} */
146
141
 
147
142
/** Types for aio operations @{ */
187
182
extern ulint    os_n_file_writes;
188
183
extern ulint    os_n_fsyncs;
189
184
 
 
185
#ifdef UNIV_PFS_IO
 
186
/* Keys to register InnoDB I/O with performance schema */
 
187
extern mysql_pfs_key_t  innodb_file_data_key;
 
188
extern mysql_pfs_key_t  innodb_file_log_key;
 
189
extern mysql_pfs_key_t  innodb_file_temp_key;
 
190
 
 
191
/* Following four macros are instumentations to register
 
192
various file I/O operations with performance schema.
 
193
1) register_pfs_file_open_begin() and register_pfs_file_open_end() are
 
194
used to register file creation, opening, closing and renaming.
 
195
2) register_pfs_file_io_begin() and register_pfs_file_io_end() are
 
196
used to register actual file read, write and flush */
 
197
# define register_pfs_file_open_begin(locker, key, op, name,            \
 
198
                                      src_file, src_line)               \
 
199
do {                                                                    \
 
200
        if (PSI_server) {                                               \
 
201
                locker = PSI_server->get_thread_file_name_locker(       \
 
202
                        key, op, name, &locker);                        \
 
203
                if (locker) {                                           \
 
204
                        PSI_server->start_file_open_wait(               \
 
205
                                locker, src_file, src_line);            \
 
206
                }                                                       \
 
207
        }                                                               \
 
208
} while (0)
 
209
 
 
210
# define register_pfs_file_open_end(locker, file)                       \
 
211
do {                                                                    \
 
212
        if (locker) {                                                   \
 
213
                PSI_server->end_file_open_wait_and_bind_to_descriptor(  \
 
214
                        locker, file);                                  \
 
215
        }                                                               \
 
216
} while (0)
 
217
 
 
218
# define register_pfs_file_io_begin(locker, file, count, op,            \
 
219
                                    src_file, src_line)                 \
 
220
do {                                                                    \
 
221
        if (PSI_server) {                                               \
 
222
                locker = PSI_server->get_thread_file_descriptor_locker( \
 
223
                        file, op);                                      \
 
224
                if (locker) {                                           \
 
225
                        PSI_server->start_file_wait(                    \
 
226
                                locker, count, src_file, src_line);     \
 
227
                }                                                       \
 
228
        }                                                               \
 
229
} while (0)
 
230
 
 
231
# define register_pfs_file_io_end(locker, count)                        \
 
232
do {                                                                    \
 
233
        if (locker) {                                                   \
 
234
                PSI_server->end_file_wait(locker, count);               \
 
235
        }                                                               \
 
236
} while (0)
 
237
#endif /* UNIV_PFS_IO  */
 
238
 
 
239
/* Following macros/functions are file I/O APIs that would be performance
 
240
schema instrumented if "UNIV_PFS_IO" is defined. They would point to
 
241
wrapper functions with performance schema instrumentation in such case.
 
242
 
 
243
os_file_create
 
244
os_file_create_simple
 
245
os_file_create_simple_no_error_handling
 
246
os_file_close
 
247
os_file_rename
 
248
os_aio
 
249
os_file_read
 
250
os_file_read_no_error_handling
 
251
os_file_write
 
252
 
 
253
The wrapper functions have the prefix of "innodb_". */
 
254
 
 
255
#ifdef UNIV_PFS_IO
 
256
# define os_file_create(key, name, create, purpose, type, success)      \
 
257
        pfs_os_file_create_func(key, name, create, purpose,     type,   \
 
258
                                success, __FILE__, __LINE__)
 
259
 
 
260
# define os_file_create_simple(key, name, create, access, success)      \
 
261
        pfs_os_file_create_simple_func(key, name, create, access,       \
 
262
                                       success, __FILE__, __LINE__)
 
263
 
 
264
# define os_file_create_simple_no_error_handling(                       \
 
265
                key, name, create_mode, access, success)                \
 
266
        pfs_os_file_create_simple_no_error_handling_func(               \
 
267
                key, name, create_mode, access, success, __FILE__, __LINE__)
 
268
 
 
269
# define os_file_close(file)                                            \
 
270
        pfs_os_file_close_func(file, __FILE__, __LINE__)
 
271
 
 
272
# define os_aio(type, mode, name, file, buf, offset, offset_high,       \
 
273
                n, message1, message2)                                  \
 
274
        pfs_os_aio_func(type, mode, name, file, buf, offset,            \
 
275
                        offset_high, n, message1, message2,             \
 
276
                        __FILE__, __LINE__)
 
277
 
 
278
# define os_file_read(file, buf, offset, offset_high, n)                \
 
279
        pfs_os_file_read_func(file, buf, offset, offset_high, n,        \
 
280
                              __FILE__, __LINE__)
 
281
 
 
282
# define os_file_read_no_error_handling(file, buf, offset,              \
 
283
                                        offset_high, n)                 \
 
284
        pfs_os_file_read_no_error_handling_func(file, buf, offset,      \
 
285
                                                offset_high, n,         \
 
286
                                                __FILE__, __LINE__)
 
287
 
 
288
# define os_file_write(name, file, buf, offset, offset_high, n)         \
 
289
        pfs_os_file_write_func(name, file, buf, offset, offset_high,    \
 
290
                               n, __FILE__, __LINE__)
 
291
 
 
292
# define os_file_flush(file)                                            \
 
293
        pfs_os_file_flush_func(file, __FILE__, __LINE__)
 
294
 
 
295
# define os_file_rename(key, oldpath, newpath)                          \
 
296
        pfs_os_file_rename_func(key, oldpath, newpath, __FILE__, __LINE__)
 
297
#else /* UNIV_PFS_IO */
 
298
 
 
299
/* If UNIV_PFS_IO is not defined, these I/O APIs point
 
300
to original un-instrumented file I/O APIs */
 
301
# define os_file_create(key, name, create, purpose, type, success)      \
 
302
        os_file_create_func(name, create, purpose, type, success)
 
303
 
 
304
# define os_file_create_simple(key, name, create, access, success)      \
 
305
        os_file_create_simple_func(name, create_mode, access, success)
 
306
 
 
307
# define os_file_create_simple_no_error_handling(                       \
 
308
                key, name, create_mode, access, success)                \
 
309
        os_file_create_simple_no_error_handling_func(                   \
 
310
                name, create_mode, access, success)
 
311
 
 
312
# define os_file_close(file)    os_file_close_func(file)
 
313
 
 
314
# define os_aio(type, mode, name, file, buf, offset, offset_high,       \
 
315
               n, message1, message2)                                   \
 
316
        os_aio_func(type, mode, name, file, buf, offset, offset_high, n,\
 
317
                    message1, message2)
 
318
 
 
319
# define os_file_read(file, buf, offset, offset_high, n)                \
 
320
        os_file_read_func(file, buf, offset, offset_high, n)
 
321
 
 
322
# define os_file_read_no_error_handling(file, buf, offset,              \
 
323
                                       offset_high, n)                  \
 
324
        os_file_read_no_error_handling_func(file, buf, offset, offset_high, n)
 
325
 
 
326
# define os_file_write(name, file, buf, offset, offset_high, n)         \
 
327
        os_file_write_func(name, file, buf, offset, offset_high, n)
 
328
 
 
329
# define os_file_flush(file)    os_file_flush_func(file)
 
330
 
 
331
# define os_file_rename(key, oldpath, newpath)                          \
 
332
        os_file_rename_func(oldpath, newpath)
 
333
 
 
334
#endif /* UNIV_PFS_IO */
 
335
 
190
336
/* File types for directory entry data type */
191
337
 
192
338
enum os_file_type_enum{
296
442
        ibool           fail_if_exists);/*!< in: if TRUE, pre-existing directory
297
443
                                        is treated as an error. */
298
444
/****************************************************************//**
 
445
NOTE! Use the corresponding macro os_file_create_simple(), not directly
 
446
this function!
299
447
A simple function to open or create a file.
300
448
@return own: handle to the file, not defined if error, error number
301
449
can be retrieved with os_file_get_last_error */
302
450
UNIV_INTERN
303
451
os_file_t
304
 
os_file_create_simple(
305
 
/*==================*/
 
452
os_file_create_simple_func(
 
453
/*=======================*/
306
454
        const char*     name,   /*!< in: name of the file or path as a
307
455
                                null-terminated string */
308
456
        ulint           create_mode,/*!< in: OS_FILE_OPEN if an existing file is
316
464
                                OS_FILE_READ_WRITE */
317
465
        ibool*          success);/*!< out: TRUE if succeed, FALSE if error */
318
466
/****************************************************************//**
 
467
NOTE! Use the corresponding macro
 
468
os_file_create_simple_no_error_handling(), not directly this function!
319
469
A simple function to open or create a file.
320
470
@return own: handle to the file, not defined if error, error number
321
471
can be retrieved with os_file_get_last_error */
322
472
UNIV_INTERN
323
473
os_file_t
324
 
os_file_create_simple_no_error_handling(
325
 
/*====================================*/
 
474
os_file_create_simple_no_error_handling_func(
 
475
/*=========================================*/
326
476
        const char*     name,   /*!< in: name of the file or path as a
327
477
                                null-terminated string */
328
478
        ulint           create_mode,/*!< in: OS_FILE_OPEN if an existing file
346
496
        const char*     operation_name);/*!< in: "open" or "create"; used in the
347
497
                                        diagnostic message */
348
498
/****************************************************************//**
 
499
NOTE! Use the corresponding macro os_file_create(), not directly
 
500
this function!
349
501
Opens an existing file or creates a new.
350
502
@return own: handle to the file, not defined if error, error number
351
503
can be retrieved with os_file_get_last_error */
352
504
UNIV_INTERN
353
505
os_file_t
354
 
os_file_create(
355
 
/*===========*/
 
506
os_file_create_func(
 
507
/*================*/
356
508
        const char*     name,   /*!< in: name of the file or path as a
357
509
                                null-terminated string */
358
510
        ulint           create_mode,/*!< in: OS_FILE_OPEN if an existing file
390
542
/*=====================*/
391
543
        const char*     name);  /*!< in: file path as a null-terminated string */
392
544
/***********************************************************************//**
 
545
NOTE! Use the corresponding macro os_file_rename(), not directly
 
546
this function!
393
547
Renames a file (can also move it to another directory). It is safest that the
394
548
file is closed before calling this function.
395
549
@return TRUE if success */
396
550
UNIV_INTERN
397
551
ibool
398
 
os_file_rename(
399
 
/*===========*/
 
552
os_file_rename_func(
 
553
/*================*/
400
554
        const char*     oldpath,        /*!< in: old file path as a
401
555
                                        null-terminated string */
402
556
        const char*     newpath);       /*!< in: new file path */
403
557
/***********************************************************************//**
 
558
NOTE! Use the corresponding macro os_file_close(), not directly this
 
559
function!
404
560
Closes a file handle. In case of error, error number can be retrieved with
405
561
os_file_get_last_error.
406
562
@return TRUE if success */
407
563
UNIV_INTERN
408
564
ibool
409
 
os_file_close(
410
 
/*==========*/
 
565
os_file_close_func(
 
566
/*===============*/
411
567
        os_file_t       file);  /*!< in, own: handle to a file */
 
568
 
 
569
#ifdef UNIV_PFS_IO
 
570
/****************************************************************//**
 
571
NOTE! Please use the corresponding macro os_file_create_simple(),
 
572
not directly this function!
 
573
A performance schema instrumented wrapper function for
 
574
os_file_create_simple() which opens or creates a file.
 
575
@return own: handle to the file, not defined if error, error number
 
576
can be retrieved with os_file_get_last_error */
 
577
UNIV_INLINE
 
578
os_file_t
 
579
pfs_os_file_create_simple_func(
 
580
/*===========================*/
 
581
        mysql_pfs_key_t key,    /*!< in: Performance Schema Key */
 
582
        const char*     name,   /*!< in: name of the file or path as a
 
583
                                null-terminated string */
 
584
        ulint           create_mode,/*!< in: OS_FILE_OPEN if an existing file is
 
585
                                opened (if does not exist, error), or
 
586
                                OS_FILE_CREATE if a new file is created
 
587
                                (if exists, error), or
 
588
                                OS_FILE_CREATE_PATH if new file
 
589
                                (if exists, error) and subdirectories along
 
590
                                its path are created (if needed)*/
 
591
        ulint           access_type,/*!< in: OS_FILE_READ_ONLY or
 
592
                                OS_FILE_READ_WRITE */
 
593
        ibool*          success,/*!< out: TRUE if succeed, FALSE if error */
 
594
        const char*     src_file,/*!< in: file name where func invoked */
 
595
        ulint           src_line);/*!< in: line where the func invoked */
 
596
 
 
597
/****************************************************************//**
 
598
NOTE! Please use the corresponding macro
 
599
os_file_create_simple_no_error_handling(), not directly this function!
 
600
A performance schema instrumented wrapper function for
 
601
os_file_create_simple_no_error_handling(). Add instrumentation to
 
602
monitor file creation/open.
 
603
@return own: handle to the file, not defined if error, error number
 
604
can be retrieved with os_file_get_last_error */
 
605
UNIV_INLINE
 
606
os_file_t
 
607
pfs_os_file_create_simple_no_error_handling_func(
 
608
/*=============================================*/
 
609
        mysql_pfs_key_t key,    /*!< in: Performance Schema Key */
 
610
        const char*     name,   /*!< in: name of the file or path as a
 
611
                                null-terminated string */
 
612
        ulint           create_mode,/*!< in: OS_FILE_OPEN if an existing file
 
613
                                is opened (if does not exist, error), or
 
614
                                OS_FILE_CREATE if a new file is created
 
615
                                (if exists, error) */
 
616
        ulint           access_type,/*!< in: OS_FILE_READ_ONLY,
 
617
                                OS_FILE_READ_WRITE, or
 
618
                                OS_FILE_READ_ALLOW_DELETE; the last option is
 
619
                                used by a backup program reading the file */
 
620
        ibool*          success,/*!< out: TRUE if succeed, FALSE if error */
 
621
        const char*     src_file,/*!< in: file name where func invoked */
 
622
        ulint           src_line);/*!< in: line where the func invoked */
 
623
 
 
624
/****************************************************************//**
 
625
NOTE! Please use the corresponding macro os_file_create(), not directly
 
626
this function!
 
627
A performance schema wrapper function for os_file_create().
 
628
Add instrumentation to monitor file creation/open.
 
629
@return own: handle to the file, not defined if error, error number
 
630
can be retrieved with os_file_get_last_error */
 
631
UNIV_INLINE
 
632
os_file_t
 
633
pfs_os_file_create_func(
 
634
/*====================*/
 
635
        mysql_pfs_key_t key,    /*!< in: Performance Schema Key */
 
636
        const char*     name,   /*!< in: name of the file or path as a
 
637
                                null-terminated string */
 
638
        ulint           create_mode,/*!< in: OS_FILE_OPEN if an existing file
 
639
                                is opened (if does not exist, error), or
 
640
                                OS_FILE_CREATE if a new file is created
 
641
                                (if exists, error),
 
642
                                OS_FILE_OVERWRITE if a new file is created
 
643
                                or an old overwritten;
 
644
                                OS_FILE_OPEN_RAW, if a raw device or disk
 
645
                                partition should be opened */
 
646
        ulint           purpose,/*!< in: OS_FILE_AIO, if asynchronous,
 
647
                                non-buffered i/o is desired,
 
648
                                OS_FILE_NORMAL, if any normal file;
 
649
                                NOTE that it also depends on type, os_aio_..
 
650
                                and srv_.. variables whether we really use
 
651
                                async i/o or unbuffered i/o: look in the
 
652
                                function source code for the exact rules */
 
653
        ulint           type,   /*!< in: OS_DATA_FILE or OS_LOG_FILE */
 
654
        ibool*          success,/*!< out: TRUE if succeed, FALSE if error */
 
655
        const char*     src_file,/*!< in: file name where func invoked */
 
656
        ulint           src_line);/*!< in: line where the func invoked */
 
657
 
 
658
/***********************************************************************//**
 
659
NOTE! Please use the corresponding macro os_file_close(), not directly
 
660
this function!
 
661
A performance schema instrumented wrapper function for os_file_close().
 
662
@return TRUE if success */
 
663
UNIV_INLINE
 
664
ibool
 
665
pfs_os_file_close_func(
 
666
/*===================*/
 
667
        os_file_t       file,   /*!< in, own: handle to a file */
 
668
        const char*     src_file,/*!< in: file name where func invoked */
 
669
        ulint           src_line);/*!< in: line where the func invoked */
 
670
/*******************************************************************//**
 
671
NOTE! Please use the corresponding macro os_file_read(), not directly
 
672
this function!
 
673
This is the performance schema instrumented wrapper function for
 
674
os_file_read() which requests a synchronous read operation.
 
675
@return TRUE if request was successful, FALSE if fail */
 
676
UNIV_INLINE
 
677
ibool
 
678
pfs_os_file_read_func(
 
679
/*==================*/
 
680
        os_file_t       file,   /*!< in: handle to a file */
 
681
        void*           buf,    /*!< in: buffer where to read */
 
682
        ulint           offset, /*!< in: least significant 32 bits of file
 
683
                                offset where to read */
 
684
        ulint           offset_high,/*!< in: most significant 32 bits of
 
685
                                offset */
 
686
        ulint           n,      /*!< in: number of bytes to read */
 
687
        const char*     src_file,/*!< in: file name where func invoked */
 
688
        ulint           src_line);/*!< in: line where the func invoked */
 
689
 
 
690
/*******************************************************************//**
 
691
NOTE! Please use the corresponding macro os_file_read_no_error_handling(),
 
692
not directly this function!
 
693
This is the performance schema instrumented wrapper function for
 
694
os_file_read_no_error_handling_func() which requests a synchronous
 
695
read operation.
 
696
@return TRUE if request was successful, FALSE if fail */
 
697
UNIV_INLINE
 
698
ibool
 
699
pfs_os_file_read_no_error_handling_func(
 
700
/*====================================*/
 
701
        os_file_t       file,   /*!< in: handle to a file */
 
702
        void*           buf,    /*!< in: buffer where to read */
 
703
        ulint           offset, /*!< in: least significant 32 bits of file
 
704
                                offset where to read */
 
705
        ulint           offset_high,/*!< in: most significant 32 bits of
 
706
                                offset */
 
707
        ulint           n,      /*!< in: number of bytes to read */
 
708
        const char*     src_file,/*!< in: file name where func invoked */
 
709
        ulint           src_line);/*!< in: line where the func invoked */
 
710
 
 
711
/*******************************************************************//**
 
712
NOTE! Please use the corresponding macro os_aio(), not directly this
 
713
function!
 
714
Performance schema wrapper function of os_aio() which requests
 
715
an asynchronous i/o operation.
 
716
@return TRUE if request was queued successfully, FALSE if fail */
 
717
UNIV_INLINE
 
718
ibool
 
719
pfs_os_aio_func(
 
720
/*============*/
 
721
        ulint           type,   /*!< in: OS_FILE_READ or OS_FILE_WRITE */
 
722
        ulint           mode,   /*!< in: OS_AIO_NORMAL etc. I/O mode */
 
723
        const char*     name,   /*!< in: name of the file or path as a
 
724
                                null-terminated string */
 
725
        os_file_t       file,   /*!< in: handle to a file */
 
726
        void*           buf,    /*!< in: buffer where to read or from which
 
727
                                to write */
 
728
        ulint           offset, /*!< in: least significant 32 bits of file
 
729
                                offset where to read or write */
 
730
        ulint           offset_high,/*!< in: most significant 32 bits of
 
731
                                offset */
 
732
        ulint           n,      /*!< in: number of bytes to read or write */
 
733
        fil_node_t*     message1,/*!< in: message for the aio handler
 
734
                                (can be used to identify a completed
 
735
                                aio operation); ignored if mode is
 
736
                                OS_AIO_SYNC */
 
737
        void*           message2,/*!< in: message for the aio handler
 
738
                                (can be used to identify a completed
 
739
                                aio operation); ignored if mode is
 
740
                                OS_AIO_SYNC */
 
741
        const char*     src_file,/*!< in: file name where func invoked */
 
742
        ulint           src_line);/*!< in: line where the func invoked */
 
743
/*******************************************************************//**
 
744
NOTE! Please use the corresponding macro os_file_write(), not directly
 
745
this function!
 
746
This is the performance schema instrumented wrapper function for
 
747
os_file_write() which requests a synchronous write operation.
 
748
@return TRUE if request was successful, FALSE if fail */
 
749
UNIV_INLINE
 
750
ibool
 
751
pfs_os_file_write_func(
 
752
/*===================*/
 
753
        const char*     name,   /*!< in: name of the file or path as a
 
754
                                null-terminated string */
 
755
        os_file_t       file,   /*!< in: handle to a file */
 
756
        const void*     buf,    /*!< in: buffer from which to write */
 
757
        ulint           offset, /*!< in: least significant 32 bits of file
 
758
                                offset where to write */
 
759
        ulint           offset_high,/*!< in: most significant 32 bits of
 
760
                                offset */
 
761
        ulint           n,      /*!< in: number of bytes to write */
 
762
        const char*     src_file,/*!< in: file name where func invoked */
 
763
        ulint           src_line);/*!< in: line where the func invoked */
 
764
/***********************************************************************//**
 
765
NOTE! Please use the corresponding macro os_file_flush(), not directly
 
766
this function!
 
767
This is the performance schema instrumented wrapper function for
 
768
os_file_flush() which flushes the write buffers of a given file to the disk.
 
769
Flushes the write buffers of a given file to the disk.
 
770
@return TRUE if success */
 
771
UNIV_INLINE
 
772
ibool
 
773
pfs_os_file_flush_func(
 
774
/*===================*/
 
775
        os_file_t       file,   /*!< in, own: handle to a file */
 
776
        const char*     src_file,/*!< in: file name where func invoked */
 
777
        ulint           src_line);/*!< in: line where the func invoked */
 
778
 
 
779
/***********************************************************************//**
 
780
NOTE! Please use the corresponding macro os_file_rename(), not directly
 
781
this function!
 
782
This is the performance schema instrumented wrapper function for
 
783
os_file_rename()
 
784
@return TRUE if success */
 
785
UNIV_INLINE
 
786
ibool
 
787
pfs_os_file_rename_func(
 
788
/*====================*/
 
789
        mysql_pfs_key_t key,    /*!< in: Performance Schema Key */
 
790
        const char*     oldpath,/*!< in: old file path as a null-terminated
 
791
                                string */
 
792
        const char*     newpath,/*!< in: new file path */
 
793
        const char*     src_file,/*!< in: file name where func invoked */
 
794
        ulint           src_line);/*!< in: line where the func invoked */
 
795
#endif  /* UNIV_PFS_IO */
 
796
 
412
797
#ifdef UNIV_HOTBACKUP
413
798
/***********************************************************************//**
414
799
Closes a file handle.
460
845
/*============*/
461
846
        FILE*           file);  /*!< in: file to be truncated */
462
847
/***********************************************************************//**
 
848
NOTE! Use the corresponding macro os_file_flush(), not directly this function!
463
849
Flushes the write buffers of a given file to the disk.
464
850
@return TRUE if success */
465
851
UNIV_INTERN
466
852
ibool
467
 
os_file_flush(
468
 
/*==========*/
 
853
os_file_flush_func(
 
854
/*===============*/
469
855
        os_file_t       file);  /*!< in, own: handle to a file */
470
856
/***********************************************************************//**
471
857
Retrieves the last error number if an error occurs in a file io function.
480
866
        ibool   report_all_errors);     /*!< in: TRUE if we want an error message
481
867
                                        printed of all errors */
482
868
/*******************************************************************//**
 
869
NOTE! Use the corresponding macro os_file_read(), not directly this function!
483
870
Requests a synchronous read operation.
484
871
@return TRUE if request was successful, FALSE if fail */
485
872
UNIV_INTERN
486
873
ibool
487
 
os_file_read(
488
 
/*=========*/
 
874
os_file_read_func(
 
875
/*==============*/
489
876
        os_file_t       file,   /*!< in: handle to a file */
490
877
        void*           buf,    /*!< in: buffer where to read */
491
878
        ulint           offset, /*!< in: least significant 32 bits of file
505
892
        char*   str,    /*!< in: buffer where to read */
506
893
        ulint   size);  /*!< in: size of buffer */
507
894
/*******************************************************************//**
 
895
NOTE! Use the corresponding macro os_file_read_no_error_handling(),
 
896
not directly this function!
508
897
Requests a synchronous positioned read operation. This function does not do
509
898
any error handling. In case of error it returns FALSE.
510
899
@return TRUE if request was successful, FALSE if fail */
511
900
UNIV_INTERN
512
901
ibool
513
 
os_file_read_no_error_handling(
514
 
/*===========================*/
 
902
os_file_read_no_error_handling_func(
 
903
/*================================*/
515
904
        os_file_t       file,   /*!< in: handle to a file */
516
905
        void*           buf,    /*!< in: buffer where to read */
517
906
        ulint           offset, /*!< in: least significant 32 bits of file
521
910
        ulint           n);     /*!< in: number of bytes to read */
522
911
 
523
912
/*******************************************************************//**
 
913
NOTE! Use the corresponding macro os_file_write(), not directly this
 
914
function!
524
915
Requests a synchronous write operation.
525
916
@return TRUE if request was successful, FALSE if fail */
526
917
UNIV_INTERN
527
918
ibool
528
 
os_file_write(
529
 
/*==========*/
 
919
os_file_write_func(
 
920
/*===============*/
530
921
        const char*     name,   /*!< in: name of the file or path as a
531
922
                                null-terminated string */
532
923
        os_file_t       file,   /*!< in: handle to a file */
595
986
segment in these arrays. This function also creates the sync array.
596
987
No i/o handler thread needs to be created for that */
597
988
UNIV_INTERN
598
 
void
 
989
ibool
599
990
os_aio_init(
600
991
/*========*/
601
992
        ulint   n_per_seg,      /*<! in: maximum number of pending aio
612
1003
/*=============*/
613
1004
 
614
1005
/*******************************************************************//**
 
1006
NOTE! Use the corresponding macro os_aio(), not directly this function!
615
1007
Requests an asynchronous i/o operation.
616
1008
@return TRUE if request was queued successfully, FALSE if fail */
617
1009
UNIV_INTERN
618
1010
ibool
619
 
os_aio(
620
 
/*===*/
 
1011
os_aio_func(
 
1012
/*========*/
621
1013
        ulint           type,   /*!< in: OS_FILE_READ or OS_FILE_WRITE */
622
1014
        ulint           mode,   /*!< in: OS_AIO_NORMAL, ..., possibly ORed
623
1015
                                to OS_AIO_SIMULATED_WAKE_LATER: the
785
1177
/*========================*/
786
1178
#endif /* !UNIV_HOTBACKUP && !__NETWARE__ */
787
1179
 
 
1180
 
 
1181
#if defined(LINUX_NATIVE_AIO)
 
1182
/**************************************************************************
 
1183
This function is only used in Linux native asynchronous i/o.
 
1184
Waits for an aio operation to complete. This function is used to wait the
 
1185
for completed requests. The aio array of pending requests is divided
 
1186
into segments. The thread specifies which segment or slot it wants to wait
 
1187
for. NOTE: this function will also take care of freeing the aio slot,
 
1188
therefore no other thread is allowed to do the freeing!
 
1189
@return TRUE if the IO was successful */
 
1190
UNIV_INTERN
 
1191
ibool
 
1192
os_aio_linux_handle(
 
1193
/*================*/
 
1194
        ulint   global_seg,     /*!< in: segment number in the aio array
 
1195
                                to wait for; segment 0 is the ibuf
 
1196
                                i/o thread, segment 1 is log i/o thread,
 
1197
                                then follow the non-ibuf read threads,
 
1198
                                and the last are the non-ibuf write
 
1199
                                threads. */
 
1200
        fil_node_t**message1,   /*!< out: the messages passed with the */
 
1201
        void**  message2,       /*!< aio request; note that in case the
 
1202
                                aio operation failed, these output
 
1203
                                parameters are valid and can be used to
 
1204
                                restart the operation. */
 
1205
        ulint*  type);          /*!< out: OS_FILE_WRITE or ..._READ */
 
1206
#endif /* LINUX_NATIVE_AIO */
 
1207
 
 
1208
#ifndef UNIV_NONINL
 
1209
#include "os0file.ic"
 
1210
#endif
 
1211
 
788
1212
#endif