590 lines
22 KiB
Plaintext
590 lines
22 KiB
Plaintext
/*****************************************************************************
|
|
|
|
Copyright (c) 2010, 2019, Oracle and/or its affiliates. All Rights Reserved.
|
|
|
|
This program is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License, version 2.0, as published by the
|
|
Free Software Foundation.
|
|
|
|
This program is also distributed with certain software (including but not
|
|
limited to OpenSSL) that is licensed under separate terms, as designated in a
|
|
particular file or component or in included license documentation. The authors
|
|
of MySQL hereby grant you an additional permission to link the program and
|
|
your derivative works with the separately licensed software that they have
|
|
included with MySQL.
|
|
|
|
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, version 2.0,
|
|
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 St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/** @file include/os0file.ic
|
|
The interface to the operating system file io
|
|
|
|
Created 2/20/2010 Jimmy Yang
|
|
*******************************************************/
|
|
|
|
#include "univ.i"
|
|
|
|
#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;
|
|
pfs_os_file_t file;
|
|
|
|
/* 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);
|
|
|
|
file.m_file = os_file_create_simple_func(name, create_mode, access_type,
|
|
read_only, success);
|
|
file.m_psi = NULL;
|
|
|
|
/* Regsiter 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;
|
|
pfs_os_file_t file;
|
|
|
|
/* 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);
|
|
|
|
file = os_file_create_simple_no_error_handling_func(
|
|
name, create_mode, access_type, read_only, success);
|
|
|
|
file.m_psi = NULL;
|
|
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] type OS_DATA_FILE or OS_LOG_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_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;
|
|
pfs_os_file_t file;
|
|
|
|
/* 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);
|
|
|
|
file =
|
|
os_file_create_func(name, create_mode, purpose, type, read_only, success);
|
|
|
|
file.m_psi = NULL;
|
|
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.m_file);
|
|
|
|
register_pfs_file_io_end(locker, 0);
|
|
|
|
return (result);
|
|
}
|
|
|
|
#ifndef UNIV_HOTBACKUP
|
|
/** 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 IO request context
|
|
@param[in] aio_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, AIO_mode aio_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, aio_mode, name, file, buf, offset, n,
|
|
read_only, m1, m2);
|
|
|
|
register_pfs_file_io_end(locker, n);
|
|
|
|
return (result);
|
|
}
|
|
#endif /* UNIV_HOTBACKUP */
|
|
|
|
/** 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, out] type IO request context
|
|
@param[in] file_name file name
|
|
@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(IORequest &type, const char *file_name,
|
|
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_name, file.m_file, buf, offset, n);
|
|
|
|
register_pfs_file_io_end(locker, n);
|
|
|
|
return (result);
|
|
}
|
|
|
|
/** NOTE! Please use the corresponding macro os_file_read_first_page(),
|
|
not directly this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_read() which requests a synchronous read operation.
|
|
@param[in, out] type IO request context
|
|
@param[in] file_name file name
|
|
@param[in] file Open file handle
|
|
@param[out] buf buffer 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_first_page_func(IORequest &type, const char *file_name,
|
|
pfs_os_file_t file, void *buf, 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_first_page_func(type, file_name, file.m_file, buf, n);
|
|
|
|
register_pfs_file_io_end(locker, n);
|
|
|
|
return (result);
|
|
}
|
|
|
|
/** Copy data from one file to another file. Data is read/written
|
|
at current file offset.
|
|
@param[in] src file handle to copy from
|
|
@param[in] src_offset offset to copy from
|
|
@param[in] dest file handle to copy to
|
|
@param[in] dest_offset offset to copy to
|
|
@param[in] size number of bytes to copy
|
|
@param[in] src_file file name where func invoked
|
|
@param[in] src_line line where the func invoked
|
|
@return DB_SUCCESS if successful */
|
|
UNIV_INLINE
|
|
dberr_t pfs_os_file_copy_func(pfs_os_file_t src, os_offset_t src_offset,
|
|
pfs_os_file_t dest, os_offset_t dest_offset,
|
|
uint size, const char *src_file, uint src_line) {
|
|
dberr_t result;
|
|
|
|
PSI_file_locker_state state_read;
|
|
PSI_file_locker_state state_write;
|
|
|
|
struct PSI_file_locker *locker_read = nullptr;
|
|
struct PSI_file_locker *locker_write = nullptr;
|
|
|
|
register_pfs_file_io_begin(&state_read, locker_read, src, size, PSI_FILE_READ,
|
|
src_file, src_line);
|
|
|
|
register_pfs_file_io_begin(&state_write, locker_write, dest, size,
|
|
PSI_FILE_WRITE, src_file, src_line);
|
|
|
|
result =
|
|
os_file_copy_func(src.m_file, src_offset, dest.m_file, dest_offset, size);
|
|
|
|
register_pfs_file_io_end(locker_write, size);
|
|
register_pfs_file_io_end(locker_read, size);
|
|
|
|
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, out] type IO request context
|
|
@param[in] file_name file name
|
|
@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(IORequest &type,
|
|
const char *file_name,
|
|
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_name, file.m_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(), not directly this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_read_no_error_handling_int_fd_func() which requests a
|
|
synchronous read operation.
|
|
@param[in, out] type IO request context
|
|
@param[in] file_name file name
|
|
@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_int_fd_func(
|
|
IORequest &type, const char *file_name, int file, void *buf,
|
|
os_offset_t offset, ulint n, ulint *o, const char *src_file,
|
|
ulint src_line) {
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker *locker = NULL;
|
|
|
|
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 result = os_file_read_no_error_handling_func(
|
|
type, file_name, OS_FILE_FROM_FD(file), buf, offset, n, o);
|
|
|
|
if (locker != NULL) {
|
|
PSI_FILE_CALL(end_file_wait)(locker, n);
|
|
}
|
|
|
|
return (result);
|
|
}
|
|
|
|
/** 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, out] 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 DB_SUCCESS if request was successful */
|
|
UNIV_INLINE
|
|
dberr_t pfs_os_file_write_func(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.m_file, buf, offset, n);
|
|
|
|
register_pfs_file_io_end(locker, n);
|
|
|
|
return (result);
|
|
}
|
|
|
|
/** 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, out] 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 DB_SUCCESS if request was successful */
|
|
UNIV_INLINE
|
|
dberr_t pfs_os_file_write_int_fd_func(IORequest &type, const char *name,
|
|
int file, const void *buf,
|
|
os_offset_t offset, ulint n,
|
|
const char *src_file, ulint src_line) {
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker *locker = NULL;
|
|
|
|
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 result =
|
|
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 (result);
|
|
}
|
|
|
|
/** 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.m_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_rename_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, oldpath, newpath, !result);
|
|
|
|
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 */
|