mirror of
https://github.com/MariaDB/server.git
synced 2025-01-18 04:53:01 +01:00
65e1399e64
Significantly reduce the amount of InnoDB, XtraDB and Mariabackup code changes by defining pfs_os_file_t as something that is transparently compatible with os_file_t.
629 lines
21 KiB
Text
629 lines
21 KiB
Text
/*****************************************************************************
|
|
|
|
Copyright (c) 2010, 2017, 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.
|
|
@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, /*!< in: Performance Schema Key */
|
|
const char* name, /*!< in: name of the file or path as a
|
|
null-terminated string */
|
|
ulint create_mode,/*!< in: create mode */
|
|
ulint access_type,/*!< in: OS_FILE_READ_ONLY or
|
|
OS_FILE_READ_WRITE */
|
|
ibool* success,/*!< out: TRUE if succeed, FALSE if error */
|
|
ulint atomic_writes,/*!< in: atomic writes table option
|
|
value */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
pfs_os_file_t file;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
/* 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_func(name, create_mode,
|
|
access_type, success, atomic_writes);
|
|
|
|
/* 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.
|
|
@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, /*!< in: Performance Schema Key */
|
|
const char* name, /*!< in: name of the file or path as a
|
|
null-terminated string */
|
|
ulint create_mode, /*!< in: file create mode */
|
|
ulint access_type,/*!< in: 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 */
|
|
ibool* success,/*!< out: TRUE if succeed, FALSE if error */
|
|
ulint atomic_writes,/*!< in: atomic writes table option
|
|
value */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
pfs_os_file_t file;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
/* 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, success, atomic_writes);
|
|
|
|
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.
|
|
@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, /*!< in: Performance Schema Key */
|
|
const char* name, /*!< in: name of the file or path as a
|
|
null-terminated string */
|
|
ulint create_mode,/*!< in: file create mode */
|
|
ulint purpose,/*!< in: 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 use
|
|
async i/o or unbuffered i/o: look in the
|
|
function source code for the exact rules */
|
|
ulint type, /*!< in: OS_DATA_FILE or OS_LOG_FILE */
|
|
ibool* success,/*!< out: TRUE if succeed, FALSE if error */
|
|
ulint atomic_writes, /*!< in: atomic writes table option
|
|
value */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
pfs_os_file_t file;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
/* 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,
|
|
success, atomic_writes);
|
|
|
|
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().
|
|
@return TRUE if success */
|
|
UNIV_INLINE
|
|
ibool
|
|
pfs_os_file_close_func(
|
|
/*===================*/
|
|
pfs_os_file_t file, /*!< in, own: handle to a file */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
ibool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
/* register the file close */
|
|
register_pfs_file_io_begin(&state, locker, file, 0, PSI_FILE_CLOSE,
|
|
src_file, src_line);
|
|
|
|
result = os_file_close_func(file);
|
|
|
|
register_pfs_file_io_end(locker, 0);
|
|
|
|
return(result);
|
|
}
|
|
/***********************************************************************//**
|
|
NOTE! Please use the corresponding macro os_file_close_no_error_handling(),
|
|
not directly this function!
|
|
A performance schema instrumented wrapper function for
|
|
os_file_close_no_error_handling().
|
|
@return TRUE if success */
|
|
UNIV_INLINE
|
|
bool
|
|
pfs_os_file_close_no_error_handling_func(
|
|
/*===================*/
|
|
pfs_os_file_t file, /*!< in, own: handle to a file */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
bool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
/* register the file close */
|
|
register_pfs_file_io_begin(&state, locker, file, 0, PSI_FILE_CLOSE,
|
|
src_file, src_line);
|
|
|
|
result = os_file_close_no_error_handling_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 instrumented wrapper function of os_aio() which
|
|
requests an asynchronous i/o operation.
|
|
@return TRUE if request was queued successfully, FALSE if fail */
|
|
UNIV_INLINE
|
|
ibool
|
|
pfs_os_aio_func(
|
|
/*============*/
|
|
ulint type, /*!< in: OS_FILE_READ or OS_FILE_WRITE */
|
|
ulint is_log, /*!< in: 1 is OS_FILE_LOG or 0 */
|
|
ulint mode, /*!< in: OS_AIO_NORMAL etc. I/O mode */
|
|
const char* name, /*!< in: name of the file or path as a
|
|
null-terminated string */
|
|
pfs_os_file_t file, /*!< in: handle to a file */
|
|
void* buf, /*!< in: buffer where to read or from which
|
|
to write */
|
|
os_offset_t offset, /*!< in: file offset where to read or write */
|
|
ulint n, /*!< in: number of bytes to read or write */
|
|
ulint page_size, /*!< in: page size in bytes */
|
|
fil_node_t* message1,/*!< in: message for the aio handler
|
|
(can be used to identify a completed
|
|
aio operation); ignored if mode is
|
|
OS_AIO_SYNC */
|
|
void* message2,/*!< in: message for the aio handler
|
|
(can be used to identify a completed
|
|
aio operation); ignored if mode is
|
|
OS_AIO_SYNC */
|
|
ulint space_id,
|
|
trx_t* trx,
|
|
ulint* write_size,/*!< in/out: Actual write size initialized
|
|
after fist successfull trim
|
|
operation for this page and if
|
|
initialized we do not trim again if
|
|
actual page size does not decrease. */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
ibool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
/* Register the read or write I/O depending on "type" */
|
|
register_pfs_file_io_begin(&state, locker, file, n,
|
|
(type == OS_FILE_WRITE)
|
|
? PSI_FILE_WRITE
|
|
: PSI_FILE_READ,
|
|
src_file, src_line);
|
|
|
|
result = os_aio_func(type, is_log, mode, name, file, buf, offset,
|
|
n, page_size, message1, message2, space_id, trx,
|
|
write_size);
|
|
|
|
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.
|
|
@return TRUE if request was successful, FALSE if fail */
|
|
UNIV_INLINE
|
|
ibool
|
|
pfs_os_file_read_func(
|
|
/*==================*/
|
|
pfs_os_file_t file, /*!< in: handle to a file */
|
|
void* buf, /*!< in: buffer where to read */
|
|
os_offset_t offset, /*!< in: file offset where to read */
|
|
ulint n, /*!< in: number of bytes to read */
|
|
trx_t* trx,
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
ibool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
register_pfs_file_io_begin(&state, locker, file, n, PSI_FILE_READ,
|
|
src_file, src_line);
|
|
|
|
result = os_file_read_func(file, buf, offset, n, trx);
|
|
|
|
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() which requests a synchronous
|
|
positioned read operation. This function does not do any error
|
|
handling. In case of error it returns FALSE.
|
|
@return TRUE if request was successful, FALSE if fail */
|
|
UNIV_INLINE
|
|
ibool
|
|
pfs_os_file_read_no_error_handling_func(
|
|
/*====================================*/
|
|
pfs_os_file_t file, /*!< in: handle to a file */
|
|
void* buf, /*!< in: buffer where to read */
|
|
os_offset_t offset, /*!< in: file offset where to read */
|
|
ulint n, /*!< in: number of bytes to read */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
ibool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
register_pfs_file_io_begin(&state, locker, file, n, PSI_FILE_READ,
|
|
src_file, src_line);
|
|
|
|
result = os_file_read_no_error_handling_func(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_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.
|
|
@return TRUE if request was successful, FALSE if fail */
|
|
UNIV_INLINE
|
|
ibool
|
|
pfs_os_file_read_no_error_handling_int_fd_func(
|
|
int file, /*!< in: handle to a file */
|
|
void* buf, /*!< in: buffer where to read */
|
|
os_offset_t offset, /*!< in: file offset where to read */
|
|
ulint n, /*!< in: number of bytes to read */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
PSI_file_locker_state state;
|
|
struct PSI_file_locker* 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__);
|
|
}
|
|
ibool result = os_file_read_no_error_handling_func(
|
|
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_write(), not directly
|
|
this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_write() which requests a synchronous write operation.
|
|
@return TRUE if request was successful, FALSE if fail */
|
|
UNIV_INLINE
|
|
ibool
|
|
pfs_os_file_write_func(
|
|
/*===================*/
|
|
const char* name, /*!< in: name of the file or path as a
|
|
null-terminated string */
|
|
pfs_os_file_t file, /*!< in: handle to a file */
|
|
const void* buf, /*!< in: buffer from which to write */
|
|
os_offset_t offset, /*!< in: file offset where to write */
|
|
ulint n, /*!< in: number of bytes to write */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
ibool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
register_pfs_file_io_begin(&state, locker, file, n, PSI_FILE_WRITE,
|
|
src_file, src_line);
|
|
|
|
result = os_file_write_func(name, 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.
|
|
@return TRUE if request was successful, FALSE if fail */
|
|
UNIV_INLINE
|
|
ibool
|
|
pfs_os_file_write_int_fd_func(
|
|
const char* name, /*!< in: name of the file or path as a
|
|
null-terminated string */
|
|
int file, /*!< in: handle to a file */
|
|
const void* buf, /*!< in: buffer from which to write */
|
|
os_offset_t offset, /*!< in: file offset where to write */
|
|
ulint n, /*!< in: number of bytes to write */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
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__);
|
|
}
|
|
ibool result = os_file_write_func(
|
|
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.
|
|
@return TRUE if success */
|
|
UNIV_INLINE
|
|
ibool
|
|
pfs_os_file_flush_func(
|
|
/*===================*/
|
|
pfs_os_file_t file, /*!< in, own: handle to a file */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
ibool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
register_pfs_file_io_begin(&state, locker, file, 0, PSI_FILE_SYNC,
|
|
src_file, src_line);
|
|
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()
|
|
@return TRUE if success */
|
|
UNIV_INLINE
|
|
ibool
|
|
pfs_os_file_rename_func(
|
|
/*====================*/
|
|
mysql_pfs_key_t key, /*!< in: Performance Schema Key */
|
|
const char* oldpath,/*!< in: old file path as a null-terminated
|
|
string */
|
|
const char* newpath,/*!< in: new file path */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
ibool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
register_pfs_file_rename_begin(&state, locker, key, PSI_FILE_RENAME, newpath,
|
|
src_file, src_line);
|
|
|
|
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()
|
|
@return TRUE if success */
|
|
UNIV_INLINE
|
|
bool
|
|
pfs_os_file_delete_func(
|
|
/*====================*/
|
|
mysql_pfs_key_t key, /*!< in: Performance Schema Key */
|
|
const char* name, /*!< in: file path as a null-terminated
|
|
string */
|
|
const char* src_file, /*!< in: file name where func invoked */
|
|
ulint src_line) /*!< in: line where the func invoked */
|
|
{
|
|
bool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
register_pfs_file_close_begin(&state, locker, key, PSI_FILE_DELETE,
|
|
name, src_file, src_line);
|
|
|
|
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()
|
|
@return TRUE if success */
|
|
UNIV_INLINE
|
|
bool
|
|
pfs_os_file_delete_if_exists_func(
|
|
/*==============================*/
|
|
mysql_pfs_key_t key, /*!< in: Performance Schema Key */
|
|
const char* name, /*!< in: file path as a null-terminated
|
|
string */
|
|
const char* src_file, /*!< in: file name where func invoked */
|
|
ulint src_line) /*!< in: line where the func invoked */
|
|
{
|
|
bool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
register_pfs_file_close_begin(&state, locker, key, PSI_FILE_DELETE,
|
|
name, src_file, src_line);
|
|
|
|
result = os_file_delete_if_exists_func(name);
|
|
|
|
register_pfs_file_close_end(locker, 0);
|
|
|
|
return(result);
|
|
}
|
|
|
|
/***********************************************************************//**
|
|
NOTE! Please use the corresponding macro os_file_set_eof_at(), not
|
|
directly this function!
|
|
This is the performance schema instrumented wrapper function for
|
|
os_file_set_eof_at()
|
|
@return TRUE if success */
|
|
UNIV_INLINE
|
|
bool
|
|
pfs_os_file_set_eof_at_func(
|
|
pfs_os_file_t file, /*!< in: handle to a file */
|
|
ib_uint64_t new_len,/*!< in: new file length */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
bool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
register_pfs_file_io_begin(&state, locker, file, 0, PSI_FILE_CHSIZE,
|
|
src_file, src_line);
|
|
result = os_file_set_eof_at_func(file, new_len);
|
|
|
|
register_pfs_file_io_end(locker, 0);
|
|
|
|
return(result);
|
|
}
|
|
|
|
#ifdef HAVE_POSIX_FALLOCATE
|
|
/***********************************************************************//**
|
|
NOTE! Please use the corresponding macro os_file_allocate(), not
|
|
directly this function!
|
|
Ensures that disk space is allocated for the file.
|
|
@return TRUE if success */
|
|
UNIV_INLINE
|
|
bool
|
|
pfs_os_file_allocate_func(
|
|
pfs_os_file_t file, /*!< in, own: handle to a file */
|
|
os_offset_t offset, /*!< in: file region offset */
|
|
os_offset_t len, /*!< in: file region length */
|
|
const char* src_file,/*!< in: file name where func invoked */
|
|
ulint src_line)/*!< in: line where the func invoked */
|
|
{
|
|
bool result;
|
|
struct PSI_file_locker* locker = NULL;
|
|
PSI_file_locker_state state;
|
|
|
|
register_pfs_file_io_begin(&state, locker, file, 0, PSI_FILE_CHSIZE,
|
|
src_file, src_line);
|
|
result = os_file_allocate_func(file, offset, len);
|
|
|
|
register_pfs_file_io_end(locker, 0);
|
|
|
|
return(result);
|
|
}
|
|
#endif
|
|
|
|
#endif /* UNIV_PFS_IO */
|