mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 20:42:30 +01:00
599 lines
17 KiB
C++
599 lines
17 KiB
C++
/*****************************************************************************
|
|
|
|
Copyright (c) 2010, 2017, Oracle and/or its affiliates. All Rights Reserved.
|
|
Copyright (c) 2013, 2019, MariaDB Corporation.
|
|
|
|
This program is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free Software
|
|
Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/**************************************************//**
|
|
@file include/os0file.ic
|
|
The interface to the operating system file io
|
|
|
|
Created 2/20/2010 Jimmy Yang
|
|
*******************************************************/
|
|
|
|
#ifdef UNIV_PFS_IO
|
|
/** NOTE! Please use the corresponding macro os_file_create_simple(),
|
|
not directly this function!
|
|
A performance schema instrumented wrapper function for
|
|
os_file_create_simple() which opens or creates a file.
|
|
@param[in] key Performance Schema Key
|
|
@param[in] name name of the file or path as a null-terminated
|
|
string
|
|
@param[in] create_mode create mode
|
|
@param[in] access_type OS_FILE_READ_ONLY or OS_FILE_READ_WRITE
|
|
@param[in] read_only if true read only mode checks are enforced
|
|
@param[out] success true if succeeded
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return own: handle to the file, not defined if error, error number
|
|
can be retrieved with os_file_get_last_error */
|
|
UNIV_INLINE
|
|
pfs_os_file_t
|
|
pfs_os_file_create_simple_func(
|
|
mysql_pfs_key_t key,
|
|
const char* name,
|
|
ulint create_mode,
|
|
ulint access_type,
|
|
bool read_only,
|
|
bool* success,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
/* register a file open or creation depending on "create_mode" */
|
|
register_pfs_file_open_begin(
|
|
&state, locker, key,
|
|
(create_mode == OS_FILE_CREATE)
|
|
? PSI_FILE_CREATE : PSI_FILE_OPEN,
|
|
name, src_file, src_line);
|
|
|
|
pfs_os_file_t file = os_file_create_simple_func(
|
|
name, create_mode, access_type, read_only, success);
|
|
|
|
/* Register psi value for the file */
|
|
register_pfs_file_open_end(locker, file,
|
|
(*success == TRUE ? success : 0));
|
|
|
|
return(file);
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro
|
|
os_file_create_simple_no_error_handling(), not directly this function!
|
|
A performance schema instrumented wrapper function for
|
|
os_file_create_simple_no_error_handling(). Add instrumentation to
|
|
monitor file creation/open.
|
|
@param[in] key Performance Schema Key
|
|
@param[in] name name of the file or path as a null-terminated
|
|
string
|
|
@param[in] create_mode create mode
|
|
@param[in] access_type OS_FILE_READ_ONLY, OS_FILE_READ_WRITE, or
|
|
OS_FILE_READ_ALLOW_DELETE; the last option is
|
|
used by a backup program reading the file
|
|
@param[in] read_only if true read only mode checks are enforced
|
|
@param[out] success true if succeeded
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return own: handle to the file, not defined if error, error number
|
|
can be retrieved with os_file_get_last_error */
|
|
UNIV_INLINE
|
|
pfs_os_file_t
|
|
pfs_os_file_create_simple_no_error_handling_func(
|
|
mysql_pfs_key_t key,
|
|
const char* name,
|
|
ulint create_mode,
|
|
ulint access_type,
|
|
bool read_only,
|
|
bool* success,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
/* register a file open or creation depending on "create_mode" */
|
|
register_pfs_file_open_begin(
|
|
&state, locker, key,
|
|
create_mode == OS_FILE_CREATE
|
|
? PSI_FILE_CREATE : PSI_FILE_OPEN,
|
|
name, src_file, src_line);
|
|
|
|
pfs_os_file_t file = os_file_create_simple_no_error_handling_func(
|
|
name, create_mode, access_type, read_only, success);
|
|
|
|
register_pfs_file_open_end(locker, file,
|
|
(*success == TRUE ? success : 0));
|
|
|
|
return(file);
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro os_file_create(), not directly
|
|
this function!
|
|
A performance schema wrapper function for os_file_create().
|
|
Add instrumentation to monitor file creation/open.
|
|
@param[in] key Performance Schema Key
|
|
@param[in] name name of the file or path as a null-terminated
|
|
string
|
|
@param[in] create_mode create mode
|
|
@param[in] purpose OS_FILE_AIO, if asynchronous, non-buffered I/O
|
|
is desired, OS_FILE_NORMAL, if any normal file;
|
|
NOTE that it also depends on type, os_aio_..
|
|
and srv_.. variables whether we really us
|
|
async I/O or unbuffered I/O: look in the
|
|
function source code for the exact rules
|
|
@param[in] read_only if true read only mode checks are enforced
|
|
@param[out] success true if succeeded
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return own: handle to the file, not defined if error, error number
|
|
can be retrieved with os_file_get_last_error */
|
|
UNIV_INLINE
|
|
pfs_os_file_t
|
|
pfs_os_file_create_func(
|
|
mysql_pfs_key_t key,
|
|
const char* name,
|
|
ulint create_mode,
|
|
ulint purpose,
|
|
ulint type,
|
|
bool read_only,
|
|
bool* success,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
/* register a file open or creation depending on "create_mode" */
|
|
register_pfs_file_open_begin(
|
|
&state, locker, key,
|
|
create_mode == OS_FILE_CREATE
|
|
? PSI_FILE_CREATE : PSI_FILE_OPEN,
|
|
name, src_file, src_line);
|
|
|
|
pfs_os_file_t file = os_file_create_func(
|
|
name, create_mode, purpose, type, read_only, success);
|
|
|
|
register_pfs_file_open_end(locker, file,
|
|
(*success == TRUE ? success : 0));
|
|
|
|
return(file);
|
|
}
|
|
/**
|
|
NOTE! Please use the corresponding macro os_file_close(), not directly
|
|
this function!
|
|
A performance schema instrumented wrapper function for os_file_close().
|
|
@param[in] file handle to a file
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return true if success */
|
|
UNIV_INLINE
|
|
bool
|
|
pfs_os_file_close_func(
|
|
pfs_os_file_t file,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
/* register the file close */
|
|
register_pfs_file_io_begin(
|
|
&state, locker, file, 0, PSI_FILE_CLOSE, src_file, src_line);
|
|
|
|
bool result = os_file_close_func(file);
|
|
|
|
register_pfs_file_io_end(locker, 0);
|
|
|
|
return(result);
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro os_aio(), not directly this
|
|
function!
|
|
Performance schema wrapper function of os_aio() which requests
|
|
an asynchronous i/o operation.
|
|
@param[in,type] type IO request context
|
|
@param[in] mode IO mode
|
|
@param[in] name Name of the file or path as NUL terminated
|
|
string
|
|
@param[in] file Open file handle
|
|
@param[out] buf buffer where to read
|
|
@param[in] offset file offset where to read
|
|
@param[in] n number of bytes to read
|
|
@param[in] read_only if true read only mode checks are enforced
|
|
@param[in,out] m1 Message for the AIO handler, (can be used to
|
|
identify a completed AIO operation); ignored
|
|
if mode is OS_AIO_SYNC
|
|
@param[in,out] m2 message for the AIO handler (can be used to
|
|
identify a completed AIO operation); ignored
|
|
if mode is OS_AIO_SYNC
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return DB_SUCCESS if request was queued successfully, FALSE if fail */
|
|
UNIV_INLINE
|
|
dberr_t
|
|
pfs_os_aio_func(
|
|
IORequest& type,
|
|
ulint mode,
|
|
const char* name,
|
|
pfs_os_file_t file,
|
|
void* buf,
|
|
os_offset_t offset,
|
|
ulint n,
|
|
bool read_only,
|
|
fil_node_t* m1,
|
|
void* m2,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
ut_ad(type.validate());
|
|
|
|
/* Register the read or write I/O depending on "type" */
|
|
register_pfs_file_io_begin(
|
|
&state, locker, file, n,
|
|
type.is_write() ? PSI_FILE_WRITE : PSI_FILE_READ,
|
|
src_file, src_line);
|
|
|
|
dberr_t result = os_aio_func(
|
|
type, mode, name, file, buf, offset, n, read_only, m1, m2);
|
|
|
|
register_pfs_file_io_end(locker, n);
|
|
|
|
return(result);
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro os_file_read(), not directly
|
|
this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_read() which requests a synchronous read operation.
|
|
@param[in] type IO request context
|
|
@param[in] file Open file handle
|
|
@param[out] buf buffer where to read
|
|
@param[in] offset file offset where to read
|
|
@param[in] n number of bytes to read
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return DB_SUCCESS if request was successful */
|
|
UNIV_INLINE
|
|
dberr_t
|
|
pfs_os_file_read_func(
|
|
const IORequest& type,
|
|
pfs_os_file_t file,
|
|
void* buf,
|
|
os_offset_t offset,
|
|
ulint n,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
ut_ad(type.validate());
|
|
|
|
register_pfs_file_io_begin(
|
|
&state, locker, file, n, PSI_FILE_READ, src_file, src_line);
|
|
|
|
dberr_t result;
|
|
|
|
result = os_file_read_func(type, file, buf, offset, n);
|
|
|
|
register_pfs_file_io_end(locker, n);
|
|
|
|
return(result);
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro os_file_read_no_error_handling(),
|
|
not directly this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_read_no_error_handling_func() which requests a synchronous
|
|
read operation.
|
|
@param[in] type IO request context
|
|
@param[in] file Open file handle
|
|
@param[out] buf buffer where to read
|
|
@param[in] offset file offset where to read
|
|
@param[in] n number of bytes to read
|
|
@param[out] o number of bytes actually read
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return DB_SUCCESS if request was successful */
|
|
UNIV_INLINE
|
|
dberr_t
|
|
pfs_os_file_read_no_error_handling_func(
|
|
const IORequest& type,
|
|
pfs_os_file_t file,
|
|
void* buf,
|
|
os_offset_t offset,
|
|
ulint n,
|
|
ulint* o,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
register_pfs_file_io_begin(
|
|
&state, locker, file, n, PSI_FILE_READ, src_file, src_line);
|
|
|
|
dberr_t result = os_file_read_no_error_handling_func(
|
|
type, file, buf, offset, n, o);
|
|
|
|
register_pfs_file_io_end(locker, n);
|
|
|
|
return(result);
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro
|
|
os_file_read_no_error_handling_int_fd() to request
|
|
a synchronous read operation.
|
|
@param[in] type read request
|
|
@param[in] file file handle
|
|
@param[out] buf buffer where to read
|
|
@param[in] offset file offset where to read
|
|
@param[in] n number of bytes to read
|
|
@param[in] src_file caller file name
|
|
@param[in] src_line caller line number
|
|
@return error code
|
|
@retval DB_SUCCESS if the operation succeeded */
|
|
UNIV_INLINE
|
|
dberr_t
|
|
pfs_os_file_read_no_error_handling_int_fd_func(
|
|
const IORequest& type,
|
|
int file,
|
|
void* buf,
|
|
os_offset_t offset,
|
|
ulint n,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
|
|
PSI_file_locker* locker = PSI_FILE_CALL(
|
|
get_thread_file_descriptor_locker)(
|
|
&state, file, PSI_FILE_READ);
|
|
if (locker != NULL) {
|
|
PSI_FILE_CALL(start_file_wait)(
|
|
locker, n,
|
|
__FILE__, __LINE__);
|
|
}
|
|
|
|
dberr_t err = os_file_read_no_error_handling_func(
|
|
type, OS_FILE_FROM_FD(file), buf, offset, n, NULL);
|
|
|
|
if (locker != NULL) {
|
|
PSI_FILE_CALL(end_file_wait)(locker, n);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro os_file_write(), not directly
|
|
this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_write() which requests a synchronous write operation.
|
|
@param[in] type IO request context
|
|
@param[in] name Name of the file or path as NUL terminated
|
|
string
|
|
@param[in] file Open file handle
|
|
@param[out] buf buffer where to read
|
|
@param[in] offset file offset where to read
|
|
@param[in] n number of bytes to read
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return error code
|
|
@retval DB_SUCCESS if the request was successfully fulfilled */
|
|
UNIV_INLINE
|
|
dberr_t
|
|
pfs_os_file_write_func(
|
|
const IORequest& type,
|
|
const char* name,
|
|
pfs_os_file_t file,
|
|
const void* buf,
|
|
os_offset_t offset,
|
|
ulint n,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
register_pfs_file_io_begin(
|
|
&state, locker, file, n, PSI_FILE_WRITE, src_file, src_line);
|
|
|
|
dberr_t result;
|
|
|
|
result = os_file_write_func(type, name, file, buf, offset, n);
|
|
|
|
register_pfs_file_io_end(locker, n);
|
|
|
|
return(result);
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro os_file_write_int_fd(),
|
|
not directly this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_write_int_fd() which requests a synchronous write operation.
|
|
@param[in] type write request
|
|
@param[in] name file name
|
|
@param[in] file file handle
|
|
@param[in] buf buffer to write
|
|
@param[in] offset file offset
|
|
@param[in] n number of bytes
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return error code
|
|
@retval DB_SUCCESS if the operation succeeded */
|
|
UNIV_INLINE
|
|
dberr_t
|
|
pfs_os_file_write_int_fd_func(
|
|
const IORequest& type,
|
|
const char* name,
|
|
int file,
|
|
const void* buf,
|
|
os_offset_t offset,
|
|
ulint n,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker;
|
|
|
|
locker = PSI_FILE_CALL(get_thread_file_descriptor_locker)(
|
|
&state, file, PSI_FILE_WRITE);
|
|
if (locker != NULL) {
|
|
PSI_FILE_CALL(start_file_wait)(
|
|
locker, n,
|
|
__FILE__, __LINE__);
|
|
}
|
|
|
|
dberr_t err = os_file_write_func(
|
|
type, name, OS_FILE_FROM_FD(file), buf, offset, n);
|
|
|
|
if (locker != NULL) {
|
|
PSI_FILE_CALL(end_file_wait)(locker, n);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro os_file_flush(), not directly
|
|
this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_flush() which flushes the write buffers of a given file to the disk.
|
|
Flushes the write buffers of a given file to the disk.
|
|
@param[in] file Open file handle
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return TRUE if success */
|
|
UNIV_INLINE
|
|
bool
|
|
pfs_os_file_flush_func(
|
|
pfs_os_file_t file,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
register_pfs_file_io_begin(
|
|
&state, locker, file, 0, PSI_FILE_SYNC, src_file, src_line);
|
|
|
|
bool result = os_file_flush_func(file);
|
|
|
|
register_pfs_file_io_end(locker, 0);
|
|
|
|
return(result);
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro os_file_rename(), not directly
|
|
this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_rename()
|
|
@param[in] key Performance Schema Key
|
|
@param[in] oldpath old file path as a null-terminated string
|
|
@param[in] newpath new file path
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return true if success */
|
|
UNIV_INLINE
|
|
bool
|
|
pfs_os_file_rename_func(
|
|
mysql_pfs_key_t key,
|
|
const char* oldpath,
|
|
const char* newpath,
|
|
const char* src_file,
|
|
uint src_line)
|
|
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
register_pfs_file_open_begin(
|
|
&state, locker, key, PSI_FILE_RENAME, newpath,
|
|
src_file, src_line);
|
|
|
|
bool result = os_file_rename_func(oldpath, newpath);
|
|
|
|
register_pfs_file_rename_end(locker, 0);
|
|
|
|
return(result);
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro os_file_delete(), not directly
|
|
this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_delete()
|
|
@param[in] key Performance Schema Key
|
|
@param[in] name old file path as a null-terminated string
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return true if success */
|
|
UNIV_INLINE
|
|
bool
|
|
pfs_os_file_delete_func(
|
|
mysql_pfs_key_t key,
|
|
const char* name,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
register_pfs_file_close_begin(
|
|
&state, locker, key, PSI_FILE_DELETE, name, src_file, src_line);
|
|
|
|
bool result = os_file_delete_func(name);
|
|
|
|
register_pfs_file_close_end(locker, 0);
|
|
|
|
return(result);
|
|
}
|
|
|
|
/**
|
|
NOTE! Please use the corresponding macro os_file_delete_if_exists(), not
|
|
directly this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_delete_if_exists()
|
|
@param[in] key Performance Schema Key
|
|
@param[in] name old file path as a null-terminated string
|
|
@param[in] exist indicate if file pre-exist
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return true if success */
|
|
UNIV_INLINE
|
|
bool
|
|
pfs_os_file_delete_if_exists_func(
|
|
mysql_pfs_key_t key,
|
|
const char* name,
|
|
bool* exist,
|
|
const char* src_file,
|
|
uint src_line)
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* locker = NULL;
|
|
|
|
register_pfs_file_close_begin(
|
|
&state, locker, key, PSI_FILE_DELETE, name, src_file, src_line);
|
|
|
|
bool result = os_file_delete_if_exists_func(name, exist);
|
|
|
|
register_pfs_file_close_end(locker, 0);
|
|
|
|
return(result);
|
|
}
|
|
#endif /* UNIV_PFS_IO */
|