mirror of
https://github.com/MariaDB/server.git
synced 2025-01-22 14:54:20 +01:00
4e1116b2c6
Also, remove empty .ic files that were not removed by my MySQL commit. Problem: InnoDB used to support a compilation mode that allowed to choose whether the function definitions in .ic files are to be inlined or not. This stopped making sense when InnoDB moved to C++ in MySQL 5.6 (and ha_innodb.cc started to #include .ic files), and more so in MySQL 5.7 when inline methods and functions were introduced in .h files. Solution: Remove all references to UNIV_NONINL and UNIV_MUST_NOT_INLINE from all files, assuming that the symbols are never defined. Remove the files fut0fut.cc and ut0byte.cc which only mattered when UNIV_NONINL was defined.
1611 lines
49 KiB
C++
1611 lines
49 KiB
C++
/***********************************************************************
|
|
|
|
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
|
|
Copyright (c) 2009, Percona Inc.
|
|
Copyright (c) 2013, 2017, MariaDB Corporation. All Rights Reserved.
|
|
|
|
Portions of this file contain modifications contributed and copyrighted
|
|
by Percona Inc.. Those modifications are
|
|
gratefully acknowledged and are described briefly in the InnoDB
|
|
documentation. The contributions by Percona Inc. are incorporated with
|
|
their permission, and subject to the conditions contained in the file
|
|
COPYING.Percona.
|
|
|
|
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.h
|
|
The interface to the operating system file io
|
|
|
|
Created 10/21/1995 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef os0file_h
|
|
#define os0file_h
|
|
|
|
#include "page0size.h"
|
|
#include "os0api.h"
|
|
|
|
#ifndef _WIN32
|
|
#include <dirent.h>
|
|
#include <sys/stat.h>
|
|
#include <time.h>
|
|
#endif /* !_WIN32 */
|
|
|
|
/** File node of a tablespace or the log data space */
|
|
struct fil_node_t;
|
|
struct fil_space_t;
|
|
|
|
extern bool os_has_said_disk_full;
|
|
extern my_bool srv_use_trim;
|
|
|
|
/** Number of pending read operations */
|
|
extern ulint os_n_pending_reads;
|
|
/** Number of pending write operations */
|
|
extern ulint os_n_pending_writes;
|
|
|
|
/** File offset in bytes */
|
|
typedef ib_uint64_t os_offset_t;
|
|
|
|
#ifdef _WIN32
|
|
|
|
/**
|
|
Gets the operating system version. Currently works only on Windows.
|
|
@return OS_WIN95, OS_WIN31, OS_WINNT, OS_WIN2000, OS_WINXP, OS_WINVISTA,
|
|
OS_WIN7. */
|
|
|
|
ulint
|
|
os_get_os_version();
|
|
|
|
typedef HANDLE os_file_dir_t; /*!< directory stream */
|
|
|
|
/** We define always WIN_ASYNC_IO, and check at run-time whether
|
|
the OS actually supports it: Win 95 does not, NT does. */
|
|
# define WIN_ASYNC_IO
|
|
|
|
/** Use unbuffered I/O */
|
|
# define UNIV_NON_BUFFERED_IO
|
|
|
|
/** File handle */
|
|
typedef HANDLE os_file_t;
|
|
|
|
/** Convert a C file descriptor to a native file handle
|
|
@param fd file descriptor
|
|
@return native file handle */
|
|
# define OS_FILE_FROM_FD(fd) (HANDLE) _get_osfhandle(fd)
|
|
|
|
#else /* _WIN32 */
|
|
|
|
typedef DIR* os_file_dir_t; /*!< directory stream */
|
|
|
|
/** File handle */
|
|
typedef int os_file_t;
|
|
|
|
/** Convert a C file descriptor to a native file handle
|
|
@param fd file descriptor
|
|
@return native file handle */
|
|
# define OS_FILE_FROM_FD(fd) fd
|
|
|
|
#endif /* _WIN32 */
|
|
|
|
static const os_file_t OS_FILE_CLOSED = os_file_t(~0);
|
|
|
|
/** The next value should be smaller or equal to the smallest sector size used
|
|
on any disk. A log block is required to be a portion of disk which is written
|
|
so that if the start and the end of a block get written to disk, then the
|
|
whole block gets written. This should be true even in most cases of a crash:
|
|
if this fails for a log block, then it is equivalent to a media failure in the
|
|
log. */
|
|
|
|
#define OS_FILE_LOG_BLOCK_SIZE 512U
|
|
|
|
/** Options for os_file_create_func @{ */
|
|
enum os_file_create_t {
|
|
OS_FILE_OPEN = 51, /*!< to open an existing file (if
|
|
doesn't exist, error) */
|
|
OS_FILE_CREATE, /*!< to create new file (if
|
|
exists, error) */
|
|
OS_FILE_OVERWRITE, /*!< to create a new file, if exists
|
|
the overwrite old file */
|
|
OS_FILE_OPEN_RAW, /*!< to open a raw device or disk
|
|
partition */
|
|
OS_FILE_CREATE_PATH, /*!< to create the directories */
|
|
OS_FILE_OPEN_RETRY, /*!< open with retry */
|
|
|
|
/** Flags that can be combined with the above values. Please ensure
|
|
that the above values stay below 128. */
|
|
|
|
OS_FILE_ON_ERROR_NO_EXIT = 128, /*!< do not exit on unknown errors */
|
|
OS_FILE_ON_ERROR_SILENT = 256 /*!< don't print diagnostic messages to
|
|
the log unless it is a fatal error,
|
|
this flag is only used if
|
|
ON_ERROR_NO_EXIT is set */
|
|
};
|
|
|
|
static const ulint OS_FILE_READ_ONLY = 333;
|
|
static const ulint OS_FILE_READ_WRITE = 444;
|
|
|
|
/** Used by MySQLBackup */
|
|
static const ulint OS_FILE_READ_ALLOW_DELETE = 555;
|
|
|
|
/* Options for file_create */
|
|
static const ulint OS_FILE_AIO = 61;
|
|
static const ulint OS_FILE_NORMAL = 62;
|
|
/* @} */
|
|
|
|
/** Types for file create @{ */
|
|
static const ulint OS_DATA_FILE = 100;
|
|
static const ulint OS_LOG_FILE = 101;
|
|
static const ulint OS_DATA_TEMP_FILE = 102;
|
|
/* @} */
|
|
|
|
/** Error codes from os_file_get_last_error @{ */
|
|
static const ulint OS_FILE_NAME_TOO_LONG = 36;
|
|
static const ulint OS_FILE_NOT_FOUND = 71;
|
|
static const ulint OS_FILE_DISK_FULL = 72;
|
|
static const ulint OS_FILE_ALREADY_EXISTS = 73;
|
|
static const ulint OS_FILE_PATH_ERROR = 74;
|
|
|
|
/** wait for OS aio resources to become available again */
|
|
static const ulint OS_FILE_AIO_RESOURCES_RESERVED = 75;
|
|
|
|
static const ulint OS_FILE_SHARING_VIOLATION = 76;
|
|
static const ulint OS_FILE_ERROR_NOT_SPECIFIED = 77;
|
|
static const ulint OS_FILE_INSUFFICIENT_RESOURCE = 78;
|
|
static const ulint OS_FILE_AIO_INTERRUPTED = 79;
|
|
static const ulint OS_FILE_OPERATION_ABORTED = 80;
|
|
static const ulint OS_FILE_ACCESS_VIOLATION = 81;
|
|
static const ulint OS_FILE_OPERATION_NOT_SUPPORTED = 125;
|
|
static const ulint OS_FILE_ERROR_MAX = 200;
|
|
/* @} */
|
|
|
|
/** Types for AIO operations @{ */
|
|
|
|
/** No transformations during read/write, write as is. */
|
|
#define IORequestRead IORequest(IORequest::READ)
|
|
#define IORequestWrite IORequest(IORequest::WRITE)
|
|
#define IORequestLogRead IORequest(IORequest::LOG | IORequest::READ)
|
|
#define IORequestLogWrite IORequest(IORequest::LOG | IORequest::WRITE)
|
|
|
|
|
|
|
|
/**
|
|
The IO Context that is passed down to the low level IO code */
|
|
class IORequest {
|
|
public:
|
|
/** Flags passed in the request, they can be ORred together. */
|
|
enum {
|
|
READ = 1,
|
|
WRITE = 2,
|
|
|
|
/** Double write buffer recovery. */
|
|
DBLWR_RECOVER = 4,
|
|
|
|
/** Enumarations below can be ORed to READ/WRITE above*/
|
|
|
|
/** Data file */
|
|
DATA_FILE = 8,
|
|
|
|
/** Log file request*/
|
|
LOG = 16,
|
|
|
|
/** Disable partial read warnings */
|
|
DISABLE_PARTIAL_IO_WARNINGS = 32,
|
|
|
|
/** Do not to wake i/o-handler threads, but the caller will do
|
|
the waking explicitly later, in this way the caller can post
|
|
several requests in a batch; NOTE that the batch must not be
|
|
so big that it exhausts the slots in AIO arrays! NOTE that
|
|
a simulated batch may introduce hidden chances of deadlocks,
|
|
because I/Os are not actually handled until all
|
|
have been posted: use with great caution! */
|
|
DO_NOT_WAKE = 64,
|
|
|
|
/** Ignore failed reads of non-existent pages */
|
|
IGNORE_MISSING = 128,
|
|
|
|
/** Use punch hole if available*/
|
|
PUNCH_HOLE = 256,
|
|
};
|
|
|
|
/** Default constructor */
|
|
IORequest()
|
|
:
|
|
m_bpage(NULL),
|
|
m_fil_node(NULL),
|
|
m_type(READ)
|
|
{
|
|
/* No op */
|
|
}
|
|
|
|
/**
|
|
@param[in] type Request type, can be a value that is
|
|
ORed from the above enum */
|
|
explicit IORequest(ulint type)
|
|
:
|
|
m_bpage(NULL),
|
|
m_fil_node(NULL),
|
|
m_type(static_cast<uint16_t>(type))
|
|
{
|
|
if (!is_punch_hole_supported() || !srv_use_trim) {
|
|
clear_punch_hole();
|
|
}
|
|
}
|
|
|
|
/**
|
|
@param[in] type Request type, can be a value that is
|
|
ORed from the above enum
|
|
@param[in] bpage Page to be written */
|
|
IORequest(ulint type, buf_page_t* bpage)
|
|
:
|
|
m_bpage(bpage),
|
|
m_fil_node(NULL),
|
|
m_type(static_cast<uint16_t>(type))
|
|
{
|
|
if (bpage && buf_page_should_punch_hole(bpage)) {
|
|
set_punch_hole();
|
|
}
|
|
|
|
if (!is_punch_hole_supported() || !srv_use_trim) {
|
|
clear_punch_hole();
|
|
}
|
|
}
|
|
|
|
/** Destructor */
|
|
~IORequest() { }
|
|
|
|
/** @return true if ignore missing flag is set */
|
|
static bool ignore_missing(ulint type)
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
{
|
|
return((type & IGNORE_MISSING) == IGNORE_MISSING);
|
|
}
|
|
|
|
/** @return true if it is a read request */
|
|
bool is_read() const
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
{
|
|
return((m_type & READ) == READ);
|
|
}
|
|
|
|
/** @return true if it is a write request */
|
|
bool is_write() const
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
{
|
|
return((m_type & WRITE) == WRITE);
|
|
}
|
|
|
|
/** @return true if it is a redo log write */
|
|
bool is_log() const
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
{
|
|
return((m_type & LOG) == LOG);
|
|
}
|
|
|
|
/** @return true if the simulated AIO thread should be woken up */
|
|
bool is_wake() const
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
{
|
|
return((m_type & DO_NOT_WAKE) == 0);
|
|
}
|
|
|
|
/** Clear the punch hole flag */
|
|
void clear_punch_hole()
|
|
{
|
|
m_type &= ~PUNCH_HOLE;
|
|
}
|
|
|
|
/** @return true if partial read warning disabled */
|
|
bool is_partial_io_warning_disabled() const
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
{
|
|
return((m_type & DISABLE_PARTIAL_IO_WARNINGS)
|
|
== DISABLE_PARTIAL_IO_WARNINGS);
|
|
}
|
|
|
|
/** Disable partial read warnings */
|
|
void disable_partial_io_warnings()
|
|
{
|
|
m_type |= DISABLE_PARTIAL_IO_WARNINGS;
|
|
}
|
|
|
|
/** @return true if missing files should be ignored */
|
|
bool ignore_missing() const
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
{
|
|
return(ignore_missing(m_type));
|
|
}
|
|
|
|
/** @return true if punch hole should be used */
|
|
bool punch_hole() const
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
{
|
|
return((m_type & PUNCH_HOLE) == PUNCH_HOLE);
|
|
}
|
|
|
|
/** @return true if the read should be validated */
|
|
bool validate() const
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
{
|
|
return(is_read() ^ is_write());
|
|
}
|
|
|
|
/** Set the punch hole flag */
|
|
void set_punch_hole()
|
|
{
|
|
if (is_punch_hole_supported() && srv_use_trim) {
|
|
m_type |= PUNCH_HOLE;
|
|
}
|
|
}
|
|
|
|
/** Clear the do not wake flag */
|
|
void clear_do_not_wake()
|
|
{
|
|
m_type &= ~DO_NOT_WAKE;
|
|
}
|
|
|
|
/** Set the pointer to file node for IO
|
|
@param[in] node File node */
|
|
void set_fil_node(fil_node_t* node)
|
|
{
|
|
if (!srv_use_trim ||
|
|
(node && !fil_node_should_punch_hole(node))) {
|
|
clear_punch_hole();
|
|
}
|
|
|
|
m_fil_node = node;
|
|
}
|
|
|
|
/** Compare two requests
|
|
@reutrn true if the are equal */
|
|
bool operator==(const IORequest& rhs) const
|
|
{
|
|
return(m_type == rhs.m_type);
|
|
}
|
|
|
|
/** Note that the IO is for double write recovery. */
|
|
void dblwr_recover()
|
|
{
|
|
m_type |= DBLWR_RECOVER;
|
|
}
|
|
|
|
/** @return true if the request is from the dblwr recovery */
|
|
bool is_dblwr_recover() const
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
{
|
|
return((m_type & DBLWR_RECOVER) == DBLWR_RECOVER);
|
|
}
|
|
|
|
/** @return true if punch hole is supported */
|
|
static bool is_punch_hole_supported()
|
|
{
|
|
|
|
/* In this debugging mode, we act as if punch hole is supported,
|
|
and then skip any calls to actually punch a hole here.
|
|
In this way, Transparent Page Compression is still being tested. */
|
|
DBUG_EXECUTE_IF("ignore_punch_hole",
|
|
return(true);
|
|
);
|
|
|
|
#if defined(HAVE_FALLOC_PUNCH_HOLE_AND_KEEP_SIZE) || defined(_WIN32)
|
|
return(true);
|
|
#else
|
|
return(false);
|
|
#endif /* HAVE_FALLOC_PUNCH_HOLE_AND_KEEP_SIZE || _WIN32 */
|
|
}
|
|
|
|
ulint get_trim_length(ulint write_length) const
|
|
{
|
|
return (m_bpage ?
|
|
buf_page_get_trim_length(m_bpage, write_length)
|
|
: 0);
|
|
}
|
|
|
|
bool should_punch_hole() const {
|
|
return (m_fil_node ?
|
|
fil_node_should_punch_hole(m_fil_node)
|
|
: false);
|
|
}
|
|
|
|
void space_no_punch_hole() const {
|
|
if (m_fil_node) {
|
|
fil_space_set_punch_hole(m_fil_node, false);
|
|
}
|
|
}
|
|
|
|
/** Free storage space associated with a section of the file.
|
|
@param[in] fh Open file handle
|
|
@param[in] off Starting offset (SEEK_SET)
|
|
@param[in] len Size of the hole
|
|
@return DB_SUCCESS or error code */
|
|
dberr_t punch_hole(os_file_t fh, os_offset_t off, ulint len);
|
|
|
|
private:
|
|
/** Page to be written on write operation. */
|
|
buf_page_t* m_bpage;
|
|
|
|
/** File node */
|
|
fil_node_t* m_fil_node;
|
|
|
|
/** Request type bit flags */
|
|
uint16_t m_type;
|
|
};
|
|
|
|
/* @} */
|
|
|
|
/** Sparse file size information. */
|
|
struct os_file_size_t {
|
|
/** Total size of file in bytes */
|
|
os_offset_t m_total_size;
|
|
|
|
/** If it is a sparse file then this is the number of bytes
|
|
actually allocated for the file. */
|
|
os_offset_t m_alloc_size;
|
|
};
|
|
|
|
/** Win NT does not allow more than 64 */
|
|
static const ulint OS_AIO_N_PENDING_IOS_PER_THREAD = 32;
|
|
|
|
/** Modes for aio operations @{ */
|
|
/** Normal asynchronous i/o not for ibuf pages or ibuf bitmap pages */
|
|
static const ulint OS_AIO_NORMAL = 21;
|
|
|
|
/** Asynchronous i/o for ibuf pages or ibuf bitmap pages */
|
|
static const ulint OS_AIO_IBUF = 22;
|
|
|
|
/** Asynchronous i/o for the log */
|
|
static const ulint OS_AIO_LOG = 23;
|
|
|
|
/** Asynchronous i/o where the calling thread will itself wait for
|
|
the i/o to complete, doing also the job of the i/o-handler thread;
|
|
can be used for any pages, ibuf or non-ibuf. This is used to save
|
|
CPU time, as we can do with fewer thread switches. Plain synchronous
|
|
I/O is not as good, because it must serialize the file seek and read
|
|
or write, causing a bottleneck for parallelism. */
|
|
static const ulint OS_AIO_SYNC = 24;
|
|
/* @} */
|
|
|
|
extern ulint os_n_file_reads;
|
|
extern ulint os_n_file_writes;
|
|
extern ulint os_n_fsyncs;
|
|
|
|
/* File types for directory entry data type */
|
|
|
|
enum os_file_type_t {
|
|
OS_FILE_TYPE_UNKNOWN = 0,
|
|
OS_FILE_TYPE_FILE, /* regular file */
|
|
OS_FILE_TYPE_DIR, /* directory */
|
|
OS_FILE_TYPE_LINK, /* symbolic link */
|
|
OS_FILE_TYPE_BLOCK /* block device */
|
|
};
|
|
|
|
/* Maximum path string length in bytes when referring to tables with in the
|
|
'./databasename/tablename.ibd' path format; we can allocate at least 2 buffers
|
|
of this size from the thread stack; that is why this should not be made much
|
|
bigger than 4000 bytes. The maximum path length used by any storage engine
|
|
in the server must be at least this big. */
|
|
|
|
/* MySQL 5.7 my_global.h */
|
|
#ifndef FN_REFLEN_SE
|
|
#define FN_REFLEN_SE 4000
|
|
#endif
|
|
|
|
#define OS_FILE_MAX_PATH 4000
|
|
#if (FN_REFLEN_SE < OS_FILE_MAX_PATH)
|
|
# error "(FN_REFLEN_SE < OS_FILE_MAX_PATH)"
|
|
#endif
|
|
|
|
/** Struct used in fetching information of a file in a directory */
|
|
struct os_file_stat_t {
|
|
char name[OS_FILE_MAX_PATH]; /*!< path to a file */
|
|
os_file_type_t type; /*!< file type */
|
|
os_offset_t size; /*!< file size in bytes */
|
|
os_offset_t alloc_size; /*!< Allocated size for
|
|
sparse files in bytes */
|
|
size_t block_size; /*!< Block size to use for IO
|
|
in bytes*/
|
|
time_t ctime; /*!< creation time */
|
|
time_t mtime; /*!< modification time */
|
|
time_t atime; /*!< access time */
|
|
bool rw_perm; /*!< true if can be opened
|
|
in read-write mode. Only valid
|
|
if type == OS_FILE_TYPE_FILE */
|
|
};
|
|
|
|
/** Create a temporary file. This function is like tmpfile(3), but
|
|
the temporary file is created in the given parameter path. If the path
|
|
is null then it will create the file in the mysql server configuration
|
|
parameter (--tmpdir).
|
|
@param[in] path location for creating temporary file
|
|
@return temporary file handle, or NULL on error */
|
|
FILE*
|
|
os_file_create_tmpfile(
|
|
const char* path);
|
|
|
|
/** The os_file_opendir() function opens a directory stream corresponding to the
|
|
directory named by the dirname argument. The directory stream is positioned
|
|
at the first entry. In both Unix and Windows we automatically skip the '.'
|
|
and '..' items at the start of the directory listing.
|
|
|
|
@param[in] dirname directory name; it must not contain a trailing
|
|
'\' or '/'
|
|
@param[in] is_fatal true if we should treat an error as a fatal
|
|
error; if we try to open symlinks then we do
|
|
not wish a fatal error if it happens not to be
|
|
a directory
|
|
@return directory stream, NULL if error */
|
|
os_file_dir_t
|
|
os_file_opendir(
|
|
const char* dirname,
|
|
bool is_fatal);
|
|
|
|
/**
|
|
Closes a directory stream.
|
|
@param[in] dir directory stream
|
|
@return 0 if success, -1 if failure */
|
|
int
|
|
os_file_closedir(
|
|
os_file_dir_t dir);
|
|
|
|
/** This function returns information of the next file in the directory. We jump
|
|
over the '.' and '..' entries in the directory.
|
|
@param[in] dirname directory name or path
|
|
@param[in] dir directory stream
|
|
@param[out] info buffer where the info is returned
|
|
@return 0 if ok, -1 if error, 1 if at the end of the directory */
|
|
int
|
|
os_file_readdir_next_file(
|
|
const char* dirname,
|
|
os_file_dir_t dir,
|
|
os_file_stat_t* info);
|
|
|
|
/**
|
|
This function attempts to create a directory named pathname. The new directory
|
|
gets default permissions. On Unix, the permissions are (0770 & ~umask). If the
|
|
directory exists already, nothing is done and the call succeeds, unless the
|
|
fail_if_exists arguments is true.
|
|
|
|
@param[in] pathname directory name as null-terminated string
|
|
@param[in] fail_if_exists if true, pre-existing directory is treated
|
|
as an error.
|
|
@return true if call succeeds, false on error */
|
|
bool
|
|
os_file_create_directory(
|
|
const char* pathname,
|
|
bool fail_if_exists);
|
|
|
|
/** NOTE! Use the corresponding macro os_file_create_simple(), not directly
|
|
this function!
|
|
A simple function to open or create a file.
|
|
@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 succeed, false if error
|
|
@return own: handle to the file, not defined if error, error number
|
|
can be retrieved with os_file_get_last_error */
|
|
os_file_t
|
|
os_file_create_simple_func(
|
|
const char* name,
|
|
ulint create_mode,
|
|
ulint access_type,
|
|
bool read_only,
|
|
bool* success);
|
|
|
|
/** NOTE! Use the corresponding macro
|
|
os_file_create_simple_no_error_handling(), not directly this function!
|
|
A simple function to open or create a file.
|
|
@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
|
|
@return own: handle to the file, not defined if error, error number
|
|
can be retrieved with os_file_get_last_error */
|
|
os_file_t
|
|
os_file_create_simple_no_error_handling_func(
|
|
const char* name,
|
|
ulint create_mode,
|
|
ulint access_type,
|
|
bool read_only,
|
|
bool* success)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Tries to disable OS caching on an opened file descriptor.
|
|
@param[in] fd file descriptor to alter
|
|
@param[in] file_name file name, used in the diagnostic message
|
|
@param[in] name "open" or "create"; used in the diagnostic
|
|
message */
|
|
void
|
|
os_file_set_nocache(
|
|
/*================*/
|
|
os_file_t fd, /*!< in: file descriptor to alter */
|
|
const char* file_name,
|
|
const char* operation_name);
|
|
|
|
/** NOTE! Use the corresponding macro os_file_create(), not directly
|
|
this function!
|
|
Opens an existing file or creates a new.
|
|
@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 use
|
|
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[in] success true if succeeded
|
|
@return own: handle to the file, not defined if error, error number
|
|
can be retrieved with os_file_get_last_error */
|
|
os_file_t
|
|
os_file_create_func(
|
|
const char* name,
|
|
ulint create_mode,
|
|
ulint purpose,
|
|
ulint type,
|
|
bool read_only,
|
|
bool* success)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Deletes a file. The file has to be closed before calling this.
|
|
@param[in] name file path as a null-terminated string
|
|
@return true if success */
|
|
bool
|
|
os_file_delete_func(const char* name);
|
|
|
|
/** Deletes a file if it exists. The file has to be closed before calling this.
|
|
@param[in] name file path as a null-terminated string
|
|
@param[out] exist indicate if file pre-exist
|
|
@return true if success */
|
|
bool
|
|
os_file_delete_if_exists_func(const char* name, bool* exist);
|
|
|
|
/** NOTE! Use the corresponding macro os_file_rename(), not directly
|
|
this function!
|
|
Renames a file (can also move it to another directory). It is safest that the
|
|
file is closed before calling this function.
|
|
@param[in] oldpath old file path as a null-terminated string
|
|
@param[in] newpath new file path
|
|
@return true if success */
|
|
bool
|
|
os_file_rename_func(const char* oldpath, const char* newpath);
|
|
|
|
/** NOTE! Use the corresponding macro os_file_close(), not directly this
|
|
function!
|
|
Closes a file handle. In case of error, error number can be retrieved with
|
|
os_file_get_last_error.
|
|
@param[in] file own: handle to a file
|
|
@return true if success */
|
|
bool
|
|
os_file_close_func(os_file_t file);
|
|
|
|
#ifdef UNIV_PFS_IO
|
|
|
|
/* Keys to register InnoDB I/O with performance schema */
|
|
extern mysql_pfs_key_t innodb_data_file_key;
|
|
extern mysql_pfs_key_t innodb_log_file_key;
|
|
extern mysql_pfs_key_t innodb_temp_file_key;
|
|
|
|
/* Following four macros are instumentations to register
|
|
various file I/O operations with performance schema.
|
|
1) register_pfs_file_open_begin() and register_pfs_file_open_end() are
|
|
used to register file creation, opening, closing and renaming.
|
|
2) register_pfs_file_io_begin() and register_pfs_file_io_end() are
|
|
used to register actual file read, write and flush
|
|
3) register_pfs_file_close_begin() and register_pfs_file_close_end()
|
|
are used to register file deletion operations*/
|
|
# define register_pfs_file_open_begin(state, locker, key, op, name, \
|
|
src_file, src_line) \
|
|
do { \
|
|
locker = PSI_FILE_CALL(get_thread_file_name_locker)( \
|
|
state, key, op, name, &locker); \
|
|
if (locker != NULL) { \
|
|
PSI_FILE_CALL(start_file_open_wait)( \
|
|
locker, src_file, src_line); \
|
|
} \
|
|
} while (0)
|
|
|
|
# define register_pfs_file_open_end(locker, file) \
|
|
do { \
|
|
if (locker != NULL) { \
|
|
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(\
|
|
locker, file); \
|
|
} \
|
|
} while (0)
|
|
|
|
# define register_pfs_file_close_begin(state, locker, key, op, name, \
|
|
src_file, src_line) \
|
|
do { \
|
|
locker = PSI_FILE_CALL(get_thread_file_name_locker)( \
|
|
state, key, op, name, &locker); \
|
|
if (locker != NULL) { \
|
|
PSI_FILE_CALL(start_file_close_wait)( \
|
|
locker, src_file, src_line); \
|
|
} \
|
|
} while (0)
|
|
|
|
# define register_pfs_file_close_end(locker, result) \
|
|
do { \
|
|
if (locker != NULL) { \
|
|
PSI_FILE_CALL(end_file_close_wait)( \
|
|
locker, result); \
|
|
} \
|
|
} while (0)
|
|
|
|
# define register_pfs_file_io_begin(state, locker, file, count, op, \
|
|
src_file, src_line) \
|
|
do { \
|
|
locker = PSI_FILE_CALL(get_thread_file_descriptor_locker)( \
|
|
state, file, op); \
|
|
if (locker != NULL) { \
|
|
PSI_FILE_CALL(start_file_wait)( \
|
|
locker, count, src_file, src_line); \
|
|
} \
|
|
} while (0)
|
|
|
|
# define register_pfs_file_io_end(locker, count) \
|
|
do { \
|
|
if (locker != NULL) { \
|
|
PSI_FILE_CALL(end_file_wait)(locker, count); \
|
|
} \
|
|
} while (0)
|
|
|
|
/* Following macros/functions are file I/O APIs that would be performance
|
|
schema instrumented if "UNIV_PFS_IO" is defined. They would point to
|
|
wrapper functions with performance schema instrumentation in such case.
|
|
|
|
os_file_create
|
|
os_file_create_simple
|
|
os_file_create_simple_no_error_handling
|
|
os_file_close
|
|
os_file_rename
|
|
os_aio
|
|
os_file_read
|
|
os_file_read_no_error_handling
|
|
os_file_write
|
|
|
|
The wrapper functions have the prefix of "innodb_". */
|
|
|
|
# define os_file_create(key, name, create, purpose, type, read_only, \
|
|
success) \
|
|
pfs_os_file_create_func(key, name, create, purpose, type, \
|
|
read_only, success, __FILE__, __LINE__)
|
|
|
|
# define os_file_create_simple(key, name, create, access, \
|
|
read_only, success) \
|
|
pfs_os_file_create_simple_func(key, name, create, access, \
|
|
read_only, success, __FILE__, __LINE__)
|
|
|
|
# define os_file_create_simple_no_error_handling( \
|
|
key, name, create_mode, access, read_only, success) \
|
|
pfs_os_file_create_simple_no_error_handling_func( \
|
|
key, name, create_mode, access, \
|
|
read_only, success, __FILE__, __LINE__)
|
|
|
|
# define os_file_close(file) \
|
|
pfs_os_file_close_func(file, __FILE__, __LINE__)
|
|
|
|
# define os_aio(type, mode, name, file, buf, offset, \
|
|
n, read_only, message1, message2) \
|
|
pfs_os_aio_func(type, mode, name, file, buf, offset, \
|
|
n, read_only, message1, message2, \
|
|
__FILE__, __LINE__)
|
|
|
|
# define os_file_read(type, file, buf, offset, n) \
|
|
pfs_os_file_read_func(type, file, buf, offset, n, __FILE__, __LINE__)
|
|
|
|
# define os_file_read_no_error_handling(type, file, buf, offset, n, o) \
|
|
pfs_os_file_read_no_error_handling_func( \
|
|
type, file, buf, offset, n, o, __FILE__, __LINE__)
|
|
|
|
# define os_file_write(type, name, file, buf, offset, n) \
|
|
pfs_os_file_write_func(type, name, file, buf, offset, \
|
|
n,__FILE__, __LINE__)
|
|
|
|
# define os_file_flush(file) \
|
|
pfs_os_file_flush_func(file, __FILE__, __LINE__)
|
|
|
|
# define os_file_rename(key, oldpath, newpath) \
|
|
pfs_os_file_rename_func(key, oldpath, newpath, __FILE__, __LINE__)
|
|
|
|
# define os_file_delete(key, name) \
|
|
pfs_os_file_delete_func(key, name, __FILE__, __LINE__)
|
|
|
|
# define os_file_delete_if_exists(key, name, exist) \
|
|
pfs_os_file_delete_if_exists_func(key, name, exist, __FILE__, __LINE__)
|
|
|
|
/** 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,
|
|
uint src_line)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** 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,
|
|
uint src_line)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** 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 use
|
|
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,
|
|
uint src_line)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** 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,
|
|
uint src_line);
|
|
|
|
/** 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,
|
|
uint src_line);
|
|
|
|
/** 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,
|
|
uint src_line);
|
|
|
|
/** 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,
|
|
uint src_line);
|
|
|
|
/** 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,
|
|
uint src_line);
|
|
|
|
/** 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,
|
|
uint src_line);
|
|
|
|
/** 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);
|
|
|
|
/**
|
|
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);
|
|
|
|
/**
|
|
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);
|
|
|
|
#else /* UNIV_PFS_IO */
|
|
|
|
/* If UNIV_PFS_IO is not defined, these I/O APIs point
|
|
to original un-instrumented file I/O APIs */
|
|
# define os_file_create(key, name, create, purpose, type, read_only, \
|
|
success) \
|
|
os_file_create_func(name, create, purpose, type, read_only, \
|
|
success)
|
|
|
|
# define os_file_create_simple(key, name, create_mode, access, \
|
|
read_only, success) \
|
|
os_file_create_simple_func(name, create_mode, access, \
|
|
read_only, success)
|
|
|
|
# define os_file_create_simple_no_error_handling( \
|
|
key, name, create_mode, access, read_only, success) \
|
|
os_file_create_simple_no_error_handling_func( \
|
|
name, create_mode, access, read_only, success)
|
|
|
|
# define os_file_close(file) os_file_close_func(file)
|
|
|
|
# define os_aio(type, mode, name, file, buf, offset, \
|
|
n, read_only, message1, message2) \
|
|
os_aio_func(type, mode, name, file, buf, offset, \
|
|
n, read_only, message1, message2)
|
|
|
|
# define os_file_read(type, file, buf, offset, n) \
|
|
os_file_read_func(type, file, buf, offset, n)
|
|
|
|
# define os_file_read_no_error_handling(type, file, buf, offset, n, o) \
|
|
os_file_read_no_error_handling_func(type, file, buf, offset, n, o)
|
|
|
|
# define os_file_write(type, name, file, buf, offset, n) \
|
|
os_file_write_func(type, name, file, buf, offset, n)
|
|
|
|
# define os_file_flush(file) os_file_flush_func(file)
|
|
|
|
# define os_file_rename(key, oldpath, newpath) \
|
|
os_file_rename_func(oldpath, newpath)
|
|
|
|
# define os_file_delete(key, name) os_file_delete_func(name)
|
|
|
|
# define os_file_delete_if_exists(key, name, exist) \
|
|
os_file_delete_if_exists_func(name, exist)
|
|
|
|
#endif /* UNIV_PFS_IO */
|
|
|
|
/** Gets a file size.
|
|
@param[in] file handle to a file
|
|
@return file size if OK, else set m_total_size to ~0 and m_alloc_size
|
|
to errno */
|
|
os_file_size_t
|
|
os_file_get_size(
|
|
const char* filename)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Gets a file size.
|
|
@param[in] file handle to a file
|
|
@return file size, or (os_offset_t) -1 on failure */
|
|
os_offset_t
|
|
os_file_get_size(
|
|
os_file_t file)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Write the specified number of zeros to a newly created file.
|
|
@param[in] name name of the file or path as a null-terminated
|
|
string
|
|
@param[in] file handle to a file
|
|
@param[in] size file size
|
|
@param[in] read_only Enable read-only checks if true
|
|
@return true if success */
|
|
bool
|
|
os_file_set_size(
|
|
const char* name,
|
|
os_file_t file,
|
|
os_offset_t size,
|
|
bool read_only)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Truncates a file at its current position.
|
|
@param[in/out] file file to be truncated
|
|
@return true if success */
|
|
bool
|
|
os_file_set_eof(
|
|
FILE* file); /*!< in: file to be truncated */
|
|
|
|
/** Truncates a file to a specified size in bytes. Do nothing if the size
|
|
preserved is smaller or equal than current size of file.
|
|
@param[in] pathname file path
|
|
@param[in] file file to be truncated
|
|
@param[in] size size preserved in bytes
|
|
@return true if success */
|
|
bool
|
|
os_file_truncate(
|
|
const char* pathname,
|
|
os_file_t file,
|
|
os_offset_t size);
|
|
|
|
/** NOTE! Use the corresponding macro os_file_flush(), not directly this
|
|
function!
|
|
Flushes the write buffers of a given file to the disk.
|
|
@param[in] file handle to a file
|
|
@return true if success */
|
|
bool
|
|
os_file_flush_func(
|
|
os_file_t file);
|
|
|
|
/** Retrieves the last error number if an error occurs in a file io function.
|
|
The number should be retrieved before any other OS calls (because they may
|
|
overwrite the error number). If the number is not known to this program,
|
|
the OS error number + 100 is returned.
|
|
@param[in] report true if we want an error message printed
|
|
for all errors
|
|
@return error number, or OS error number + 100 */
|
|
ulint
|
|
os_file_get_last_error(
|
|
bool report);
|
|
|
|
/** NOTE! Use the corresponding macro os_file_read(), not directly this
|
|
function!
|
|
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
|
|
@return DB_SUCCESS if request was successful */
|
|
dberr_t
|
|
os_file_read_func(
|
|
IORequest& type,
|
|
os_file_t file,
|
|
void* buf,
|
|
os_offset_t offset,
|
|
ulint n)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Rewind file to its start, read at most size - 1 bytes from it to str, and
|
|
NUL-terminate str. All errors are silently ignored. This function is
|
|
mostly meant to be used with temporary files.
|
|
@param[in,out] file file to read from
|
|
@param[in,out] str buffer where to read
|
|
@param[in] size size of buffer */
|
|
void
|
|
os_file_read_string(
|
|
FILE* file,
|
|
char* str,
|
|
ulint size);
|
|
|
|
/** NOTE! Use the corresponding macro os_file_read_no_error_handling(),
|
|
not directly this function!
|
|
Requests a synchronous positioned read operation. This function does not do
|
|
any error handling. In case of error it returns FALSE.
|
|
@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
|
|
@return DB_SUCCESS or error code */
|
|
dberr_t
|
|
os_file_read_no_error_handling_func(
|
|
IORequest& type,
|
|
os_file_t file,
|
|
void* buf,
|
|
os_offset_t offset,
|
|
ulint n,
|
|
ulint* o)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** NOTE! Use the corresponding macro os_file_write(), not directly this
|
|
function!
|
|
Requests a synchronous write 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
|
|
@return DB_SUCCESS if request was successful */
|
|
dberr_t
|
|
os_file_write_func(
|
|
IORequest& type,
|
|
const char* name,
|
|
os_file_t file,
|
|
const void* buf,
|
|
os_offset_t offset,
|
|
ulint n)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Check the existence and type of the given file.
|
|
@param[in] path pathname of the file
|
|
@param[out] exists true if file exists
|
|
@param[out] type type of the file (if it exists)
|
|
@return true if call succeeded */
|
|
bool
|
|
os_file_status(
|
|
const char* path,
|
|
bool* exists,
|
|
os_file_type_t* type);
|
|
|
|
/** This function returns a new path name after replacing the basename
|
|
in an old path with a new basename. The old_path is a full path
|
|
name including the extension. The tablename is in the normal
|
|
form "databasename/tablename". The new base name is found after
|
|
the forward slash. Both input strings are null terminated.
|
|
|
|
This function allocates memory to be returned. It is the callers
|
|
responsibility to free the return value after it is no longer needed.
|
|
|
|
@param[in] old_path pathname
|
|
@param[in] new_name new file name
|
|
@return own: new full pathname */
|
|
char*
|
|
os_file_make_new_pathname(
|
|
const char* old_path,
|
|
const char* new_name);
|
|
|
|
/** This function reduces a null-terminated full remote path name into
|
|
the path that is sent by MySQL for DATA DIRECTORY clause. It replaces
|
|
the 'databasename/tablename.ibd' found at the end of the path with just
|
|
'tablename'.
|
|
|
|
Since the result is always smaller than the path sent in, no new memory
|
|
is allocated. The caller should allocate memory for the path sent in.
|
|
This function manipulates that path in place.
|
|
|
|
If the path format is not as expected, just return. The result is used
|
|
to inform a SHOW CREATE TABLE command.
|
|
@param[in,out] data_dir_path Full path/data_dir_path */
|
|
void
|
|
os_file_make_data_dir_path(
|
|
char* data_dir_path);
|
|
|
|
/** Create all missing subdirectories along the given path.
|
|
@return DB_SUCCESS if OK, otherwise error code. */
|
|
dberr_t
|
|
os_file_create_subdirs_if_needed(
|
|
const char* path);
|
|
|
|
#ifdef UNIV_ENABLE_UNIT_TEST_GET_PARENT_DIR
|
|
/* Test the function os_file_get_parent_dir. */
|
|
void
|
|
unit_test_os_file_get_parent_dir();
|
|
#endif /* UNIV_ENABLE_UNIT_TEST_GET_PARENT_DIR */
|
|
|
|
/** Initializes the asynchronous io system. Creates one array each for ibuf
|
|
and log i/o. Also creates one array each for read and write where each
|
|
array is divided logically into n_read_segs and n_write_segs
|
|
respectively. The caller must create an i/o handler thread for each
|
|
segment in these arrays. This function also creates the sync array.
|
|
No i/o handler thread needs to be created for that
|
|
@param[in] n_read_segs number of reader threads
|
|
@param[in] n_write_segs number of writer threads
|
|
@param[in] n_slots_sync number of slots in the sync aio array */
|
|
|
|
bool
|
|
os_aio_init(
|
|
ulint n_read_segs,
|
|
ulint n_write_segs,
|
|
ulint n_slots_sync);
|
|
|
|
/**
|
|
Frees the asynchronous io system. */
|
|
void
|
|
os_aio_free();
|
|
|
|
/**
|
|
NOTE! Use the corresponding macro os_aio(), not directly this function!
|
|
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
|
|
@return DB_SUCCESS or error code */
|
|
dberr_t
|
|
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);
|
|
|
|
/** Wakes up all async i/o threads so that they know to exit themselves in
|
|
shutdown. */
|
|
void
|
|
os_aio_wake_all_threads_at_shutdown();
|
|
|
|
/** Waits until there are no pending writes in os_aio_write_array. There can
|
|
be other, synchronous, pending writes. */
|
|
void
|
|
os_aio_wait_until_no_pending_writes();
|
|
|
|
/** Wakes up simulated aio i/o-handler threads if they have something to do. */
|
|
void
|
|
os_aio_simulated_wake_handler_threads();
|
|
|
|
#ifdef _WIN32
|
|
/** This function can be called if one wants to post a batch of reads and
|
|
prefers an i/o-handler thread to handle them all at once later. You must
|
|
call os_aio_simulated_wake_handler_threads later to ensure the threads
|
|
are not left sleeping! */
|
|
void
|
|
os_aio_simulated_put_read_threads_to_sleep();
|
|
#else /* _WIN32 */
|
|
# define os_aio_simulated_put_read_threads_to_sleep()
|
|
#endif /* _WIN32 */
|
|
|
|
/** This is the generic AIO handler interface function.
|
|
Waits for an aio operation to complete. This function is used to wait the
|
|
for completed requests. The AIO array of pending requests is divided
|
|
into segments. The thread specifies which segment or slot it wants to wait
|
|
for. NOTE: this function will also take care of freeing the aio slot,
|
|
therefore no other thread is allowed to do the freeing!
|
|
@param[in] segment the number of the segment in the aio arrays to
|
|
wait for; segment 0 is the ibuf I/O thread,
|
|
segment 1 the log I/O thread, then follow the
|
|
non-ibuf read threads, and as the last are the
|
|
non-ibuf write threads; if this is
|
|
ULINT_UNDEFINED, then it means that sync AIO
|
|
is used, and this parameter is ignored
|
|
@param[out] m1 the messages passed with the AIO request;
|
|
note that also in the case where the AIO
|
|
operation failed, these output parameters
|
|
are valid and can be used to restart the
|
|
operation, for example
|
|
@param[out] m2 callback message
|
|
@param[out] type OS_FILE_WRITE or ..._READ
|
|
@return DB_SUCCESS or error code */
|
|
dberr_t
|
|
os_aio_handler(
|
|
ulint segment,
|
|
fil_node_t** m1,
|
|
void** m2,
|
|
IORequest* type);
|
|
|
|
/** Prints info of the aio arrays.
|
|
@param[in/out] file file where to print */
|
|
void
|
|
os_aio_print(FILE* file);
|
|
|
|
/** Refreshes the statistics used to print per-second averages. */
|
|
void
|
|
os_aio_refresh_stats();
|
|
|
|
/** Checks that all slots in the system have been freed, that is, there are
|
|
no pending io operations. */
|
|
bool
|
|
os_aio_all_slots_free();
|
|
|
|
#ifdef UNIV_DEBUG
|
|
|
|
/** Prints all pending IO
|
|
@param[in] file file where to print */
|
|
void
|
|
os_aio_print_pending_io(FILE* file);
|
|
|
|
#endif /* UNIV_DEBUG */
|
|
|
|
/** This function returns information about the specified file
|
|
@param[in] path pathname of the file
|
|
@param[in] stat_info information of a file in a directory
|
|
@param[in] check_rw_perm for testing whether the file can be opened
|
|
in RW mode
|
|
@param[in] read_only if true read only mode checks are enforced
|
|
@return DB_SUCCESS if all OK */
|
|
dberr_t
|
|
os_file_get_status(
|
|
const char* path,
|
|
os_file_stat_t* stat_info,
|
|
bool check_rw_perm,
|
|
bool read_only);
|
|
|
|
/** Creates a temporary file in the location specified by the parameter
|
|
path. If the path is NULL then it will be created on --tmpdir location.
|
|
This function is defined in ha_innodb.cc.
|
|
@param[in] path location for creating temporary file
|
|
@return temporary file descriptor, or < 0 on error */
|
|
int
|
|
innobase_mysql_tmpfile(
|
|
const char* path);
|
|
|
|
/** Set the file create umask
|
|
@param[in] umask The umask to use for file creation. */
|
|
void
|
|
os_file_set_umask(ulint umask);
|
|
|
|
/** Check if the file system supports sparse files.
|
|
|
|
Warning: On POSIX systems we try and punch a hole from offset 0 to
|
|
the system configured page size. This should only be called on an empty
|
|
file.
|
|
|
|
Note: On Windows we use the name and on Unices we use the file handle.
|
|
|
|
@param[in] name File name
|
|
@param[in] fh File handle for the file - if opened
|
|
@return true if the file system supports sparse files */
|
|
bool
|
|
os_is_sparse_file_supported(
|
|
const char* path,
|
|
os_file_t fh)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Free storage space associated with a section of the file.
|
|
@param[in] fh Open file handle
|
|
@param[in] off Starting offset (SEEK_SET)
|
|
@param[in] len Size of the hole
|
|
@return DB_SUCCESS or error code */
|
|
dberr_t
|
|
os_file_punch_hole(
|
|
IORequest& type,
|
|
os_file_t fh,
|
|
os_offset_t off,
|
|
os_offset_t len)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Free storage space associated with a section of the file.
|
|
@param[in] fh Open file handle
|
|
@param[in] off Starting offset (SEEK_SET)
|
|
@param[in] len Size of the hole
|
|
@return DB_SUCCESS or error code */
|
|
dberr_t
|
|
os_file_punch_hole(
|
|
os_file_t fh,
|
|
os_offset_t off,
|
|
os_offset_t len)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Normalizes a directory path for the current OS:
|
|
On Windows, we convert '/' to '\', else we convert '\' to '/'.
|
|
@param[in,out] str A null-terminated directory and file path */
|
|
void os_normalize_path(char* str);
|
|
|
|
/* Determine if a path is an absolute path or not.
|
|
@param[in] OS directory or file path to evaluate
|
|
@retval true if an absolute path
|
|
@retval false if a relative path */
|
|
UNIV_INLINE
|
|
bool
|
|
is_absolute_path(
|
|
const char* path)
|
|
{
|
|
if (path[0] == OS_PATH_SEPARATOR) {
|
|
return(true);
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
if (path[1] == ':' && path[2] == OS_PATH_SEPARATOR) {
|
|
return(true);
|
|
}
|
|
#endif /* _WIN32 */
|
|
|
|
return(false);
|
|
}
|
|
|
|
/***********************************************************************//**
|
|
Try to get number of bytes per sector from file system.
|
|
@return file block size */
|
|
UNIV_INTERN
|
|
ulint
|
|
os_file_get_block_size(
|
|
/*===================*/
|
|
os_file_t file, /*!< in: handle to a file */
|
|
const char* name); /*!< in: file name */
|
|
|
|
#include "os0file.ic"
|
|
|
|
#endif /* os0file_h */
|