/***************************************************************************** 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 */