mirror of
https://github.com/MariaDB/server.git
synced 2025-01-22 14:54:20 +01:00
6495806e59
Problem was that implementation merged from 10.1 was incompatible with InnoDB 5.7. buf0buf.cc: Add functions to return should we punch hole and how big. buf0flu.cc: Add written page to IORequest fil0fil.cc: Remove unneeded status call and add test is sparse files and punch hole supported by file system when tablespace is created. Add call to get file system block size. Used file node is added to IORequest. Added functions to check is punch hole supported and setting punch hole. ha_innodb.cc: Remove unneeded status variables (trim512-32768) and trim_op_saved. Deprecate innodb_use_trim and set it ON by default. Add function to set innodb-use-trim dynamically. dberr.h: Add error code DB_IO_NO_PUNCH_HOLE if punch hole operation fails. fil0fil.h: Add punch_hole variable to fil_space_t and block size to fil_node_t. os0api.h: Header to helper functions on buf0buf.cc and fil0fil.cc for os0file.h os0file.h: Remove unneeded m_block_size from IORequest and add bpage to IORequest to know actual size of the block and m_fil_node to know tablespace file system block size and does it support punch hole. os0file.cc: Add function punch_hole() to IORequest to do punch_hole operation, get the file system block size and determine does file system support sparse files (for punch hole). page0size.h: remove implicit copy disable and use this implicit copy to implement copy_from() function. buf0dblwr.cc, buf0flu.cc, buf0rea.cc, fil0fil.cc, fil0fil.h, os0file.h, os0file.cc, log0log.cc, log0recv.cc: Remove unneeded write_size parameter from fil_io calls. srv0mon.h, srv0srv.h, srv0mon.cc: Remove unneeded trim512-trim32678 status variables. Removed these from monitor tests.
507 lines
15 KiB
Text
507 lines
15 KiB
Text
/*****************************************************************************
|
|
|
|
Copyright (c) 2010, 2015, Oracle and/or its affiliates. All Rights Reserved.
|
|
Copyright (c) 2013, 2017, 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, Suite 500, Boston, MA 02110-1335 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
|
|
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,
|
|
ulint 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);
|
|
|
|
os_file_t file = os_file_create_simple_func(
|
|
name, create_mode, access_type, read_only, success);
|
|
|
|
/* Regsiter the returning "file" value with the system */
|
|
register_pfs_file_open_end(locker, file);
|
|
|
|
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
|
|
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,
|
|
ulint 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);
|
|
|
|
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);
|
|
|
|
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
|
|
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,
|
|
ulint 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);
|
|
|
|
os_file_t file = os_file_create_func(
|
|
name, create_mode, purpose, type, read_only, success);
|
|
|
|
register_pfs_file_open_end(locker, file);
|
|
|
|
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(
|
|
os_file_t file,
|
|
const char* src_file,
|
|
ulint 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 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,
|
|
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,
|
|
ulint 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, out] 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(
|
|
IORequest& type,
|
|
os_file_t file,
|
|
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;
|
|
|
|
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, out] 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(
|
|
IORequest& type,
|
|
os_file_t 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;
|
|
|
|
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_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,
|
|
os_file_t 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;
|
|
|
|
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_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(
|
|
os_file_t file,
|
|
const char* src_file,
|
|
ulint 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,
|
|
ulint 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_open_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,
|
|
ulint 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,
|
|
ulint 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 */
|
|
|