diff options
Diffstat (limited to 'storage/innobase/os')
| -rw-r--r-- | storage/innobase/os/os0event.cc | 515 | ||||
| -rw-r--r-- | storage/innobase/os/os0file.cc | 4349 | ||||
| -rw-r--r-- | storage/innobase/os/os0thread.cc | 131 |
3 files changed, 4995 insertions, 0 deletions
diff --git a/storage/innobase/os/os0event.cc b/storage/innobase/os/os0event.cc new file mode 100644 index 00000000..f18633cc --- /dev/null +++ b/storage/innobase/os/os0event.cc @@ -0,0 +1,515 @@ +/***************************************************************************** + +Copyright (c) 2013, 2015, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2019, 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, Fifth Floor, Boston, MA 02110-1335 USA + +*****************************************************************************/ + +/**************************************************//** +@file os/os0event.cc +The interface to the operating system condition variables. + +Created 2012-09-23 Sunny Bains +*******************************************************/ + +#include "os0event.h" +#include "ut0mutex.h" +#include <my_sys.h> + +#ifdef _WIN32 +#include <windows.h> +#include <synchapi.h> +/** Native condition variable. */ +typedef CONDITION_VARIABLE os_cond_t; +#else +/** Native condition variable */ +typedef pthread_cond_t os_cond_t; +#endif /* _WIN32 */ + +/** InnoDB condition variable. */ +struct os_event { + os_event() UNIV_NOTHROW; + + ~os_event() UNIV_NOTHROW; + + /** + Destroys a condition variable */ + void destroy() UNIV_NOTHROW + { +#ifndef _WIN32 + int ret = pthread_cond_destroy(&cond_var); + ut_a(ret == 0); +#endif /* !_WIN32 */ + + mutex.destroy(); + } + + /** Set the event */ + void set() UNIV_NOTHROW + { + mutex.enter(); + + if (!m_set) { + broadcast(); + } + + mutex.exit(); + } + + int64_t reset() UNIV_NOTHROW + { + mutex.enter(); + + if (m_set) { + m_set = false; + } + + int64_t ret = signal_count; + + mutex.exit(); + + return(ret); + } + + /** + Waits for an event object until it is in the signaled state. + + Typically, if the event has been signalled after the os_event_reset() + we'll return immediately because event->m_set == true. + There are, however, situations (e.g.: sync_array code) where we may + lose this information. For example: + + thread A calls os_event_reset() + thread B calls os_event_set() [event->m_set == true] + thread C calls os_event_reset() [event->m_set == false] + thread A calls os_event_wait() [infinite wait!] + thread C calls os_event_wait() [infinite wait!] + + Where such a scenario is possible, to avoid infinite wait, the + value returned by reset() should be passed in as + reset_sig_count. */ + void wait_low(int64_t reset_sig_count) UNIV_NOTHROW; + + /** + Waits for an event object until it is in the signaled state or + a timeout is exceeded. + @param time_in_usec - timeout in microseconds, + or OS_SYNC_INFINITE_TIME + @param reset_sig_count- zero or the value returned by + previous call of os_event_reset(). + @return 0 if success, OS_SYNC_TIME_EXCEEDED if timeout was exceeded */ + ulint wait_time_low( + ulint time_in_usec, + int64_t reset_sig_count) UNIV_NOTHROW; + + /** @return true if the event is in the signalled state. */ + bool is_set() const UNIV_NOTHROW + { + mutex.enter(); + bool is_set = m_set; + mutex.exit(); + return is_set; + } + +private: + /** + Initialize a condition variable */ + void init() UNIV_NOTHROW + { + + mutex.init(); + +#ifdef _WIN32 + InitializeConditionVariable(&cond_var); +#else + { + int ret; + + ret = pthread_cond_init(&cond_var, NULL); + ut_a(ret == 0); + } +#endif /* _WIN32 */ + } + + /** + Wait on condition variable */ + void wait() UNIV_NOTHROW + { +#ifdef _WIN32 + if (!SleepConditionVariableCS(&cond_var, mutex, INFINITE)) { + ut_error; + } +#else + { + int ret; + + ret = pthread_cond_wait(&cond_var, mutex); + ut_a(ret == 0); + } +#endif /* _WIN32 */ + } + + /** + Wakes all threads waiting for condition variable */ + void broadcast() UNIV_NOTHROW + { + m_set = true; + ++signal_count; + +#ifdef _WIN32 + WakeAllConditionVariable(&cond_var); +#else + { + int ret; + + ret = pthread_cond_broadcast(&cond_var); + ut_a(ret == 0); + } +#endif /* _WIN32 */ + } + + /** + Wakes one thread waiting for condition variable */ + void signal() UNIV_NOTHROW + { +#ifdef _WIN32 + WakeConditionVariable(&cond_var); +#else + { + int ret; + + ret = pthread_cond_signal(&cond_var); + ut_a(ret == 0); + } +#endif /* _WIN32 */ + } + + /** + Do a timed wait on condition variable. + @param abstime - timeout + @param time_in_ms - timeout in milliseconds. + @return true if timed out, false otherwise */ + bool timed_wait( +#ifndef _WIN32 + const timespec* abstime +#else + DWORD time_in_ms +#endif /* !_WIN32 */ + ); + +private: + bool m_set; /*!< this is true when the + event is in the signaled + state, i.e., a thread does + not stop if it tries to wait + for this event */ + int64_t signal_count; /*!< this is incremented + each time the event becomes + signaled */ + mutable OSMutex mutex; /*!< this mutex protects + the next fields */ + + + os_cond_t cond_var; /*!< condition variable is + used in waiting for the event */ + +protected: + // Disable copying + os_event(const os_event&); + os_event& operator=(const os_event&); +}; + +/** +Do a timed wait on condition variable. +@param abstime - absolute time to wait +@param time_in_ms - timeout in milliseconds +@return true if timed out */ +bool +os_event::timed_wait( +#ifndef _WIN32 + const timespec* abstime +#else + DWORD time_in_ms +#endif /* !_WIN32 */ +) +{ +#ifdef _WIN32 + BOOL ret; + + ret = SleepConditionVariableCS(&cond_var, mutex, time_in_ms); + + if (!ret) { + DWORD err = GetLastError(); + + /* FQDN=msdn.microsoft.com + @see http://$FQDN/en-us/library/ms686301%28VS.85%29.aspx, + + "Condition variables are subject to spurious wakeups + (those not associated with an explicit wake) and stolen wakeups + (another thread manages to run before the woken thread)." + Check for both types of timeouts. + Conditions are checked by the caller.*/ + if (err == WAIT_TIMEOUT || err == ERROR_TIMEOUT) { + return(true); + } + } + + ut_a(ret); + + return(false); +#else + int ret; + + ret = pthread_cond_timedwait(&cond_var, mutex, abstime); + + switch (ret) { + case 0: + case ETIMEDOUT: + /* We play it safe by checking for EINTR even though + according to the POSIX documentation it can't return EINTR. */ + case EINTR: + break; + + default: + ib::error() << "pthread_cond_timedwait() returned: " << ret + << ": abstime={" << abstime->tv_sec << "," + << abstime->tv_nsec << "}"; + ut_error; + } + + return(ret == ETIMEDOUT); +#endif /* _WIN32 */ +} + +/** +Waits for an event object until it is in the signaled state. + +Typically, if the event has been signalled after the os_event_reset() +we'll return immediately because event->m_set == true. +There are, however, situations (e.g.: sync_array code) where we may +lose this information. For example: + +thread A calls os_event_reset() +thread B calls os_event_set() [event->m_set == true] +thread C calls os_event_reset() [event->m_set == false] +thread A calls os_event_wait() [infinite wait!] +thread C calls os_event_wait() [infinite wait!] + +Where such a scenario is possible, to avoid infinite wait, the +value returned by reset() should be passed in as +reset_sig_count. */ +void +os_event::wait_low( + int64_t reset_sig_count) UNIV_NOTHROW +{ + mutex.enter(); + + if (!reset_sig_count) { + reset_sig_count = signal_count; + } + + while (!m_set && signal_count == reset_sig_count) { + + wait(); + + /* Spurious wakeups may occur: we have to check if the + event really has been signaled after we came here to wait. */ + } + + mutex.exit(); +} + +/** +Waits for an event object until it is in the signaled state or +a timeout is exceeded. +@param time_in_usec - timeout in microseconds, or OS_SYNC_INFINITE_TIME +@param reset_sig_count - zero or the value returned by previous call + of os_event_reset(). +@return 0 if success, OS_SYNC_TIME_EXCEEDED if timeout was exceeded */ +ulint +os_event::wait_time_low( + ulint time_in_usec, + int64_t reset_sig_count) UNIV_NOTHROW +{ + bool timed_out = false; + +#ifdef _WIN32 + DWORD time_in_ms; + + if (time_in_usec != OS_SYNC_INFINITE_TIME) { + time_in_ms = DWORD(time_in_usec / 1000); + } else { + time_in_ms = INFINITE; + } +#else + struct timespec abstime; + + if (time_in_usec != OS_SYNC_INFINITE_TIME) { + ulonglong usec = ulonglong(time_in_usec) + my_hrtime().val; + abstime.tv_sec = static_cast<time_t>(usec / 1000000); + abstime.tv_nsec = static_cast<uint>((usec % 1000000) * 1000); + } else { + abstime.tv_nsec = 999999999; + abstime.tv_sec = (time_t) ULINT_MAX; + } + + ut_a(abstime.tv_nsec <= 999999999); + +#endif /* _WIN32 */ + + mutex.enter(); + + if (!reset_sig_count) { + reset_sig_count = signal_count; + } + + do { + if (m_set || signal_count != reset_sig_count) { + + break; + } + +#ifndef _WIN32 + timed_out = timed_wait(&abstime); +#else + timed_out = timed_wait(time_in_ms); +#endif /* !_WIN32 */ + + } while (!timed_out); + + mutex.exit(); + + return(timed_out ? OS_SYNC_TIME_EXCEEDED : 0); +} + +/** Constructor */ +os_event::os_event() UNIV_NOTHROW +{ + init(); + + m_set = false; + + /* We return this value in os_event_reset(), + which can then be be used to pass to the + os_event_wait_low(). The value of zero is + reserved in os_event_wait_low() for the case + when the caller does not want to pass any + signal_count value. To distinguish between + the two cases we initialize signal_count + to 1 here. */ + + signal_count = 1; +} + +/** Destructor */ +os_event::~os_event() UNIV_NOTHROW +{ + destroy(); +} + +/** +Creates an event semaphore, i.e., a semaphore which may just have two +states: signaled and nonsignaled. The created event is manual reset: it +must be reset explicitly by calling sync_os_reset_event. +@return the event handle */ +os_event_t os_event_create(const char*) +{ + return(UT_NEW_NOKEY(os_event())); +} + +/** +Check if the event is set. +@return true if set */ +bool +os_event_is_set( +/*============*/ + const os_event_t event) /*!< in: event to test */ +{ + return(event->is_set()); +} + +/** +Sets an event semaphore to the signaled state: lets waiting threads +proceed. */ +void +os_event_set( +/*=========*/ + os_event_t event) /*!< in/out: event to set */ +{ + event->set(); +} + +/** +Resets an event semaphore to the nonsignaled state. Waiting threads will +stop to wait for the event. +The return value should be passed to os_even_wait_low() if it is desired +that this thread should not wait in case of an intervening call to +os_event_set() between this os_event_reset() and the +os_event_wait_low() call. See comments for os_event_wait_low(). +@return current signal_count. */ +int64_t +os_event_reset( +/*===========*/ + os_event_t event) /*!< in/out: event to reset */ +{ + return(event->reset()); +} + +/** +Waits for an event object until it is in the signaled state or +a timeout is exceeded. +@return 0 if success, OS_SYNC_TIME_EXCEEDED if timeout was exceeded */ +ulint +os_event_wait_time_low( +/*===================*/ + os_event_t event, /*!< in/out: event to wait */ + ulint time_in_usec, /*!< in: timeout in + microseconds, or + OS_SYNC_INFINITE_TIME */ + int64_t reset_sig_count) /*!< in: zero or the value + returned by previous call of + os_event_reset(). */ +{ + return(event->wait_time_low(time_in_usec, reset_sig_count)); +} + +/** +Waits for an event object until it is in the signaled state. + +Where such a scenario is possible, to avoid infinite wait, the +value returned by os_event_reset() should be passed in as +reset_sig_count. */ +void +os_event_wait_low( +/*==============*/ + os_event_t event, /*!< in: event to wait */ + int64_t reset_sig_count) /*!< in: zero or the value + returned by previous call of + os_event_reset(). */ +{ + event->wait_low(reset_sig_count); +} + +/** +Frees an event object. */ +void +os_event_destroy( +/*=============*/ + os_event_t& event) /*!< in/own: event to free */ + +{ + UT_DELETE(event); + event = NULL; +} diff --git a/storage/innobase/os/os0file.cc b/storage/innobase/os/os0file.cc new file mode 100644 index 00000000..7a6829e7 --- /dev/null +++ b/storage/innobase/os/os0file.cc @@ -0,0 +1,4349 @@ +/*********************************************************************** + +Copyright (c) 1995, 2019, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2009, Percona Inc. +Copyright (c) 2013, 2021, MariaDB Corporation. + +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, Fifth Floor, Boston, MA 02110-1335 USA + +***********************************************************************/ + +/**************************************************//** +@file os/os0file.cc +The interface to the operating system file i/o primitives + +Created 10/21/1995 Heikki Tuuri +*******************************************************/ + +#ifndef UNIV_INNOCHECKSUM +#include "os0file.h" +#include "sql_const.h" + +#ifdef UNIV_LINUX +# include <sys/types.h> +# include <sys/stat.h> +#endif + +#include "srv0srv.h" +#include "srv0start.h" +#include "fil0fil.h" +#include "fsp0fsp.h" +#ifdef HAVE_LINUX_UNISTD_H +#include "unistd.h" +#endif +#include "os0event.h" +#include "os0thread.h" + +#include <vector> +#include <tpool_structs.h> + +#ifdef LINUX_NATIVE_AIO +#include <libaio.h> +#endif /* LINUX_NATIVE_AIO */ + +#ifdef HAVE_FALLOC_PUNCH_HOLE_AND_KEEP_SIZE +# include <fcntl.h> +# include <linux/falloc.h> +#endif /* HAVE_FALLOC_PUNCH_HOLE_AND_KEEP_SIZE */ + +#if defined(UNIV_LINUX) && defined(HAVE_SYS_IOCTL_H) +# include <sys/ioctl.h> +# ifndef DFS_IOCTL_ATOMIC_WRITE_SET +# define DFS_IOCTL_ATOMIC_WRITE_SET _IOW(0x95, 2, uint) +# endif +#endif + +#ifdef _WIN32 +#include <winioctl.h> +#else +// my_test_if_atomic_write() +#include <my_sys.h> +#endif + +#include "buf0dblwr.h" + +#include <thread> +#include <chrono> + +/* Per-IO operation environment*/ +class io_slots +{ +private: + tpool::cache<tpool::aiocb> m_cache; + tpool::task_group m_group; + int m_max_aio; +public: + io_slots(int max_submitted_io, int max_callback_concurrency) : + m_cache(max_submitted_io), + m_group(max_callback_concurrency), + m_max_aio(max_submitted_io) + { + } + /* Get cached AIO control block */ + tpool::aiocb* acquire() + { + return m_cache.get(); + } + /* Release AIO control block back to cache */ + void release(tpool::aiocb* aiocb) + { + m_cache.put(aiocb); + } + + bool contains(tpool::aiocb* aiocb) + { + return m_cache.contains(aiocb); + } + + /* Wait for completions of all AIO operations */ + void wait() + { + m_cache.wait(); + } + + size_t pending_io_count() + { + return (size_t)m_max_aio - m_cache.size(); + } + + tpool::task_group* get_task_group() + { + return &m_group; + } + + ~io_slots() + { + wait(); + } +}; + +static io_slots *read_slots; +static io_slots *write_slots; + +/** Number of retries for partial I/O's */ +constexpr ulint NUM_RETRIES_ON_PARTIAL_IO = 10; + +/* This specifies the file permissions InnoDB uses when it creates files in +Unix; the value of os_innodb_umask is initialized in ha_innodb.cc to +my_umask */ + +#ifndef _WIN32 +/** Umask for creating files */ +static ulint os_innodb_umask = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP; +#else +/** Umask for creating files */ +static ulint os_innodb_umask = 0; +#endif /* _WIN32 */ + + +#ifdef WITH_INNODB_DISALLOW_WRITES +#define WAIT_ALLOW_WRITES() os_event_wait(srv_allow_writes_event) +#else +#define WAIT_ALLOW_WRITES() do { } while (0) +#endif /* WITH_INNODB_DISALLOW_WRITES */ + + +Atomic_counter<ulint> os_n_file_reads; +static ulint os_bytes_read_since_printout; +ulint os_n_file_writes; +ulint os_n_fsyncs; +static ulint os_n_file_reads_old; +static ulint os_n_file_writes_old; +static ulint os_n_fsyncs_old; + +static time_t os_last_printout; +bool os_has_said_disk_full; + +/** Default Zip compression level */ +extern uint page_zip_level; + +#ifdef UNIV_PFS_IO +/* Keys to register InnoDB I/O with performance schema */ +mysql_pfs_key_t innodb_data_file_key; +mysql_pfs_key_t innodb_log_file_key; +mysql_pfs_key_t innodb_temp_file_key; +#endif + +/** Handle errors for file operations. +@param[in] name name of a file or NULL +@param[in] operation operation +@param[in] should_abort whether to abort on an unknown error +@param[in] on_error_silent whether to suppress reports of non-fatal errors +@return true if we should retry the operation */ +static MY_ATTRIBUTE((warn_unused_result)) +bool +os_file_handle_error_cond_exit( + const char* name, + const char* operation, + bool should_abort, + bool on_error_silent); + +/** Does error handling when a file operation fails. +@param[in] name name of a file or NULL +@param[in] operation operation name that failed +@return true if we should retry the operation */ +static +bool +os_file_handle_error( + const char* name, + const char* operation) +{ + /* Exit in case of unknown error */ + return(os_file_handle_error_cond_exit(name, operation, true, false)); +} + +/** Does error handling when a file operation fails. +@param[in] name name of a file or NULL +@param[in] operation operation name that failed +@param[in] on_error_silent if true then don't print any message to the log. +@return true if we should retry the operation */ +static +bool +os_file_handle_error_no_exit( + const char* name, + const char* operation, + bool on_error_silent) +{ + /* Don't exit in case of unknown error */ + return(os_file_handle_error_cond_exit( + name, operation, false, on_error_silent)); +} + +/** Handle RENAME error. +@param name old name of the file +@param new_name new name of the file */ +static void os_file_handle_rename_error(const char* name, const char* new_name) +{ + if (os_file_get_last_error(true) != OS_FILE_DISK_FULL) { + ib::error() << "Cannot rename file '" << name << "' to '" + << new_name << "'"; + } else if (!os_has_said_disk_full) { + os_has_said_disk_full = true; + /* Disk full error is reported irrespective of the + on_error_silent setting. */ + ib::error() << "Full disk prevents renaming file '" + << name << "' to '" << new_name << "'"; + } +} + + +#ifdef _WIN32 + +/** + Wrapper around Windows DeviceIoControl() function. + + Works synchronously, also in case for handle opened + for async access (i.e with FILE_FLAG_OVERLAPPED). + + Accepts the same parameters as DeviceIoControl(),except + last parameter (OVERLAPPED). +*/ +static +BOOL +os_win32_device_io_control( + HANDLE handle, + DWORD code, + LPVOID inbuf, + DWORD inbuf_size, + LPVOID outbuf, + DWORD outbuf_size, + LPDWORD bytes_returned +) +{ + OVERLAPPED overlapped = { 0 }; + overlapped.hEvent = tpool::win_get_syncio_event(); + BOOL result = DeviceIoControl(handle, code, inbuf, inbuf_size, outbuf, + outbuf_size, NULL, &overlapped); + + if (result || (GetLastError() == ERROR_IO_PENDING)) { + /* Wait for async io to complete */ + result = GetOverlappedResult(handle, &overlapped, bytes_returned, TRUE); + } + + return result; +} + +#endif + + + +/** Helper class for doing synchronous file IO. Currently, the objective +is to hide the OS specific code, so that the higher level functions aren't +peppered with #ifdef. Makes the code flow difficult to follow. */ +class SyncFileIO +{ +public: + /** Constructor + @param[in] fh File handle + @param[in,out] buf Buffer to read/write + @param[in] n Number of bytes to read/write + @param[in] offset Offset where to read or write */ + SyncFileIO(os_file_t fh, void *buf, ulint n, os_offset_t offset) : + m_fh(fh), m_buf(buf), m_n(static_cast<ssize_t>(n)), m_offset(offset) + { ut_ad(m_n > 0); } + + /** Do the read/write + @param[in] request The IO context and type + @return the number of bytes read/written or negative value on error */ + ssize_t execute(const IORequest &request); + + /** Move the read/write offset up to where the partial IO succeeded. + @param[in] n_bytes The number of bytes to advance */ + void advance(ssize_t n_bytes) + { + m_offset+= n_bytes; + ut_ad(m_n >= n_bytes); + m_n-= n_bytes; + m_buf= reinterpret_cast<uchar*>(m_buf) + n_bytes; + } + +private: + /** Open file handle */ + const os_file_t m_fh; + /** Buffer to read/write */ + void *m_buf; + /** Number of bytes to read/write */ + ssize_t m_n; + /** Offset from where to read/write */ + os_offset_t m_offset; +}; + +#undef USE_FILE_LOCK +#ifndef _WIN32 +/* On Windows, mandatory locking is used */ +# define USE_FILE_LOCK +#endif +#ifdef USE_FILE_LOCK +/** Obtain an exclusive lock on a file. +@param[in] fd file descriptor +@param[in] name file name +@return 0 on success */ +static +int +os_file_lock( + int fd, + const char* name) +{ + if (my_disable_locking) { + return 0; + } + + struct flock lk; + + lk.l_type = F_WRLCK; + lk.l_whence = SEEK_SET; + lk.l_start = lk.l_len = 0; + + if (fcntl(fd, F_SETLK, &lk) == -1) { + + ib::error() + << "Unable to lock " << name + << " error: " << errno; + + if (errno == EAGAIN || errno == EACCES) { + + ib::info() + << "Check that you do not already have" + " another mysqld process using the" + " same InnoDB data or log files."; + } + + return(-1); + } + + return(0); +} +#endif /* USE_FILE_LOCK */ + + +/** Create a temporary file. This function is like tmpfile(3), but +the temporary file is created in the in the mysql server configuration +parameter (--tmpdir). +@return temporary file handle, or NULL on error */ +FILE* +os_file_create_tmpfile() +{ + FILE* file = NULL; + WAIT_ALLOW_WRITES(); + File fd = mysql_tmpfile("ib"); + + if (fd >= 0) { + file = my_fdopen(fd, 0, O_RDWR|O_TRUNC|O_CREAT|FILE_BINARY, + MYF(MY_WME)); + if (!file) { + my_close(fd, MYF(MY_WME)); + } + } + + if (file == NULL) { + + ib::error() + << "Unable to create temporary file; errno: " + << errno; + } + + return(file); +} + +/** 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) +{ + if (size != 0) { + rewind(file); + + size_t flen = fread(str, 1, size - 1, file); + + str[flen] = '\0'; + } +} + +/** 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] tablename Contains new base name +@return own: new full pathname */ +char* +os_file_make_new_pathname( + const char* old_path, + const char* tablename) +{ + ulint dir_len; + char* last_slash; + char* base_name; + char* new_path; + ulint new_path_len; + + /* Split the tablename into its database and table name components. + They are separated by a '/'. */ + last_slash = strrchr((char*) tablename, '/'); + base_name = last_slash ? last_slash + 1 : (char*) tablename; + + /* Find the offset of the last slash. We will strip off the + old basename.ibd which starts after that slash. */ + last_slash = strrchr((char*) old_path, OS_PATH_SEPARATOR); + dir_len = last_slash ? ulint(last_slash - old_path) : strlen(old_path); + + /* allocate a new path and move the old directory path to it. */ + new_path_len = dir_len + strlen(base_name) + sizeof "/.ibd"; + new_path = static_cast<char*>(ut_malloc_nokey(new_path_len)); + memcpy(new_path, old_path, dir_len); + + snprintf(new_path + dir_len, new_path_len - dir_len, + "%c%s.ibd", OS_PATH_SEPARATOR, base_name); + + return(new_path); +} + +/** 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) +{ + /* Replace the period before the extension with a null byte. */ + char* ptr = strrchr((char*) data_dir_path, '.'); + + if (ptr == NULL) { + return; + } + + ptr[0] = '\0'; + + /* The tablename starts after the last slash. */ + ptr = strrchr((char*) data_dir_path, OS_PATH_SEPARATOR); + + if (ptr == NULL) { + return; + } + + ptr[0] = '\0'; + + char* tablename = ptr + 1; + + /* The databasename starts after the next to last slash. */ + ptr = strrchr((char*) data_dir_path, OS_PATH_SEPARATOR); + + if (ptr == NULL) { + return; + } + + ulint tablename_len = strlen(tablename); + + memmove(++ptr, tablename, tablename_len); + + ptr[tablename_len] = '\0'; +} + +/** Check if the path refers to the root of a drive using a pointer +to the last directory separator that the caller has fixed. +@param[in] path path name +@param[in] path last directory separator in the path +@return true if this path is a drive root, false if not */ +UNIV_INLINE +bool +os_file_is_root( + const char* path, + const char* last_slash) +{ + return( +#ifdef _WIN32 + (last_slash == path + 2 && path[1] == ':') || +#endif /* _WIN32 */ + last_slash == path); +} + +/** Return the parent directory component of a null-terminated path. +Return a new buffer containing the string up to, but not including, +the final component of the path. +The path returned will not contain a trailing separator. +Do not return a root path, return NULL instead. +The final component trimmed off may be a filename or a directory name. +If the final component is the only component of the path, return NULL. +It is the caller's responsibility to free the returned string after it +is no longer needed. +@param[in] path Path name +@return own: parent directory of the path */ +static +char* +os_file_get_parent_dir( + const char* path) +{ + bool has_trailing_slash = false; + + /* Find the offset of the last slash */ + const char* last_slash = strrchr(path, OS_PATH_SEPARATOR); + + if (!last_slash) { + /* No slash in the path, return NULL */ + return(NULL); + } + + /* Ok, there is a slash. Is there anything after it? */ + if (static_cast<size_t>(last_slash - path + 1) == strlen(path)) { + has_trailing_slash = true; + } + + /* Reduce repetative slashes. */ + while (last_slash > path + && last_slash[-1] == OS_PATH_SEPARATOR) { + last_slash--; + } + + /* Check for the root of a drive. */ + if (os_file_is_root(path, last_slash)) { + return(NULL); + } + + /* If a trailing slash prevented the first strrchr() from trimming + the last component of the path, trim that component now. */ + if (has_trailing_slash) { + /* Back up to the previous slash. */ + last_slash--; + while (last_slash > path + && last_slash[0] != OS_PATH_SEPARATOR) { + last_slash--; + } + + /* Reduce repetative slashes. */ + while (last_slash > path + && last_slash[-1] == OS_PATH_SEPARATOR) { + last_slash--; + } + } + + /* Check for the root of a drive. */ + if (os_file_is_root(path, last_slash)) { + return(NULL); + } + + if (last_slash - path < 0) { + /* Sanity check, it prevents gcc from trying to handle this case which + * results in warnings for some optimized builds */ + return (NULL); + } + + /* Non-trivial directory component */ + + return(mem_strdupl(path, ulint(last_slash - path))); +} +#ifdef UNIV_ENABLE_UNIT_TEST_GET_PARENT_DIR + +/* Test the function os_file_get_parent_dir. */ +void +test_os_file_get_parent_dir( + const char* child_dir, + const char* expected_dir) +{ + char* child = mem_strdup(child_dir); + char* expected = expected_dir == NULL ? NULL + : mem_strdup(expected_dir); + + /* os_file_get_parent_dir() assumes that separators are + converted to OS_PATH_SEPARATOR. */ + os_normalize_path(child); + os_normalize_path(expected); + + char* parent = os_file_get_parent_dir(child); + + bool unexpected = (expected == NULL + ? (parent != NULL) + : (0 != strcmp(parent, expected))); + if (unexpected) { + ib::fatal() << "os_file_get_parent_dir('" << child + << "') returned '" << parent + << "', instead of '" << expected << "'."; + } + ut_free(parent); + ut_free(child); + ut_free(expected); +} + +/* Test the function os_file_get_parent_dir. */ +void +unit_test_os_file_get_parent_dir() +{ + test_os_file_get_parent_dir("/usr/lib/a", "/usr/lib"); + test_os_file_get_parent_dir("/usr/", NULL); + test_os_file_get_parent_dir("//usr//", NULL); + test_os_file_get_parent_dir("usr", NULL); + test_os_file_get_parent_dir("usr//", NULL); + test_os_file_get_parent_dir("/", NULL); + test_os_file_get_parent_dir("//", NULL); + test_os_file_get_parent_dir(".", NULL); + test_os_file_get_parent_dir("..", NULL); +# ifdef _WIN32 + test_os_file_get_parent_dir("D:", NULL); + test_os_file_get_parent_dir("D:/", NULL); + test_os_file_get_parent_dir("D:\\", NULL); + test_os_file_get_parent_dir("D:/data", NULL); + test_os_file_get_parent_dir("D:/data/", NULL); + test_os_file_get_parent_dir("D:\\data\\", NULL); + test_os_file_get_parent_dir("D:///data/////", NULL); + test_os_file_get_parent_dir("D:\\\\\\data\\\\\\\\", NULL); + test_os_file_get_parent_dir("D:/data//a", "D:/data"); + test_os_file_get_parent_dir("D:\\data\\\\a", "D:\\data"); + test_os_file_get_parent_dir("D:///data//a///b/", "D:///data//a"); + test_os_file_get_parent_dir("D:\\\\\\data\\\\a\\\\\\b\\", "D:\\\\\\data\\\\a"); +#endif /* _WIN32 */ +} +#endif /* UNIV_ENABLE_UNIT_TEST_GET_PARENT_DIR */ + + +/** Creates all missing subdirectories along the given path. +@param[in] path Path name +@return DB_SUCCESS if OK, otherwise error code. */ +dberr_t +os_file_create_subdirs_if_needed( + const char* path) +{ + if (srv_read_only_mode) { + + ib::error() + << "read only mode set. Can't create " + << "subdirectories '" << path << "'"; + + return(DB_READ_ONLY); + + } + + char* subdir = os_file_get_parent_dir(path); + + if (subdir == NULL) { + /* subdir is root or cwd, nothing to do */ + return(DB_SUCCESS); + } + + /* Test if subdir exists */ + os_file_type_t type; + bool subdir_exists; + bool success = os_file_status(subdir, &subdir_exists, &type); + + if (success && !subdir_exists) { + + /* Subdir does not exist, create it */ + dberr_t err = os_file_create_subdirs_if_needed(subdir); + + if (err != DB_SUCCESS) { + + ut_free(subdir); + + return(err); + } + + success = os_file_create_directory(subdir, false); + } + + ut_free(subdir); + + return(success ? DB_SUCCESS : DB_ERROR); +} + + + +/** Do the read/write +@param[in] request The IO context and type +@return the number of bytes read/written or negative value on error */ +ssize_t +SyncFileIO::execute(const IORequest& request) +{ + ssize_t n_bytes; + + if (request.is_read()) { +#ifdef _WIN32 + n_bytes = tpool::pread(m_fh, m_buf, m_n, m_offset); +#else + n_bytes = pread(m_fh, m_buf, m_n, m_offset); +#endif + } else { + ut_ad(request.is_write()); +#ifdef _WIN32 + n_bytes = tpool::pwrite(m_fh, m_buf, m_n, m_offset); +#else + n_bytes = pwrite(m_fh, m_buf, m_n, m_offset); +#endif + } + + return(n_bytes); +} + +#ifndef _WIN32 +/** 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 */ +static +dberr_t +os_file_punch_hole_posix( + os_file_t fh, + os_offset_t off, + os_offset_t len) +{ + +#ifdef HAVE_FALLOC_PUNCH_HOLE_AND_KEEP_SIZE + const int mode = FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE; + + int ret = fallocate(fh, mode, off, len); + + if (ret == 0) { + return(DB_SUCCESS); + } + + if (errno == ENOTSUP) { + return(DB_IO_NO_PUNCH_HOLE); + } + + ib::warn() + << "fallocate(" + <<", FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, " + << off << ", " << len << ") returned errno: " + << errno; + + return(DB_IO_ERROR); + +#elif defined(UNIV_SOLARIS) + + // Use F_FREESP + +#endif /* HAVE_FALLOC_PUNCH_HOLE_AND_KEEP_SIZE */ + + return(DB_IO_NO_PUNCH_HOLE); +} + + + +/** 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_all_errors true if we want an error message + printed of all errors +@param[in] on_error_silent true then don't print any diagnostic + to the log +@return error number, or OS error number + 100 */ +static +ulint +os_file_get_last_error_low( + bool report_all_errors, + bool on_error_silent) +{ + int err = errno; + + if (err == 0) { + return(0); + } + + if (report_all_errors + || (err != ENOSPC && err != EEXIST && !on_error_silent)) { + + ib::error() + << "Operating system error number " + << err + << " in a file operation."; + + if (err == ENOENT) { + + ib::error() + << "The error means the system" + " cannot find the path specified."; + + if (srv_is_being_started) { + + ib::error() + << "If you are installing InnoDB," + " remember that you must create" + " directories yourself, InnoDB" + " does not create them."; + } + } else if (err == EACCES) { + + ib::error() + << "The error means mysqld does not have" + " the access rights to the directory."; + + } else { + if (strerror(err) != NULL) { + + ib::error() + << "Error number " << err << " means '" + << strerror(err) << "'"; + } + + ib::info() << OPERATING_SYSTEM_ERROR_MSG; + } + } + + switch (err) { + case ENOSPC: + return(OS_FILE_DISK_FULL); + case ENOENT: + return(OS_FILE_NOT_FOUND); + case EEXIST: + return(OS_FILE_ALREADY_EXISTS); + case EXDEV: + case ENOTDIR: + case EISDIR: + return(OS_FILE_PATH_ERROR); + case EAGAIN: + if (srv_use_native_aio) { + return(OS_FILE_AIO_RESOURCES_RESERVED); + } + break; + case EINTR: + if (srv_use_native_aio) { + return(OS_FILE_AIO_INTERRUPTED); + } + break; + case EACCES: + return(OS_FILE_ACCESS_VIOLATION); + } + return(OS_FILE_ERROR_MAX + err); +} + +/** Wrapper to fsync() or fdatasync() that retries the call on some errors. +Returns the value 0 if successful; otherwise the value -1 is returned and +the global variable errno is set to indicate the error. +@param[in] file open file handle +@return 0 if success, -1 otherwise */ +static int os_file_sync_posix(os_file_t file) +{ +#if !defined(HAVE_FDATASYNC) || HAVE_DECL_FDATASYNC == 0 + auto func= fsync; + auto func_name= "fsync()"; +#else + auto func= fdatasync; + auto func_name= "fdatasync()"; +#endif + + ulint failures= 0; + + for (;;) + { + ++os_n_fsyncs; + + int ret= func(file); + + if (ret == 0) + return ret; + + switch (errno) + { + case ENOLCK: + ++failures; + ut_a(failures < 1000); + + if (!(failures % 100)) + ib::warn() << func_name << ": No locks available; retrying"; + + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + break; + + case EINTR: + ++failures; + ut_a(failures < 2000); + break; + + default: + ib::fatal() << func_name << " returned " << errno; + } + } +} + +/** Check the existence and type of the given file. +@param[in] path path name of file +@param[out] exists true if the file exists +@param[out] type Type of the file, if it exists +@return true if call succeeded */ +static +bool +os_file_status_posix( + const char* path, + bool* exists, + os_file_type_t* type) +{ + struct stat statinfo; + + int ret = stat(path, &statinfo); + + *exists = !ret; + + if (!ret) { + /* file exists, everything OK */ + + } else if (errno == ENOENT || errno == ENOTDIR || errno == ENAMETOOLONG) { + /* file does not exist */ + return(true); + + } else { + /* file exists, but stat call failed */ + os_file_handle_error_no_exit(path, "stat", false); + return(false); + } + + if (S_ISDIR(statinfo.st_mode)) { + *type = OS_FILE_TYPE_DIR; + + } else if (S_ISLNK(statinfo.st_mode)) { + *type = OS_FILE_TYPE_LINK; + + } else if (S_ISREG(statinfo.st_mode)) { + *type = OS_FILE_TYPE_FILE; + } else { + *type = OS_FILE_TYPE_UNKNOWN; + } + + return(true); +} + +/** 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) +{ + int ret; + + WAIT_ALLOW_WRITES(); + ret = os_file_sync_posix(file); + + if (ret == 0) { + return(true); + } + + /* Since Linux returns EINVAL if the 'file' is actually a raw device, + we choose to ignore that error if we are using raw disks */ + + if (srv_start_raw_disk_in_use && errno == EINVAL) { + + return(true); + } + + ib::error() << "The OS said file flush did not succeed"; + + os_file_handle_error(NULL, "flush"); + + /* It is a fatal error if a file flush does not succeed, because then + the database can get corrupt on disk */ + ut_error; + + return(false); +} + +/** 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 checks are enforced +@param[out] success true if succeed, false if error +@return handle to the file, not defined if error, error number + can be retrieved with os_file_get_last_error */ +pfs_os_file_t +os_file_create_simple_func( + const char* name, + ulint create_mode, + ulint access_type, + bool read_only, + bool* success) +{ + pfs_os_file_t file; + + *success = false; + + int create_flag; + const char* mode_str = NULL; + + if (create_mode != OS_FILE_OPEN && create_mode != OS_FILE_OPEN_RAW) { + WAIT_ALLOW_WRITES(); + } + + ut_a(!(create_mode & OS_FILE_ON_ERROR_SILENT)); + ut_a(!(create_mode & OS_FILE_ON_ERROR_NO_EXIT)); + + if (create_mode == OS_FILE_OPEN) { + mode_str = "OPEN"; + + if (access_type == OS_FILE_READ_ONLY) { + + create_flag = O_RDONLY; + + } else if (read_only) { + + create_flag = O_RDONLY; + + } else { + create_flag = O_RDWR; + } + + } else if (read_only) { + + mode_str = "OPEN"; + create_flag = O_RDONLY; + + } else if (create_mode == OS_FILE_CREATE) { + + mode_str = "CREATE"; + create_flag = O_RDWR | O_CREAT | O_EXCL; + + } else if (create_mode == OS_FILE_CREATE_PATH) { + + mode_str = "CREATE PATH"; + /* Create subdirs along the path if needed. */ + + *success = os_file_create_subdirs_if_needed(name); + + if (!*success) { + + ib::error() + << "Unable to create subdirectories '" + << name << "'"; + + return(OS_FILE_CLOSED); + } + + create_flag = O_RDWR | O_CREAT | O_EXCL; + create_mode = OS_FILE_CREATE; + } else { + + ib::error() + << "Unknown file create mode (" + << create_mode + << " for file '" << name << "'"; + + return(OS_FILE_CLOSED); + } + + bool retry; + + do { + file = open(name, create_flag | O_CLOEXEC, os_innodb_umask); + + if (file == -1) { + *success = false; + retry = os_file_handle_error( + name, + create_mode == OS_FILE_OPEN + ? "open" : "create"); + } else { + *success = true; + retry = false; + } + + } while (retry); + + /* This function is always called for data files, we should disable + OS caching (O_DIRECT) here as we do in os_file_create_func(), so + we open the same file in the same mode, see man page of open(2). */ + if (!srv_read_only_mode + && *success + && (srv_file_flush_method == SRV_O_DIRECT + || srv_file_flush_method == SRV_O_DIRECT_NO_FSYNC)) { + + os_file_set_nocache(file, name, mode_str); + } + +#ifdef USE_FILE_LOCK + if (!read_only + && *success + && (access_type == OS_FILE_READ_WRITE) + && os_file_lock(file, name)) { + + *success = false; + close(file); + file = -1; + } +#endif /* USE_FILE_LOCK */ + + return(file); +} + +/** 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. +If another error occurs, such as a permission error, this does not crash, +but reports the error and returns false. +@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) +{ + int rcode; + + WAIT_ALLOW_WRITES(); + rcode = mkdir(pathname, 0770); + + if (!(rcode == 0 || (errno == EEXIST && !fail_if_exists))) { + /* failure */ + os_file_handle_error_no_exit(pathname, "mkdir", false); + + return(false); + } + + return(true); +} + +/** 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 true, if read only checks should be enforcedm +@param[in] success true if succeeded +@return handle to the file, not defined if error, error number + can be retrieved with os_file_get_last_error */ +pfs_os_file_t +os_file_create_func( + const char* name, + ulint create_mode, + ulint purpose, + ulint type, + bool read_only, + bool* success) +{ + bool on_error_no_exit; + bool on_error_silent; + + *success = false; + + DBUG_EXECUTE_IF( + "ib_create_table_fail_disk_full", + *success = false; + errno = ENOSPC; + return(OS_FILE_CLOSED); + ); + + int create_flag; + const char* mode_str = NULL; + + on_error_no_exit = create_mode & OS_FILE_ON_ERROR_NO_EXIT + ? true : false; + on_error_silent = create_mode & OS_FILE_ON_ERROR_SILENT + ? true : false; + + create_mode &= ulint(~(OS_FILE_ON_ERROR_NO_EXIT + | OS_FILE_ON_ERROR_SILENT)); + + if (create_mode == OS_FILE_OPEN + || create_mode == OS_FILE_OPEN_RAW + || create_mode == OS_FILE_OPEN_RETRY) { + + mode_str = "OPEN"; + + create_flag = read_only ? O_RDONLY : O_RDWR; + + } else if (read_only) { + + mode_str = "OPEN"; + + create_flag = O_RDONLY; + + } else if (create_mode == OS_FILE_CREATE) { + + mode_str = "CREATE"; + create_flag = O_RDWR | O_CREAT | O_EXCL; + + } else if (create_mode == OS_FILE_OVERWRITE) { + + mode_str = "OVERWRITE"; + create_flag = O_RDWR | O_CREAT | O_TRUNC; + + } else { + ib::error() + << "Unknown file create mode (" << create_mode << ")" + << " for file '" << name << "'"; + + return(OS_FILE_CLOSED); + } + + ut_a(type == OS_LOG_FILE + || type == OS_DATA_FILE + || type == OS_DATA_FILE_NO_O_DIRECT); + + ut_a(purpose == OS_FILE_AIO || purpose == OS_FILE_NORMAL); + + /* We let O_DSYNC only affect log files */ + + if (!read_only + && type == OS_LOG_FILE + && srv_file_flush_method == SRV_O_DSYNC) { +#ifdef O_DSYNC + create_flag |= O_DSYNC; +#else + create_flag |= O_SYNC; +#endif + } + + os_file_t file; + bool retry; + + do { + file = open(name, create_flag | O_CLOEXEC, os_innodb_umask); + + if (file == -1) { + const char* operation; + + operation = (create_mode == OS_FILE_CREATE + && !read_only) ? "create" : "open"; + + *success = false; + + if (on_error_no_exit) { + retry = os_file_handle_error_no_exit( + name, operation, on_error_silent); + } else { + retry = os_file_handle_error(name, operation); + } + } else { + *success = true; + retry = false; + } + + } while (retry); + + /* We disable OS caching (O_DIRECT) only on data files */ + if (!read_only + && *success + && type != OS_LOG_FILE + && type != OS_DATA_FILE_NO_O_DIRECT + && (srv_file_flush_method == SRV_O_DIRECT + || srv_file_flush_method == SRV_O_DIRECT_NO_FSYNC)) { + + os_file_set_nocache(file, name, mode_str); + } + +#ifdef USE_FILE_LOCK + if (!read_only + && *success + && create_mode != OS_FILE_OPEN_RAW + && os_file_lock(file, name)) { + + if (create_mode == OS_FILE_OPEN_RETRY) { + + ib::info() + << "Retrying to lock the first data file"; + + for (int i = 0; i < 100; i++) { + os_thread_sleep(1000000); + + if (!os_file_lock(file, name)) { + *success = true; + return(file); + } + } + + ib::info() + << "Unable to open the first data file"; + } + + *success = false; + close(file); + file = -1; + } +#endif /* USE_FILE_LOCK */ + + return(file); +} + +/** 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 */ +pfs_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) +{ + os_file_t file; + int create_flag; + + if (create_mode != OS_FILE_OPEN && create_mode != OS_FILE_OPEN_RAW) { + WAIT_ALLOW_WRITES(); + } + + ut_a(!(create_mode & OS_FILE_ON_ERROR_SILENT)); + ut_a(!(create_mode & OS_FILE_ON_ERROR_NO_EXIT)); + + *success = false; + + if (create_mode == OS_FILE_OPEN) { + + if (access_type == OS_FILE_READ_ONLY) { + + create_flag = O_RDONLY; + + } else if (read_only) { + + create_flag = O_RDONLY; + + } else { + + ut_a(access_type == OS_FILE_READ_WRITE + || access_type == OS_FILE_READ_ALLOW_DELETE); + + create_flag = O_RDWR; + } + + } else if (read_only) { + + create_flag = O_RDONLY; + + } else if (create_mode == OS_FILE_CREATE) { + + create_flag = O_RDWR | O_CREAT | O_EXCL; + + } else { + + ib::error() + << "Unknown file create mode " + << create_mode << " for file '" << name << "'"; + + return(OS_FILE_CLOSED); + } + + file = open(name, create_flag | O_CLOEXEC, os_innodb_umask); + + *success = (file != -1); + +#ifdef USE_FILE_LOCK + if (!read_only + && *success + && access_type == OS_FILE_READ_WRITE + && os_file_lock(file, name)) { + + *success = false; + close(file); + file = -1; + + } +#endif /* USE_FILE_LOCK */ + + return(file); +} + +/** 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) +{ + if (exist != NULL) { + *exist = true; + } + + int ret; + WAIT_ALLOW_WRITES(); + + ret = unlink(name); + + if (ret != 0 && errno == ENOENT) { + if (exist != NULL) { + *exist = false; + } + } else if (ret != 0 && errno != ENOENT) { + os_file_handle_error_no_exit(name, "delete", false); + + return(false); + } + + return(true); +} + +/** 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) +{ + int ret; + WAIT_ALLOW_WRITES(); + + ret = unlink(name); + + if (ret != 0) { + os_file_handle_error_no_exit(name, "delete", FALSE); + + return(false); + } + + return(true); +} + +/** 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) +{ +#ifdef UNIV_DEBUG + os_file_type_t type; + bool exists; + + /* New path must not exist. */ + ut_ad(os_file_status(newpath, &exists, &type)); + ut_ad(!exists); + + /* Old path must exist. */ + ut_ad(os_file_status(oldpath, &exists, &type)); + ut_ad(exists); +#endif /* UNIV_DEBUG */ + + int ret; + WAIT_ALLOW_WRITES(); + + ret = rename(oldpath, newpath); + + if (ret != 0) { + os_file_handle_rename_error(oldpath, newpath); + + return(false); + } + + return(true); +} + +/** 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 Handle to close +@return true if success */ +bool os_file_close_func(os_file_t file) +{ + int ret= close(file); + + if (!ret) + return true; + + os_file_handle_error(NULL, "close"); + return false; +} + +/** Gets a file size. +@param[in] file handle to an open file +@return file size, or (os_offset_t) -1 on failure */ +os_offset_t +os_file_get_size(os_file_t file) +{ + struct stat statbuf; + return fstat(file, &statbuf) ? os_offset_t(-1) : statbuf.st_size; +} + +/** Gets a file size. +@param[in] filename Full path to the filename to check +@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) +{ + struct stat s; + os_file_size_t file_size; + + int ret = stat(filename, &s); + + if (ret == 0) { + file_size.m_total_size = s.st_size; + /* st_blocks is in 512 byte sized blocks */ + file_size.m_alloc_size = s.st_blocks * 512; + } else { + file_size.m_total_size = ~0U; + file_size.m_alloc_size = (os_offset_t) errno; + } + + return(file_size); +} + +/** This function returns information about the specified file +@param[in] path pathname of the file +@param[out] stat_info information of a file in a directory +@param[in,out] statinfo 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 */ +static +dberr_t +os_file_get_status_posix( + const char* path, + os_file_stat_t* stat_info, + struct stat* statinfo, + bool check_rw_perm, + bool read_only) +{ + int ret = stat(path, statinfo); + + if (ret && (errno == ENOENT || errno == ENOTDIR + || errno == ENAMETOOLONG)) { + /* file does not exist */ + + return(DB_NOT_FOUND); + + } else if (ret) { + /* file exists, but stat call failed */ + + os_file_handle_error_no_exit(path, "stat", false); + + return(DB_FAIL); + } + + switch (statinfo->st_mode & S_IFMT) { + case S_IFDIR: + stat_info->type = OS_FILE_TYPE_DIR; + break; + case S_IFLNK: + stat_info->type = OS_FILE_TYPE_LINK; + break; + case S_IFBLK: + /* Handle block device as regular file. */ + case S_IFCHR: + /* Handle character device as regular file. */ + case S_IFREG: + stat_info->type = OS_FILE_TYPE_FILE; + break; + default: + stat_info->type = OS_FILE_TYPE_UNKNOWN; + } + + stat_info->size = statinfo->st_size; + stat_info->block_size = statinfo->st_blksize; + stat_info->alloc_size = statinfo->st_blocks * 512; + + if (check_rw_perm + && (stat_info->type == OS_FILE_TYPE_FILE + || stat_info->type == OS_FILE_TYPE_BLOCK)) { + + stat_info->rw_perm = !access(path, read_only + ? R_OK : R_OK | W_OK); + } + + return(DB_SUCCESS); +} + +/** Truncates a file to a specified size in bytes. +Do nothing if the size to preserve is greater or equal to the current +size of the file. +@param[in] pathname file path +@param[in] file file to be truncated +@param[in] size size to preserve in bytes +@return true if success */ +static +bool +os_file_truncate_posix( + const char* pathname, + os_file_t file, + os_offset_t size) +{ + int res = ftruncate(file, size); + + if (res == -1) { + + bool retry; + + retry = os_file_handle_error_no_exit( + pathname, "truncate", false); + + if (retry) { + ib::warn() + << "Truncate failed for '" + << pathname << "'"; + } + } + + return(res == 0); +} + +/** Truncates a file at its current position. +@return true if success */ +bool +os_file_set_eof( + FILE* file) /*!< in: file to be truncated */ +{ + WAIT_ALLOW_WRITES(); + return(!ftruncate(fileno(file), ftell(file))); +} + +#else /* !_WIN32 */ + +#include <WinIoCtl.h> + + + +/** 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 0 on success or errno */ +static +dberr_t +os_file_punch_hole_win32( + os_file_t fh, + os_offset_t off, + os_offset_t len) +{ + FILE_ZERO_DATA_INFORMATION punch; + + punch.FileOffset.QuadPart = off; + punch.BeyondFinalZero.QuadPart = off + len; + + /* If lpOverlapped is NULL, lpBytesReturned cannot be NULL, + therefore we pass a dummy parameter. */ + DWORD temp; + BOOL success = os_win32_device_io_control( + fh, FSCTL_SET_ZERO_DATA, &punch, sizeof(punch), + NULL, 0, &temp); + + return(success ? DB_SUCCESS: DB_IO_NO_PUNCH_HOLE); +} + +/** Check the existence and type of the given file. +@param[in] path path name of file +@param[out] exists true if the file exists +@param[out] type Type of the file, if it exists +@return true if call succeeded */ +static +bool +os_file_status_win32( + const char* path, + bool* exists, + os_file_type_t* type) +{ + int ret; + struct _stat64 statinfo; + + ret = _stat64(path, &statinfo); + + *exists = !ret; + + if (!ret) { + /* file exists, everything OK */ + + } else if (errno == ENOENT || errno == ENOTDIR || errno == ENAMETOOLONG) { + /* file does not exist */ + return(true); + + } else { + /* file exists, but stat call failed */ + os_file_handle_error_no_exit(path, "stat", false); + return(false); + } + + if (_S_IFDIR & statinfo.st_mode) { + *type = OS_FILE_TYPE_DIR; + + } else if (_S_IFREG & statinfo.st_mode) { + *type = OS_FILE_TYPE_FILE; + + } else { + *type = OS_FILE_TYPE_UNKNOWN; + } + + return(true); +} + +/* Dynamically load NtFlushBuffersFileEx, used in os_file_flush_func */ +#include <winternl.h> +typedef NTSTATUS(WINAPI* pNtFlushBuffersFileEx)( + HANDLE FileHandle, ULONG Flags, PVOID Parameters, ULONG ParametersSize, + PIO_STATUS_BLOCK IoStatusBlock); + +static pNtFlushBuffersFileEx my_NtFlushBuffersFileEx + = (pNtFlushBuffersFileEx)GetProcAddress(GetModuleHandle("ntdll"), + "NtFlushBuffersFileEx"); + +/** 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) +{ + ++os_n_fsyncs; + static bool disable_datasync; + + if (my_NtFlushBuffersFileEx && !disable_datasync) + { + IO_STATUS_BLOCK iosb{}; + NTSTATUS status= my_NtFlushBuffersFileEx( + file, FLUSH_FLAGS_FILE_DATA_SYNC_ONLY, nullptr, 0, &iosb); + if (!status) + return true; + /* + NtFlushBuffersFileEx(FLUSH_FLAGS_FILE_DATA_SYNC_ONLY) might fail + unless on Win10+, and maybe non-NTFS. Switch to using FlushFileBuffers(). + */ + disable_datasync= true; + } + + if (FlushFileBuffers(file)) + return true; + + /* Since Windows returns ERROR_INVALID_FUNCTION if the 'file' is + actually a raw device, we choose to ignore that error if we are using + raw disks */ + if (srv_start_raw_disk_in_use && GetLastError() == ERROR_INVALID_FUNCTION) + return true; + + os_file_handle_error(nullptr, "flush"); + + /* It is a fatal error if a file flush does not succeed, because then + the database can get corrupt on disk */ + ut_error; + + return false; +} + +/** 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, +then OS error number + OS_FILE_ERROR_MAX is returned. +@param[in] report_all_errors true if we want an error message printed + of all errors +@param[in] on_error_silent true then don't print any diagnostic + to the log +@return error number, or OS error number + OS_FILE_ERROR_MAX */ +static +ulint +os_file_get_last_error_low( + bool report_all_errors, + bool on_error_silent) +{ + ulint err = (ulint) GetLastError(); + + if (err == ERROR_SUCCESS) { + return(0); + } + + if (report_all_errors + || (!on_error_silent + && err != ERROR_DISK_FULL + && err != ERROR_FILE_EXISTS)) { + + ib::error() + << "Operating system error number " << err + << " in a file operation."; + + if (err == ERROR_PATH_NOT_FOUND) { + ib::error() + << "The error means the system" + " cannot find the path specified."; + + if (srv_is_being_started) { + ib::error() + << "If you are installing InnoDB," + " remember that you must create" + " directories yourself, InnoDB" + " does not create them."; + } + + } else if (err == ERROR_ACCESS_DENIED) { + + ib::error() + << "The error means mysqld does not have" + " the access rights to" + " the directory. It may also be" + " you have created a subdirectory" + " of the same name as a data file."; + + } else if (err == ERROR_SHARING_VIOLATION + || err == ERROR_LOCK_VIOLATION) { + + ib::error() + << "The error means that another program" + " is using InnoDB's files." + " This might be a backup or antivirus" + " software or another instance" + " of MySQL." + " Please close it to get rid of this error."; + + } else if (err == ERROR_WORKING_SET_QUOTA + || err == ERROR_NO_SYSTEM_RESOURCES) { + + ib::error() + << "The error means that there are no" + " sufficient system resources or quota to" + " complete the operation."; + + } else if (err == ERROR_OPERATION_ABORTED) { + + ib::error() + << "The error means that the I/O" + " operation has been aborted" + " because of either a thread exit" + " or an application request." + " Retry attempt is made."; + } else { + + ib::info() << OPERATING_SYSTEM_ERROR_MSG; + } + } + + if (err == ERROR_FILE_NOT_FOUND) { + return(OS_FILE_NOT_FOUND); + } else if (err == ERROR_DISK_FULL) { + return(OS_FILE_DISK_FULL); + } else if (err == ERROR_FILE_EXISTS) { + return(OS_FILE_ALREADY_EXISTS); + } else if (err == ERROR_SHARING_VIOLATION + || err == ERROR_LOCK_VIOLATION) { + return(OS_FILE_SHARING_VIOLATION); + } else if (err == ERROR_WORKING_SET_QUOTA + || err == ERROR_NO_SYSTEM_RESOURCES) { + return(OS_FILE_INSUFFICIENT_RESOURCE); + } else if (err == ERROR_OPERATION_ABORTED) { + return(OS_FILE_OPERATION_ABORTED); + } else if (err == ERROR_ACCESS_DENIED) { + return(OS_FILE_ACCESS_VIOLATION); + } + + return(OS_FILE_ERROR_MAX + err); +} + + +/** 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 handle to the file, not defined if error, error number + can be retrieved with os_file_get_last_error */ +pfs_os_file_t +os_file_create_simple_func( + const char* name, + ulint create_mode, + ulint access_type, + bool read_only, + bool* success) +{ + os_file_t file; + + *success = false; + + DWORD access; + DWORD create_flag; + DWORD attributes = 0; + + ut_a(!(create_mode & OS_FILE_ON_ERROR_SILENT)); + ut_a(!(create_mode & OS_FILE_ON_ERROR_NO_EXIT)); + ut_ad(srv_operation == SRV_OPERATION_NORMAL); + + if (create_mode == OS_FILE_OPEN) { + + create_flag = OPEN_EXISTING; + + } else if (read_only) { + + create_flag = OPEN_EXISTING; + + } else if (create_mode == OS_FILE_CREATE) { + + create_flag = CREATE_NEW; + + } else if (create_mode == OS_FILE_CREATE_PATH) { + + /* Create subdirs along the path if needed. */ + *success = os_file_create_subdirs_if_needed(name); + + if (!*success) { + + ib::error() + << "Unable to create subdirectories '" + << name << "'"; + + return(OS_FILE_CLOSED); + } + + create_flag = CREATE_NEW; + create_mode = OS_FILE_CREATE; + + } else { + + ib::error() + << "Unknown file create mode (" + << create_mode << ") for file '" + << name << "'"; + + return(OS_FILE_CLOSED); + } + + if (access_type == OS_FILE_READ_ONLY) { + + access = GENERIC_READ; + + } else if (read_only) { + + ib::info() + << "Read only mode set. Unable to" + " open file '" << name << "' in RW mode, " + << "trying RO mode"; + + access = GENERIC_READ; + + } else if (access_type == OS_FILE_READ_WRITE) { + + access = GENERIC_READ | GENERIC_WRITE; + + } else { + + ib::error() + << "Unknown file access type (" << access_type << ") " + "for file '" << name << "'"; + + return(OS_FILE_CLOSED); + } + + bool retry; + + do { + /* Use default security attributes and no template file. */ + + file = CreateFile( + (LPCTSTR) name, access, + FILE_SHARE_READ | FILE_SHARE_DELETE, + NULL, create_flag, attributes, NULL); + + if (file == INVALID_HANDLE_VALUE) { + + *success = false; + + retry = os_file_handle_error( + name, create_mode == OS_FILE_OPEN ? + "open" : "create"); + + } else { + + retry = false; + + *success = true; + } + + } while (retry); + + return(file); +} + +/** 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. +If another error occurs, such as a permission error, this does not crash, +but reports the error and returns false. +@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) +{ + BOOL rcode; + + rcode = CreateDirectory((LPCTSTR) pathname, NULL); + if (!(rcode != 0 + || (GetLastError() == ERROR_ALREADY_EXISTS + && !fail_if_exists))) { + + os_file_handle_error_no_exit( + pathname, "CreateDirectory", false); + + return(false); + } + + return(true); +} + +/** Check that IO of specific size is possible for the file +opened with FILE_FLAG_NO_BUFFERING. + +The requirement is that IO is multiple of the disk sector size. + +@param[in] file file handle +@param[in] io_size expected io size +@return true - unbuffered io of requested size is possible, false otherwise. + +@note: this function only works correctly with Windows 8 or later, +(GetFileInformationByHandleEx with FileStorageInfo is only supported there). +It will return true on earlier Windows version. + */ +static bool unbuffered_io_possible(HANDLE file, size_t io_size) +{ + FILE_STORAGE_INFO info; + if (GetFileInformationByHandleEx( + file, FileStorageInfo, &info, sizeof(info))) { + ULONG sector_size = info.LogicalBytesPerSector; + if (sector_size) + return io_size % sector_size == 0; + } + return true; +} + + +/** 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] success true if succeeded +@return handle to the file, not defined if error, error number + can be retrieved with os_file_get_last_error */ +pfs_os_file_t +os_file_create_func( + const char* name, + ulint create_mode, + ulint purpose, + ulint type, + bool read_only, + bool* success) +{ + os_file_t file; + bool retry; + bool on_error_no_exit; + bool on_error_silent; + + *success = false; + + DBUG_EXECUTE_IF( + "ib_create_table_fail_disk_full", + *success = false; + SetLastError(ERROR_DISK_FULL); + return(OS_FILE_CLOSED); + ); + + DWORD create_flag; + DWORD share_mode = read_only + ? FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE + : FILE_SHARE_READ | FILE_SHARE_DELETE; + + if (create_mode != OS_FILE_OPEN && create_mode != OS_FILE_OPEN_RAW) { + WAIT_ALLOW_WRITES(); + } + + on_error_no_exit = create_mode & OS_FILE_ON_ERROR_NO_EXIT + ? true : false; + + on_error_silent = create_mode & OS_FILE_ON_ERROR_SILENT + ? true : false; + + create_mode &= ~(OS_FILE_ON_ERROR_NO_EXIT | OS_FILE_ON_ERROR_SILENT); + + if (create_mode == OS_FILE_OPEN_RAW) { + + ut_a(!read_only); + + /* On Windows Physical devices require admin privileges and + have to have the write-share mode set. See the remarks + section for the CreateFile() function documentation in MSDN. */ + + share_mode |= FILE_SHARE_WRITE; + + create_flag = OPEN_EXISTING; + + } else if (create_mode == OS_FILE_OPEN + || create_mode == OS_FILE_OPEN_RETRY) { + + create_flag = OPEN_EXISTING; + + } else if (read_only) { + + create_flag = OPEN_EXISTING; + + } else if (create_mode == OS_FILE_CREATE) { + + create_flag = CREATE_NEW; + + } else if (create_mode == OS_FILE_OVERWRITE) { + + create_flag = CREATE_ALWAYS; + + } else { + ib::error() + << "Unknown file create mode (" << create_mode << ") " + << " for file '" << name << "'"; + + return(OS_FILE_CLOSED); + } + + DWORD attributes = 0; + + if (purpose == OS_FILE_AIO) { + +#ifdef WIN_ASYNC_IO + /* If specified, use asynchronous (overlapped) io and no + buffering of writes in the OS */ + + if (srv_use_native_aio) { + attributes |= FILE_FLAG_OVERLAPPED; + } +#endif /* WIN_ASYNC_IO */ + + } else if (purpose == OS_FILE_NORMAL) { + + /* Use default setting. */ + + } else { + + ib::error() + << "Unknown purpose flag (" << purpose << ") " + << "while opening file '" << name << "'"; + + return(OS_FILE_CLOSED); + } + + if (type == OS_LOG_FILE) { + /* There is not reason to use buffered write to logs.*/ + attributes |= FILE_FLAG_NO_BUFFERING; + } + + switch (srv_file_flush_method) + { + case SRV_O_DSYNC: + if (type == OS_LOG_FILE) { + /* Map O_DSYNC to FILE_WRITE_THROUGH */ + attributes |= FILE_FLAG_WRITE_THROUGH; + } + break; + + case SRV_O_DIRECT_NO_FSYNC: + case SRV_O_DIRECT: + if (type != OS_DATA_FILE) { + break; + } + /* fall through */ + case SRV_ALL_O_DIRECT_FSYNC: + /*Traditional Windows behavior, no buffering for any files.*/ + if (type != OS_DATA_FILE_NO_O_DIRECT) { + attributes |= FILE_FLAG_NO_BUFFERING; + } + break; + + case SRV_FSYNC: + case SRV_LITTLESYNC: + break; + + case SRV_NOSYNC: + /* Let Windows cache manager handle all writes.*/ + attributes &= ~(FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING); + break; + + default: + ut_a(false); /* unknown flush mode.*/ + } + + + // TODO: Create a bug, this looks wrong. The flush log + // parameter is dynamic. + if (type == OS_LOG_FILE && srv_flush_log_at_trx_commit == 2) { + /* Do not use unbuffered i/o for the log files because + value 2 denotes that we do not flush the log at every + commit, but only once per second */ + attributes &= ~(FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING); + } + + + DWORD access = GENERIC_READ; + + if (!read_only) { + access |= GENERIC_WRITE; + } + + for (;;) { + const char *operation; + + /* Use default security attributes and no template file. */ + file = CreateFile( + name, access, share_mode, NULL, + create_flag, attributes, NULL); + + /* If FILE_FLAG_NO_BUFFERING was set, check if this can work at all, + for expected IO sizes. Reopen without the unbuffered flag, if it is won't work*/ + if ((file != INVALID_HANDLE_VALUE) + && (attributes & FILE_FLAG_NO_BUFFERING) + && (type == OS_LOG_FILE) + && !unbuffered_io_possible(file, OS_FILE_LOG_BLOCK_SIZE)) { + ut_a(CloseHandle(file)); + attributes &= ~FILE_FLAG_NO_BUFFERING; + create_flag = OPEN_ALWAYS; + continue; + } + + *success = (file != INVALID_HANDLE_VALUE); + if (*success) { + break; + } + + operation = (create_mode == OS_FILE_CREATE && !read_only) ? + "create" : "open"; + + if (on_error_no_exit) { + retry = os_file_handle_error_no_exit( + name, operation, on_error_silent); + } + else { + retry = os_file_handle_error(name, operation); + } + + if (!retry) { + break; + } + } + + if (*success && (attributes & FILE_FLAG_OVERLAPPED) && srv_thread_pool) { + srv_thread_pool->bind(file); + } + return(file); +} + +/** 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[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 */ +pfs_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) +{ + os_file_t file; + + *success = false; + + DWORD access; + DWORD create_flag; + DWORD attributes = 0; + DWORD share_mode = read_only + ? FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE + : FILE_SHARE_READ | FILE_SHARE_DELETE; + + ut_a(name); + + ut_a(!(create_mode & OS_FILE_ON_ERROR_SILENT)); + ut_a(!(create_mode & OS_FILE_ON_ERROR_NO_EXIT)); + + if (create_mode == OS_FILE_OPEN) { + + create_flag = OPEN_EXISTING; + + } else if (read_only) { + + create_flag = OPEN_EXISTING; + + } else if (create_mode == OS_FILE_CREATE) { + + create_flag = CREATE_NEW; + + } else { + + ib::error() + << "Unknown file create mode (" << create_mode << ") " + << " for file '" << name << "'"; + + return(OS_FILE_CLOSED); + } + + if (access_type == OS_FILE_READ_ONLY) { + + access = GENERIC_READ; + + } else if (read_only) { + + access = GENERIC_READ; + + } else if (access_type == OS_FILE_READ_WRITE) { + + access = GENERIC_READ | GENERIC_WRITE; + + } else if (access_type == OS_FILE_READ_ALLOW_DELETE) { + + ut_a(!read_only); + + access = GENERIC_READ; + + /*!< A backup program has to give mysqld the maximum + freedom to do what it likes with the file */ + + share_mode |= FILE_SHARE_DELETE | FILE_SHARE_WRITE + | FILE_SHARE_READ; + + } else { + + ib::error() + << "Unknown file access type (" << access_type << ") " + << "for file '" << name << "'"; + + return(OS_FILE_CLOSED); + } + + file = CreateFile((LPCTSTR) name, + access, + share_mode, + NULL, // Security attributes + create_flag, + attributes, + NULL); // No template file + + *success = (file != INVALID_HANDLE_VALUE); + + return(file); +} + +/** 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) +{ + ulint count = 0; + + if (exist != NULL) { + *exist = true; + } + + for (;;) { + /* In Windows, deleting an .ibd file may fail if + the file is being accessed by an external program, + such as a backup tool. */ + + bool ret = DeleteFile((LPCTSTR) name); + + if (ret) { + return(true); + } + + DWORD lasterr = GetLastError(); + + if (lasterr == ERROR_FILE_NOT_FOUND + || lasterr == ERROR_PATH_NOT_FOUND) { + + /* the file does not exist, this not an error */ + if (exist != NULL) { + *exist = false; + } + + return(true); + } + + ++count; + + if (count > 100 && 0 == (count % 10)) { + + /* Print error information */ + os_file_get_last_error(true); + + ib::warn() << "Delete of file '" << name << "' failed."; + } + + /* Sleep for a second */ + os_thread_sleep(1000000); + + if (count > 2000) { + + return(false); + } + } +} + +/** Deletes a file. The file has to be closed before calling this. +@param[in] name File path as NUL terminated string +@return true if success */ +bool +os_file_delete_func( + const char* name) +{ + ulint count = 0; + + for (;;) { + /* In Windows, deleting an .ibd file may fail if + the file is being accessed by an external program, + such as a backup tool. */ + + BOOL ret = DeleteFile((LPCTSTR) name); + + if (ret) { + return(true); + } + + if (GetLastError() == ERROR_FILE_NOT_FOUND) { + /* If the file does not exist, we classify this as + a 'mild' error and return */ + + return(false); + } + + ++count; + + if (count > 100 && 0 == (count % 10)) { + + /* print error information */ + os_file_get_last_error(true); + + ib::warn() + << "Cannot delete file '" << name << "'. Is " + << "another program accessing it?"; + } + + /* sleep for a second */ + os_thread_sleep(1000000); + + if (count > 2000) { + + return(false); + } + } + + ut_error; + return(false); +} + +/** 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) +{ +#ifdef UNIV_DEBUG + os_file_type_t type; + bool exists; + + /* New path must not exist. */ + ut_ad(os_file_status(newpath, &exists, &type)); + ut_ad(!exists); + + /* Old path must exist. */ + ut_ad(os_file_status(oldpath, &exists, &type)); + ut_ad(exists); +#endif /* UNIV_DEBUG */ + + if (MoveFile((LPCTSTR) oldpath, (LPCTSTR) newpath)) { + return(true); + } + + os_file_handle_rename_error(oldpath, newpath); + return(false); +} + +/** 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,own] file Handle to a file +@return true if success */ +bool os_file_close_func(os_file_t file) +{ + ut_ad(file); + if (!CloseHandle(file)) + { + os_file_handle_error(NULL, "close"); + return false; + } + + if(srv_thread_pool) + srv_thread_pool->unbind(file); + return true; +} + +/** 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) +{ + DWORD high; + DWORD low = GetFileSize(file, &high); + + if (low == 0xFFFFFFFF && GetLastError() != NO_ERROR) { + return((os_offset_t) -1); + } + + return(os_offset_t(low | (os_offset_t(high) << 32))); +} + +/** Gets a file size. +@param[in] filename Full path to the filename to check +@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) +{ + struct __stat64 s; + os_file_size_t file_size; + + int ret = _stat64(filename, &s); + + if (ret == 0) { + + file_size.m_total_size = s.st_size; + + DWORD low_size; + DWORD high_size; + + low_size = GetCompressedFileSize(filename, &high_size); + + if (low_size != INVALID_FILE_SIZE) { + + file_size.m_alloc_size = high_size; + file_size.m_alloc_size <<= 32; + file_size.m_alloc_size |= low_size; + + } else { + ib::error() + << "GetCompressedFileSize(" + << filename << ", ..) failed."; + + file_size.m_alloc_size = (os_offset_t) -1; + } + } else { + file_size.m_total_size = ~0; + file_size.m_alloc_size = (os_offset_t) ret; + } + + return(file_size); +} + +/** This function returns information about the specified file +@param[in] path pathname of the file +@param[out] stat_info information of a file in a directory +@param[in,out] statinfo 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 true if the file is opened in read-only mode +@return DB_SUCCESS if all OK */ +static +dberr_t +os_file_get_status_win32( + const char* path, + os_file_stat_t* stat_info, + struct _stat64* statinfo, + bool check_rw_perm, + bool read_only) +{ + int ret = _stat64(path, statinfo); + + if (ret && (errno == ENOENT || errno == ENOTDIR + || errno == ENAMETOOLONG)) { + /* file does not exist */ + + return(DB_NOT_FOUND); + + } else if (ret) { + /* file exists, but stat call failed */ + + os_file_handle_error_no_exit(path, "STAT", false); + + return(DB_FAIL); + + } else if (_S_IFDIR & statinfo->st_mode) { + + stat_info->type = OS_FILE_TYPE_DIR; + + } else if (_S_IFREG & statinfo->st_mode) { + + DWORD access = GENERIC_READ; + + if (!read_only) { + access |= GENERIC_WRITE; + } + + stat_info->type = OS_FILE_TYPE_FILE; + + /* Check if we can open it in read-only mode. */ + + if (check_rw_perm) { + HANDLE fh; + + fh = CreateFile( + (LPCTSTR) path, // File to open + access, + FILE_SHARE_READ | FILE_SHARE_WRITE + | FILE_SHARE_DELETE, // Full sharing + NULL, // Default security + OPEN_EXISTING, // Existing file only + FILE_ATTRIBUTE_NORMAL, // Normal file + NULL); // No attr. template + + if (fh == INVALID_HANDLE_VALUE) { + stat_info->rw_perm = false; + } else { + stat_info->rw_perm = true; + CloseHandle(fh); + } + } + stat_info->block_size = 0; + + /* What follows, is calculation of FS block size, which is not important + (it is just shown in I_S innodb tables). The error to calculate it will be ignored.*/ + char volname[MAX_PATH]; + BOOL result = GetVolumePathName(path, volname, MAX_PATH); + static bool warned_once = false; + if (!result) { + if (!warned_once) { + ib::warn() + << "os_file_get_status_win32: " + << "Failed to get the volume path name for: " + << path + << "- OS error number " << GetLastError(); + warned_once = true; + } + return(DB_SUCCESS); + } + + DWORD sectorsPerCluster; + DWORD bytesPerSector; + DWORD numberOfFreeClusters; + DWORD totalNumberOfClusters; + + result = GetDiskFreeSpace( + (LPCSTR) volname, + §orsPerCluster, + &bytesPerSector, + &numberOfFreeClusters, + &totalNumberOfClusters); + + if (!result) { + if (!warned_once) { + ib::warn() + << "GetDiskFreeSpace(" << volname << ",...) " + << "failed " + << "- OS error number " << GetLastError(); + warned_once = true; + } + return(DB_SUCCESS); + } + stat_info->block_size = bytesPerSector * sectorsPerCluster; + } else { + stat_info->type = OS_FILE_TYPE_UNKNOWN; + } + + return(DB_SUCCESS); +} + +/** +Sets a sparse flag on Windows file. +@param[in] file file handle +@return true on success, false on error +*/ +#include <versionhelpers.h> +bool os_file_set_sparse_win32(os_file_t file, bool is_sparse) +{ + if (!is_sparse && !IsWindows8OrGreater()) { + /* Cannot unset sparse flag on older Windows. + Until Windows8 it is documented to produce unpredictable results, + if there are unallocated ranges in file.*/ + return false; + } + DWORD temp; + FILE_SET_SPARSE_BUFFER sparse_buffer; + sparse_buffer.SetSparse = is_sparse; + return os_win32_device_io_control(file, + FSCTL_SET_SPARSE, &sparse_buffer, sizeof(sparse_buffer), 0, 0,&temp); +} + + +/** +Change file size on Windows. + +If file is extended, the bytes between old and new EOF +are zeros. + +If file is sparse, "virtual" block is added at the end of +allocated area. + +If file is normal, file system allocates storage. + +@param[in] pathname file path +@param[in] file file handle +@param[in] size size to preserve in bytes +@return true if success */ +bool +os_file_change_size_win32( + const char* pathname, + os_file_t file, + os_offset_t size) +{ + LARGE_INTEGER length; + + length.QuadPart = size; + + BOOL success = SetFilePointerEx(file, length, NULL, FILE_BEGIN); + + if (!success) { + os_file_handle_error_no_exit( + pathname, "SetFilePointerEx", false); + } else { + success = SetEndOfFile(file); + if (!success) { + os_file_handle_error_no_exit( + pathname, "SetEndOfFile", false); + } + } + return(success); +} + +/** Truncates a file at its current position. +@param[in] file Handle to be truncated +@return true if success */ +bool +os_file_set_eof( + FILE* file) +{ + HANDLE h = (HANDLE) _get_osfhandle(fileno(file)); + + return(SetEndOfFile(h)); +} + +#endif /* !_WIN32*/ + +/** Does a syncronous read or write depending upon the type specified +In case of partial reads/writes the function tries +NUM_RETRIES_ON_PARTIAL_IO times to read/write the complete data. +@param[in] type, IO flags +@param[in] file handle to an open file +@param[out] buf buffer where to read +@param[in] offset file offset from the start where to read +@param[in] n number of bytes to read, starting from offset +@param[out] err DB_SUCCESS or error code +@return number of bytes read/written, -1 if error */ +static MY_ATTRIBUTE((warn_unused_result)) +ssize_t +os_file_io( + const IORequest&in_type, + os_file_t file, + void* buf, + ulint n, + os_offset_t offset, + dberr_t* err) +{ + ssize_t original_n = ssize_t(n); + IORequest type = in_type; + ssize_t bytes_returned = 0; + + SyncFileIO sync_file_io(file, buf, n, offset); + + for (ulint i = 0; i < NUM_RETRIES_ON_PARTIAL_IO; ++i) { + + ssize_t n_bytes = sync_file_io.execute(type); + + /* Check for a hard error. Not much we can do now. */ + if (n_bytes < 0) { + + break; + + } else if (n_bytes + bytes_returned == ssize_t(n)) { + + bytes_returned += n_bytes; + + *err = type.maybe_punch_hole(offset, n); + + return(original_n); + } + + /* Handle partial read/write. */ + + ut_ad(ulint(n_bytes + bytes_returned) < n); + + bytes_returned += n_bytes; + + if (type.type != IORequest::READ_MAYBE_PARTIAL) { + const char* op = type.is_read() + ? "read" : "written"; + + ib::warn() + << n + << " bytes should have been " << op << ". Only " + << bytes_returned + << " bytes " << op << ". Retrying" + << " for the remaining bytes."; + } + + /* Advance the offset and buffer by n_bytes */ + sync_file_io.advance(n_bytes); + } + + *err = DB_IO_ERROR; + + if (type.type != IORequest::READ_MAYBE_PARTIAL) { + ib::warn() + << "Retry attempts for " + << (type.is_read() ? "reading" : "writing") + << " partial data failed."; + } + + return(bytes_returned); +} + +/** Does a synchronous write operation in Posix. +@param[in] type IO context +@param[in] file handle to an open file +@param[out] buf buffer from which to write +@param[in] n number of bytes to read, starting from offset +@param[in] offset file offset from the start where to read +@param[out] err DB_SUCCESS or error code +@return number of bytes written, -1 if error */ +static MY_ATTRIBUTE((warn_unused_result)) +ssize_t +os_file_pwrite( + const IORequest& type, + os_file_t file, + const byte* buf, + ulint n, + os_offset_t offset, + dberr_t* err) +{ + ut_ad(type.is_write()); + + ++os_n_file_writes; + + const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_WRITES); + MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_WRITES, monitor); + ssize_t n_bytes = os_file_io(type, file, const_cast<byte*>(buf), + n, offset, err); + MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_WRITES, monitor); + + return(n_bytes); +} + +/** NOTE! Use the corresponding macro os_file_write(), not directly +Requests a synchronous write operation. +@param[in] type IO flags +@param[in] file handle to an open file +@param[out] buf buffer from which to write +@param[in] offset file offset from the start where to read +@param[in] n number of bytes to read, starting from offset +@return error code +@retval DB_SUCCESS if the operation succeeded */ +dberr_t +os_file_write_func( + const IORequest& type, + const char* name, + os_file_t file, + const void* buf, + os_offset_t offset, + ulint n) +{ + dberr_t err; + + ut_ad(n > 0); + + WAIT_ALLOW_WRITES(); + + ssize_t n_bytes = os_file_pwrite(type, file, (byte*)buf, n, offset, &err); + + if ((ulint) n_bytes != n && !os_has_said_disk_full) { + + ib::error() + << "Write to file " << name << " failed at offset " + << offset << ", " << n + << " bytes should have been written," + " only " << n_bytes << " were written." + " Operating system error number " << IF_WIN(GetLastError(),errno) << "." + " Check that your OS and file system" + " support files of this size." + " Check also that the disk is not full" + " or a disk quota exceeded."; +#ifndef _WIN32 + if (strerror(errno) != NULL) { + + ib::error() + << "Error number " << errno + << " means '" << strerror(errno) << "'"; + } + + ib::info() << OPERATING_SYSTEM_ERROR_MSG; +#endif + os_has_said_disk_full = true; + } + + return(err); +} + +/** Does a synchronous read operation in Posix. +@param[in] type IO flags +@param[in] file handle to an open file +@param[out] buf buffer where to read +@param[in] offset file offset from the start where to read +@param[in] n number of bytes to read, starting from offset +@param[out] err DB_SUCCESS or error code +@return number of bytes read, -1 if error */ +static MY_ATTRIBUTE((warn_unused_result)) +ssize_t +os_file_pread( + const IORequest& type, + os_file_t file, + void* buf, + ulint n, + os_offset_t offset, + dberr_t* err) +{ + ut_ad(type.is_read()); + + ++os_n_file_reads; + + const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_READS); + MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_READS, monitor); + ssize_t n_bytes = os_file_io(type, file, buf, n, offset, err); + MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor); + + return(n_bytes); +} + +/** Requests a synchronous positioned read operation. +@return DB_SUCCESS if request was successful, false if fail +@param[in] type IO flags +@param[in] file handle to an open file +@param[out] buf buffer where to read +@param[in] offset file offset from the start where to read +@param[in] n number of bytes to read, starting from offset +@param[out] o number of bytes actually read +@param[in] exit_on_err if true then exit on error +@return DB_SUCCESS or error code */ +static MY_ATTRIBUTE((warn_unused_result)) +dberr_t +os_file_read_page( + const IORequest& type, + os_file_t file, + void* buf, + os_offset_t offset, + ulint n, + ulint* o, + bool exit_on_err) +{ + dberr_t err; + + os_bytes_read_since_printout += n; + + ut_ad(n > 0); + + ssize_t n_bytes = os_file_pread(type, file, buf, n, offset, &err); + + if (o) { + *o = n_bytes; + } + + if (ulint(n_bytes) == n || (err != DB_SUCCESS && !exit_on_err)) { + return err; + } + int os_err = IF_WIN((int)GetLastError(), errno); + + if (!os_file_handle_error_cond_exit( + NULL, "read", exit_on_err, false)) { + ib::fatal() + << "Tried to read " << n << " bytes at offset " + << offset << ", but was only able to read " << n_bytes + << ".Cannot read from file. OS error number " + << os_err << "."; + } else { + ib::error() << "Tried to read " << n << " bytes at offset " + << offset << ", but was only able to read " << n_bytes; + } + if (err == DB_SUCCESS) { + err = DB_IO_ERROR; + } + + return err; +} + +/** 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_all_errors true if we want an error printed + for all errors +@return error number, or OS error number + 100 */ +ulint +os_file_get_last_error( + bool report_all_errors) +{ + return(os_file_get_last_error_low(report_all_errors, false)); +} + +/** Handle errors for file operations. +@param[in] name name of a file or NULL +@param[in] operation operation +@param[in] should_abort whether to abort on an unknown error +@param[in] on_error_silent whether to suppress reports of non-fatal errors +@return true if we should retry the operation */ +static MY_ATTRIBUTE((warn_unused_result)) +bool +os_file_handle_error_cond_exit( + const char* name, + const char* operation, + bool should_abort, + bool on_error_silent) +{ + ulint err; + + err = os_file_get_last_error_low(false, on_error_silent); + + switch (err) { + case OS_FILE_DISK_FULL: + /* We only print a warning about disk full once */ + + if (os_has_said_disk_full) { + + return(false); + } + + /* Disk full error is reported irrespective of the + on_error_silent setting. */ + + if (name) { + + ib::error() + << "Encountered a problem with file '" + << name << "'"; + } + + ib::error() + << "Disk is full. Try to clean the disk to free space."; + + os_has_said_disk_full = true; + + return(false); + + case OS_FILE_AIO_RESOURCES_RESERVED: + case OS_FILE_AIO_INTERRUPTED: + + return(true); + + case OS_FILE_PATH_ERROR: + case OS_FILE_ALREADY_EXISTS: + case OS_FILE_ACCESS_VIOLATION: + + return(false); + + case OS_FILE_SHARING_VIOLATION: + + os_thread_sleep(10000000); /* 10 sec */ + return(true); + + case OS_FILE_OPERATION_ABORTED: + case OS_FILE_INSUFFICIENT_RESOURCE: + + os_thread_sleep(100000); /* 100 ms */ + return(true); + + default: + + /* If it is an operation that can crash on error then it + is better to ignore on_error_silent and print an error message + to the log. */ + + if (should_abort || !on_error_silent) { + ib::error() << "File " + << (name != NULL ? name : "(unknown)") + << ": '" << operation << "'" + " returned OS error " << err << "." + << (should_abort + ? " Cannot continue operation" : ""); + } + + if (should_abort) { + abort(); + } + } + + return(false); +} + +#ifndef _WIN32 +/** 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( + int fd MY_ATTRIBUTE((unused)), + const char* file_name MY_ATTRIBUTE((unused)), + const char* operation_name MY_ATTRIBUTE((unused))) +{ + /* some versions of Solaris may not have DIRECTIO_ON */ +#if defined(UNIV_SOLARIS) && defined(DIRECTIO_ON) + if (directio(fd, DIRECTIO_ON) == -1) { + int errno_save = errno; + + ib::error() + << "Failed to set DIRECTIO_ON on file " + << file_name << "; " << operation_name << ": " + << strerror(errno_save) << "," + " continuing anyway."; + } +#elif defined(O_DIRECT) + if (fcntl(fd, F_SETFL, O_DIRECT) == -1) { + int errno_save = errno; + static bool warning_message_printed = false; + if (errno_save == EINVAL) { + if (!warning_message_printed) { + warning_message_printed = true; +# ifdef UNIV_LINUX + ib::warn() + << "Failed to set O_DIRECT on file" + << file_name << "; " << operation_name + << ": " << strerror(errno_save) << ", " + "continuing anyway. O_DIRECT is " + "known to result in 'Invalid argument' " + "on Linux on tmpfs, " + "see MySQL Bug#26662."; +# else /* UNIV_LINUX */ + goto short_warning; +# endif /* UNIV_LINUX */ + } + } else { +# ifndef UNIV_LINUX +short_warning: +# endif + ib::warn() + << "Failed to set O_DIRECT on file " + << file_name << "; " << operation_name + << " : " << strerror(errno_save) + << ", continuing anyway."; + } + } +#endif /* defined(UNIV_SOLARIS) && defined(DIRECTIO_ON) */ +} + +#endif /* _WIN32 */ + +/** Check if the file system supports sparse files. +@param fh file handle +@return true if the file system supports sparse files */ +IF_WIN(static,) bool os_is_sparse_file_supported(os_file_t fh) +{ +#ifdef _WIN32 + FILE_ATTRIBUTE_TAG_INFO info; + if (GetFileInformationByHandleEx(fh, FileAttributeTagInfo, + &info, (DWORD)sizeof(info))) { + if (info.FileAttributes != INVALID_FILE_ATTRIBUTES) { + return (info.FileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) != 0; + } + } + return false; +#else + /* We don't know the FS block size, use the sector size. The FS + will do the magic. */ + return DB_SUCCESS == os_file_punch_hole_posix(fh, 0, srv_page_size); +#endif /* _WIN32 */ +} + +/** Extend a file. + +On Windows, extending a file allocates blocks for the file, +unless the file is sparse. + +On Unix, we will extend the file with ftruncate(), if +file needs to be sparse. Otherwise posix_fallocate() is used +when available, and if not, binary zeroes are added to the end +of file. + +@param[in] name file name +@param[in] file file handle +@param[in] size desired file size +@param[in] sparse whether to create a sparse file (no preallocating) +@return whether the operation succeeded */ +bool +os_file_set_size( + const char* name, + os_file_t file, + os_offset_t size, + bool is_sparse) +{ +#ifdef _WIN32 + /* On Windows, changing file size works well and as expected for both + sparse and normal files. + + However, 10.2 up until 10.2.9 made every file sparse in innodb, + causing NTFS fragmentation issues(MDEV-13941). We try to undo + the damage, and unsparse the file.*/ + + if (!is_sparse && os_is_sparse_file_supported(file)) { + if (!os_file_set_sparse_win32(file, false)) + /* Unsparsing file failed. Fallback to writing binary + zeros, to avoid even higher fragmentation.*/ + goto fallback; + } + + return os_file_change_size_win32(name, file, size); + +fallback: +#else + struct stat statbuf; + + if (is_sparse) { + bool success = !ftruncate(file, size); + if (!success) { + ib::error() << "ftruncate of file " << name << " to " + << size << " bytes failed with error " + << errno; + } + return(success); + } + +# ifdef HAVE_POSIX_FALLOCATE + int err; + do { + if (fstat(file, &statbuf)) { + err = errno; + } else { + os_offset_t current_size = statbuf.st_size; + if (current_size >= size) { + return true; + } + current_size &= ~os_offset_t(statbuf.st_blksize - 1); + err = posix_fallocate(file, current_size, + size - current_size); + } + } while (err == EINTR + && srv_shutdown_state <= SRV_SHUTDOWN_INITIATED); + + switch (err) { + case 0: + return true; + default: + ib::error() << "preallocating " + << size << " bytes for file " << name + << " failed with error " << err; + /* fall through */ + case EINTR: + errno = err; + return false; + case EINVAL: + case EOPNOTSUPP: + /* fall back to the code below */ + break; + } +# endif /* HAVE_POSIX_ALLOCATE */ +#endif /* _WIN32*/ + +#ifdef _WIN32 + os_offset_t current_size = os_file_get_size(file); + FILE_STORAGE_INFO info; + if (GetFileInformationByHandleEx(file, FileStorageInfo, &info, + sizeof info)) { + if (info.LogicalBytesPerSector) { + current_size &= ~os_offset_t(info.LogicalBytesPerSector + - 1); + } + } +#else + if (fstat(file, &statbuf)) { + return false; + } + os_offset_t current_size = statbuf.st_size + & ~os_offset_t(statbuf.st_blksize - 1); +#endif + if (current_size >= size) { + return true; + } + + /* Write up to 1 megabyte at a time. */ + ulint buf_size = ut_min(ulint(64), + ulint(size >> srv_page_size_shift)) + << srv_page_size_shift; + + /* Align the buffer for possible raw i/o */ + byte* buf = static_cast<byte*>(aligned_malloc(buf_size, + srv_page_size)); + /* Write buffer full of zeros */ + memset(buf, 0, buf_size); + + while (current_size < size + && srv_shutdown_state <= SRV_SHUTDOWN_INITIATED) { + ulint n_bytes; + + if (size - current_size < (os_offset_t) buf_size) { + n_bytes = (ulint) (size - current_size); + } else { + n_bytes = buf_size; + } + + if (os_file_write(IORequestWrite, name, + file, buf, current_size, n_bytes) != + DB_SUCCESS) { + break; + } + + current_size += n_bytes; + } + + aligned_free(buf); + + return(current_size >= size && os_file_flush(file)); +} + +/** Truncate a file to a specified size in bytes. +@param[in] pathname file path +@param[in] file file to be truncated +@param[in] size size preserved in bytes +@param[in] allow_shrink whether to allow the file to become smaller +@return true if success */ +bool +os_file_truncate( + const char* pathname, + os_file_t file, + os_offset_t size, + bool allow_shrink) +{ + if (!allow_shrink) { + /* Do nothing if the size preserved is larger than or + equal to the current size of file */ + os_offset_t size_bytes = os_file_get_size(file); + + if (size >= size_bytes) { + return(true); + } + } + +#ifdef _WIN32 + return(os_file_change_size_win32(pathname, file, size)); +#else /* _WIN32 */ + return(os_file_truncate_posix(pathname, file, size)); +#endif /* _WIN32 */ +} + +/** NOTE! Use the corresponding macro os_file_read(), not directly this +function! +Requests a synchronous positioned read operation. +@return DB_SUCCESS if request was successful, DB_IO_ERROR on failure +@param[in] type IO flags +@param[in] file handle to an open file +@param[out] buf buffer where to read +@param[in] offset file offset from the start where to read +@param[in] n number of bytes to read, starting from offset +@return error code +@retval DB_SUCCESS if the operation succeeded */ +dberr_t +os_file_read_func( + const IORequest& type, + os_file_t file, + void* buf, + os_offset_t offset, + ulint n) +{ + return(os_file_read_page(type, file, buf, offset, n, NULL, true)); +} + +/** NOTE! Use the corresponding macro os_file_read_no_error_handling(), +not directly this function! +Requests a synchronous positioned read operation. +@return DB_SUCCESS if request was successful, DB_IO_ERROR on failure +@param[in] type IO flags +@param[in] file handle to an open file +@param[out] buf buffer where to read +@param[in] offset file offset from the start where to read +@param[in] n number of bytes to read, starting from offset +@param[out] o number of bytes actually read +@return DB_SUCCESS or error code */ +dberr_t +os_file_read_no_error_handling_func( + const IORequest& type, + os_file_t file, + void* buf, + os_offset_t offset, + ulint n, + ulint* o) +{ + return(os_file_read_page(type, file, buf, offset, n, o, false)); +} + +/** Check the existence and type of the given file. +@param[in] path path name of file +@param[out] exists true if the 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) +{ +#ifdef _WIN32 + return(os_file_status_win32(path, exists, type)); +#else + return(os_file_status_posix(path, exists, type)); +#endif /* _WIN32 */ +} + +/** 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) +{ +#ifdef _WIN32 + return os_file_punch_hole_win32(fh, off, len); +#else + return os_file_punch_hole_posix(fh, off, len); +#endif /* _WIN32 */ +} + +/** Free storage space associated with a section of the file. +@param off byte offset from the start (SEEK_SET) +@param len size of the hole in bytes +@return DB_SUCCESS or error code */ +dberr_t IORequest::punch_hole(os_offset_t off, ulint len) const +{ + ulint trim_len = bpage ? bpage->physical_size() - len : 0; + + if (trim_len == 0) { + return(DB_SUCCESS); + } + + off += len; + + /* Check does file system support punching holes for this + tablespace. */ + if (!node->space->punch_hole) { + return DB_IO_NO_PUNCH_HOLE; + } + + dberr_t err = os_file_punch_hole(node->handle, off, trim_len); + + if (err == DB_SUCCESS) { + srv_stats.page_compressed_trim_op.inc(); + } else { + /* If punch hole is not supported, + set space so that it is not used. */ + if (err == DB_IO_NO_PUNCH_HOLE) { + node->space->punch_hole = false; + err = DB_SUCCESS; + } + } + + return (err); +} + +/** This function returns information about the specified file +@param[in] path pathname of the file +@param[out] 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 true if file is opened in read-only mode +@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) +{ + dberr_t ret; + +#ifdef _WIN32 + struct _stat64 info; + + ret = os_file_get_status_win32( + path, stat_info, &info, check_rw_perm, read_only); + +#else + struct stat info; + + ret = os_file_get_status_posix( + path, stat_info, &info, check_rw_perm, read_only); + +#endif /* _WIN32 */ + + if (ret == DB_SUCCESS) { + stat_info->ctime = info.st_ctime; + stat_info->atime = info.st_atime; + stat_info->mtime = info.st_mtime; + stat_info->size = info.st_size; + } + + return(ret); +} + + +extern void fil_aio_callback(const IORequest &request); + +static void io_callback(tpool::aiocb* cb) +{ + ut_a(cb->m_err == DB_SUCCESS); + const IORequest request(*static_cast<const IORequest*> + (static_cast<const void*>(cb->m_userdata))); + /* Return cb back to cache*/ + if (cb->m_opcode == tpool::aio_opcode::AIO_PREAD) + { + ut_ad(read_slots->contains(cb)); + read_slots->release(cb); + } + else + { + ut_ad(write_slots->contains(cb)); + write_slots->release(cb); + } + + fil_aio_callback(request); +} + +#ifdef LINUX_NATIVE_AIO +/** Checks if the system supports native linux aio. On some kernel +versions where native aio is supported it won't work on tmpfs. In such +cases we can't use native aio. + +@return: true if supported, false otherwise. */ +static bool is_linux_native_aio_supported() +{ + File fd; + io_context_t io_ctx; + std::string log_file_path = get_log_file_path(); + + memset(&io_ctx, 0, sizeof(io_ctx)); + if (io_setup(1, &io_ctx)) { + + /* The platform does not support native aio. */ + + return(false); + + } + else if (!srv_read_only_mode) { + + /* Now check if tmpdir supports native aio ops. */ + fd = mysql_tmpfile("ib"); + + if (fd < 0) { + ib::warn() + << "Unable to create temp file to check" + " native AIO support."; + + int ret = io_destroy(io_ctx); + ut_a(ret != -EINVAL); + ut_ad(ret != -EFAULT); + + return(false); + } + } + else { + fd = my_open(log_file_path.c_str(), O_RDONLY | O_CLOEXEC, + MYF(0)); + + if (fd == -1) { + + ib::warn() << "Unable to open \"" << log_file_path + << "\" to check native" + << " AIO read support."; + + int ret = io_destroy(io_ctx); + ut_a(ret != EINVAL); + ut_ad(ret != EFAULT); + + return(false); + } + } + + struct io_event io_event; + + memset(&io_event, 0x0, sizeof(io_event)); + + byte* ptr = static_cast<byte*>(aligned_malloc(srv_page_size, + srv_page_size)); + + struct iocb iocb; + + /* Suppress valgrind warning. */ + memset(ptr, 0, srv_page_size); + memset(&iocb, 0x0, sizeof(iocb)); + + struct iocb* p_iocb = &iocb; + + if (!srv_read_only_mode) { + + io_prep_pwrite(p_iocb, fd, ptr, srv_page_size, 0); + + } + else { + ut_a(srv_page_size >= 512); + io_prep_pread(p_iocb, fd, ptr, 512, 0); + } + + int err = io_submit(io_ctx, 1, &p_iocb); + + if (err >= 1) { + /* Now collect the submitted IO request. */ + err = io_getevents(io_ctx, 1, 1, &io_event, NULL); + } + + aligned_free(ptr); + my_close(fd, MYF(MY_WME)); + + switch (err) { + case 1: + { + int ret = io_destroy(io_ctx); + ut_a(ret != -EINVAL); + ut_ad(ret != -EFAULT); + + return(true); + } + + case -EINVAL: + case -ENOSYS: + ib::warn() + << "Linux Native AIO not supported. You can either" + " move " + << (srv_read_only_mode ? log_file_path : "tmpdir") + << " to a file system that supports native" + " AIO or you can set innodb_use_native_aio to" + " FALSE to avoid this message."; + + /* fall through. */ + default: + ib::warn() + << "Linux Native AIO check on " + << (srv_read_only_mode ? log_file_path : "tmpdir") + << "returned error[" << -err << "]"; + } + + int ret = io_destroy(io_ctx); + ut_a(ret != -EINVAL); + ut_ad(ret != -EFAULT); + + return(false); +} +#endif + +int os_aio_init() +{ + int max_write_events= int(srv_n_write_io_threads * + OS_AIO_N_PENDING_IOS_PER_THREAD); + int max_read_events= int(srv_n_read_io_threads * + OS_AIO_N_PENDING_IOS_PER_THREAD); + int max_events= max_read_events + max_write_events; + int ret; +#if LINUX_NATIVE_AIO + if (srv_use_native_aio && !is_linux_native_aio_supported()) + goto disable; +#endif + + ret= srv_thread_pool->configure_aio(srv_use_native_aio, max_events); + +#ifdef LINUX_NATIVE_AIO + if (ret) + { + ut_ad(srv_use_native_aio); +disable: + ib::warn() << "Linux Native AIO disabled."; + srv_use_native_aio= false; + ret= srv_thread_pool->configure_aio(false, max_events); + } +#endif + + if (!ret) + { + read_slots= new io_slots(max_read_events, srv_n_read_io_threads); + write_slots= new io_slots(max_write_events, srv_n_write_io_threads); + } + return ret; +} + + +void os_aio_free() +{ + srv_thread_pool->disable_aio(); + delete read_slots; + delete write_slots; + read_slots= nullptr; + write_slots= nullptr; +} + +/** Wait until there are no pending asynchronous writes. */ +static void os_aio_wait_until_no_pending_writes_low() +{ + bool notify_wait = write_slots->pending_io_count() > 0; + + if (notify_wait) + tpool::tpool_wait_begin(); + + write_slots->wait(); + + if (notify_wait) + tpool::tpool_wait_end(); +} + +/** Wait until there are no pending asynchronous writes. +Only used on FLUSH TABLES...FOR EXPORT. */ +void os_aio_wait_until_no_pending_writes() +{ + os_aio_wait_until_no_pending_writes_low(); + buf_dblwr.wait_flush_buffered_writes(); +} + +/** Request a read or write. +@param type I/O request +@param buf buffer +@param offset file offset +@param n number of bytes +@retval DB_SUCCESS if request was queued successfully +@retval DB_IO_ERROR on I/O error */ +dberr_t os_aio(const IORequest &type, void *buf, os_offset_t offset, size_t n) +{ + ut_ad(n > 0); + ut_ad((n % OS_FILE_LOG_BLOCK_SIZE) == 0); + ut_ad((offset % OS_FILE_LOG_BLOCK_SIZE) == 0); + ut_ad(type.is_read() || type.is_write()); + ut_ad(type.node); + ut_ad(type.node->is_open()); + +#ifdef WIN_ASYNC_IO + ut_ad((n & 0xFFFFFFFFUL) == n); +#endif /* WIN_ASYNC_IO */ + +#ifdef UNIV_PFS_IO + PSI_file_locker_state state; + PSI_file_locker* locker= nullptr; + register_pfs_file_io_begin(&state, locker, type.node->handle, n, + type.is_write() + ? PSI_FILE_WRITE : PSI_FILE_READ, + __FILE__, __LINE__); +#endif /* UNIV_PFS_IO */ + dberr_t err = DB_SUCCESS; + + if (!type.is_async()) { + err = type.is_read() + ? os_file_read_func(type, type.node->handle, + buf, offset, n) + : os_file_write_func(type, type.node->name, + type.node->handle, + buf, offset, n); +func_exit: +#ifdef UNIV_PFS_IO + register_pfs_file_io_end(locker, n); +#endif /* UNIV_PFS_IO */ + return err; + } + + if (type.is_read()) { + ++os_n_file_reads; + } else { + ++os_n_file_writes; + } + + compile_time_assert(sizeof(IORequest) <= tpool::MAX_AIO_USERDATA_LEN); + io_slots* slots= type.is_read() ? read_slots : write_slots; + tpool::aiocb* cb = slots->acquire(); + + cb->m_buffer = buf; + cb->m_callback = (tpool::callback_func)io_callback; + cb->m_group = slots->get_task_group(); + cb->m_fh = type.node->handle.m_file; + cb->m_len = (int)n; + cb->m_offset = offset; + cb->m_opcode = type.is_read() ? tpool::aio_opcode::AIO_PREAD : tpool::aio_opcode::AIO_PWRITE; + new (cb->m_userdata) IORequest{type}; + + ut_a(reinterpret_cast<size_t>(cb->m_buffer) % OS_FILE_LOG_BLOCK_SIZE + == 0); + ut_a(cb->m_len % OS_FILE_LOG_BLOCK_SIZE == 0); + ut_a(cb->m_offset % OS_FILE_LOG_BLOCK_SIZE == 0); + + if (srv_thread_pool->submit_io(cb)) { + slots->release(cb); + os_file_handle_error(type.node->name, type.is_read() + ? "aio read" : "aio write"); + err = DB_IO_ERROR; + } + + goto func_exit; +} + +/** Prints info of the aio arrays. +@param[in,out] file file where to print */ +void +os_aio_print(FILE* file) +{ + time_t current_time; + double time_elapsed; + + current_time = time(NULL); + time_elapsed = 0.001 + difftime(current_time, os_last_printout); + + fprintf(file, + "Pending flushes (fsync) log: " ULINTPF + "; buffer pool: " ULINTPF "\n" + ULINTPF " OS file reads, " + ULINTPF " OS file writes, " + ULINTPF " OS fsyncs\n", + log_sys.get_pending_flushes(), + ulint{fil_n_pending_tablespace_flushes}, + ulint{os_n_file_reads}, + os_n_file_writes, + os_n_fsyncs); + + const ulint n_reads = ulint(MONITOR_VALUE(MONITOR_OS_PENDING_READS)); + const ulint n_writes = ulint(MONITOR_VALUE(MONITOR_OS_PENDING_WRITES)); + + if (n_reads != 0 || n_writes != 0) { + fprintf(file, + ULINTPF " pending reads, " ULINTPF " pending writes\n", + n_reads, n_writes); + } + + ulint avg_bytes_read = (os_n_file_reads == os_n_file_reads_old) + ? 0 + : os_bytes_read_since_printout + / (os_n_file_reads - os_n_file_reads_old); + + fprintf(file, + "%.2f reads/s, " ULINTPF " avg bytes/read," + " %.2f writes/s, %.2f fsyncs/s\n", + static_cast<double>(os_n_file_reads - os_n_file_reads_old) + / time_elapsed, + avg_bytes_read, + static_cast<double>(os_n_file_writes - os_n_file_writes_old) + / time_elapsed, + static_cast<double>(os_n_fsyncs - os_n_fsyncs_old) + / time_elapsed); + + os_n_file_reads_old = os_n_file_reads; + os_n_file_writes_old = os_n_file_writes; + os_n_fsyncs_old = os_n_fsyncs; + os_bytes_read_since_printout = 0; + + os_last_printout = current_time; +} + +/** Refreshes the statistics used to print per-second averages. */ +void +os_aio_refresh_stats() +{ + os_n_fsyncs_old = os_n_fsyncs; + + os_bytes_read_since_printout = 0; + + os_n_file_reads_old = os_n_file_reads; + + os_n_file_writes_old = os_n_file_writes; + + os_n_fsyncs_old = os_n_fsyncs; + + os_bytes_read_since_printout = 0; + + os_last_printout = time(NULL); +} + + +/** +Set the file create umask +@param[in] umask The umask to use for file creation. */ +void +os_file_set_umask(ulint umask) +{ + os_innodb_umask = umask; +} + +#ifdef _WIN32 + +/* Checks whether physical drive is on SSD.*/ +static bool is_drive_on_ssd(DWORD nr) +{ + char physical_drive_path[32]; + snprintf(physical_drive_path, sizeof(physical_drive_path), + "\\\\.\\PhysicalDrive%lu", nr); + + HANDLE h= CreateFile(physical_drive_path, 0, + FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, + nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); + if (h == INVALID_HANDLE_VALUE) + return false; + + DEVICE_SEEK_PENALTY_DESCRIPTOR seek_penalty; + STORAGE_PROPERTY_QUERY storage_query{}; + storage_query.PropertyId= StorageDeviceSeekPenaltyProperty; + storage_query.QueryType= PropertyStandardQuery; + + bool on_ssd= false; + DWORD bytes_written; + if (DeviceIoControl(h, IOCTL_STORAGE_QUERY_PROPERTY, &storage_query, + sizeof storage_query, &seek_penalty, sizeof seek_penalty, + &bytes_written, nullptr)) + { + on_ssd= seek_penalty.IncursSeekPenalty; + } + else + { + on_ssd= false; + } + CloseHandle(h); + return on_ssd; +} + +/* + Checks whether volume is on SSD, by checking all physical drives + in that volume. +*/ +static bool is_volume_on_ssd(const char *volume_mount_point) +{ + char volume_name[MAX_PATH]; + + if (!GetVolumeNameForVolumeMountPoint(volume_mount_point, volume_name, + array_elements(volume_name))) + { + /* This can fail, e.g if file is on network share */ + return false; + } + + /* Chomp last backslash, this is needed to open volume.*/ + size_t length= strlen(volume_name); + if (length && volume_name[length - 1] == '\\') + volume_name[length - 1]= 0; + + /* Open volume handle */ + HANDLE volume_handle= CreateFile( + volume_name, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, + nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); + + if (volume_handle == INVALID_HANDLE_VALUE) + return false; + + /* + Enumerate all volume extends, check whether all of them are on SSD + */ + + /* Anticipate common case where there is only one extent.*/ + VOLUME_DISK_EXTENTS single_extent; + + /* But also have a place to manage allocated data.*/ + std::unique_ptr<BYTE[]> lifetime; + + DWORD bytes_written; + VOLUME_DISK_EXTENTS *extents= nullptr; + if (DeviceIoControl(volume_handle, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, + nullptr, 0, &single_extent, sizeof(single_extent), + &bytes_written, nullptr)) + { + /* Worked on the first try. Use the preallocated buffer.*/ + extents= &single_extent; + } + else + { + VOLUME_DISK_EXTENTS *last_query= &single_extent; + while (GetLastError() == ERROR_MORE_DATA) + { + DWORD extentCount= last_query->NumberOfDiskExtents; + DWORD allocatedSize= + FIELD_OFFSET(VOLUME_DISK_EXTENTS, Extents[extentCount]); + lifetime.reset(new BYTE[allocatedSize]); + last_query= (VOLUME_DISK_EXTENTS *) lifetime.get(); + if (DeviceIoControl(volume_handle, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, + nullptr, 0, last_query, allocatedSize, + &bytes_written, nullptr)) + { + extents= last_query; + break; + } + } + } + CloseHandle(volume_handle); + if (!extents) + return false; + + for (DWORD i= 0; i < extents->NumberOfDiskExtents; i++) + if (!is_drive_on_ssd(extents->Extents[i].DiskNumber)) + return false; + + return true; +} + +#include <unordered_map> +static bool is_file_on_ssd(char *file_path) +{ + /* Cache of volume_path => volume_info, protected by rwlock.*/ + static std::unordered_map<std::string, bool> cache; + static SRWLOCK lock= SRWLOCK_INIT; + + /* Preset result, in case something fails, e.g we're on network drive.*/ + char volume_path[MAX_PATH]; + if (!GetVolumePathName(file_path, volume_path, array_elements(volume_path))) + return false; + + /* Try cached volume info first.*/ + std::string volume_path_str(volume_path); + bool found; + bool result; + AcquireSRWLockShared(&lock); + auto e= cache.find(volume_path_str); + if ((found= e != cache.end())) + result= e->second; + ReleaseSRWLockShared(&lock); + + if (found) + return result; + + result= is_volume_on_ssd(volume_path); + + /* Update cache */ + AcquireSRWLockExclusive(&lock); + cache[volume_path_str]= result; + ReleaseSRWLockExclusive(&lock); + return result; +} + +#endif + +/** Determine some file metadata when creating or reading the file. +@param file the file that is being created, or OS_FILE_CLOSED */ +void fil_node_t::find_metadata(os_file_t file +#ifndef _WIN32 + , struct stat* statbuf +#endif + ) +{ + if (file == OS_FILE_CLOSED) { + file = handle; + ut_ad(is_open()); + } + +#ifdef _WIN32 /* FIXME: make this unconditional */ + if (space->punch_hole) { + space->punch_hole = os_is_sparse_file_supported(file); + } +#endif + + /* + For the temporary tablespace and during the + non-redo-logged adjustments in + IMPORT TABLESPACE, we do not care about + the atomicity of writes. + + Atomic writes is supported if the file can be used + with atomic_writes (not log file), O_DIRECT is + used (tested in ha_innodb.cc) and the file is + device and file system that supports atomic writes + for the given block size. + */ + space->atomic_write_supported = space->purpose == FIL_TYPE_TEMPORARY + || space->purpose == FIL_TYPE_IMPORT; +#ifdef _WIN32 + on_ssd = is_file_on_ssd(name); + FILE_STORAGE_INFO info; + if (GetFileInformationByHandleEx( + file, FileStorageInfo, &info, sizeof(info))) { + block_size = info.PhysicalBytesPerSectorForAtomicity; + } else { + block_size = 512; + } +#else + struct stat sbuf; + if (!statbuf && !fstat(file, &sbuf)) { + statbuf = &sbuf; + } + if (statbuf) { + block_size = statbuf->st_blksize; + } + on_ssd = space->atomic_write_supported +# ifdef UNIV_LINUX + || (statbuf && fil_system.is_ssd(statbuf->st_dev)) +# endif + ; +#endif + if (!space->atomic_write_supported) { + space->atomic_write_supported = atomic_write + && srv_use_atomic_writes +#ifndef _WIN32 + && my_test_if_atomic_write(file, + space->physical_size()) +#else + /* On Windows, all single sector writes are atomic, + as per WriteFile() documentation on MSDN. + We also require SSD for atomic writes, eventhough + technically it is not necessary- the reason is that + on hard disks, we still want the benefit from + (non-atomic) neighbor page flushing in the buffer + pool code. */ + && srv_page_size == block_size + && on_ssd +#endif + ; + } +} + +/** Read the first page of a data file. +@return whether the page was found valid */ +bool fil_node_t::read_page0() +{ + ut_ad(mutex_own(&fil_system.mutex)); + const unsigned psize = space->physical_size(); +#ifndef _WIN32 + struct stat statbuf; + if (fstat(handle, &statbuf)) { + return false; + } + os_offset_t size_bytes = statbuf.st_size; +#else + os_offset_t size_bytes = os_file_get_size(handle); + ut_a(size_bytes != (os_offset_t) -1); +#endif + const uint32_t min_size = FIL_IBD_FILE_INITIAL_SIZE * psize; + + if (size_bytes < min_size) { + ib::error() << "The size of the file " << name + << " is only " << size_bytes + << " bytes, should be at least " << min_size; + return false; + } + + page_t *page= static_cast<byte*>(aligned_malloc(psize, psize)); + if (os_file_read(IORequestRead, handle, page, 0, psize) + != DB_SUCCESS) { + ib::error() << "Unable to read first page of file " << name; +corrupted: + aligned_free(page); + return false; + } + + const ulint space_id = memcmp_aligned<2>( + FIL_PAGE_SPACE_ID + page, + FSP_HEADER_OFFSET + FSP_SPACE_ID + page, 4) + ? ULINT_UNDEFINED + : mach_read_from_4(FIL_PAGE_SPACE_ID + page); + ulint flags = fsp_header_get_flags(page); + const uint32_t size = fsp_header_get_field(page, FSP_SIZE); + const uint32_t free_limit = fsp_header_get_field(page, FSP_FREE_LIMIT); + const uint32_t free_len = flst_get_len(FSP_HEADER_OFFSET + FSP_FREE + + page); + if (!fil_space_t::is_valid_flags(flags, space->id)) { + ulint cflags = fsp_flags_convert_from_101(flags); + if (cflags == ULINT_UNDEFINED) { +invalid: + ib::error() + << "Expected tablespace flags " + << ib::hex(space->flags) + << " but found " << ib::hex(flags) + << " in the file " << name; + goto corrupted; + } + + ulint cf = cflags & ~FSP_FLAGS_MEM_MASK; + ulint sf = space->flags & ~FSP_FLAGS_MEM_MASK; + + if (!fil_space_t::is_flags_equal(cf, sf) + && !fil_space_t::is_flags_equal(sf, cf)) { + goto invalid; + } + + flags = cflags; + } + + ut_ad(!(flags & FSP_FLAGS_MEM_MASK)); + + /* Try to read crypt_data from page 0 if it is not yet read. */ + if (!space->crypt_data) { + space->crypt_data = fil_space_read_crypt_data( + fil_space_t::zip_size(flags), page); + } + aligned_free(page); + + if (UNIV_UNLIKELY(space_id != space->id)) { + ib::error() << "Expected tablespace id " << space->id + << " but found " << space_id + << " in the file " << name; + return false; + } + +#ifdef UNIV_LINUX + find_metadata(handle, &statbuf); +#else + find_metadata(); +#endif + /* Truncate the size to a multiple of extent size. */ + ulint mask = psize * FSP_EXTENT_SIZE - 1; + + if (size_bytes <= mask) { + /* .ibd files start smaller than an + extent size. Do not truncate valid data. */ + } else { + size_bytes &= ~os_offset_t(mask); + } + + space->flags = (space->flags & FSP_FLAGS_MEM_MASK) | flags; + + space->punch_hole = space->is_compressed(); + this->size = uint32_t(size_bytes / psize); + space->set_sizes(this->size); + ut_ad(space->free_limit == 0 || space->free_limit == free_limit); + ut_ad(space->free_len == 0 || space->free_len == free_len); + space->size_in_header = size; + space->free_limit = free_limit; + space->free_len = free_len; + return true; +} + +#else +#include "univ.i" +#endif /* !UNIV_INNOCHECKSUM */ + +/** 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) +{ + if (str != NULL) { + for (; *str; str++) { + if (*str == OS_PATH_SEPARATOR_ALT) { + *str = OS_PATH_SEPARATOR; + } + } + } +} diff --git a/storage/innobase/os/os0thread.cc b/storage/innobase/os/os0thread.cc new file mode 100644 index 00000000..f3533acf --- /dev/null +++ b/storage/innobase/os/os0thread.cc @@ -0,0 +1,131 @@ +/***************************************************************************** + +Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2017, 2020, 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, Fifth Floor, Boston, MA 02110-1335 USA + +*****************************************************************************/ + +/**************************************************//** +@file os/os0thread.cc +The interface to the operating system thread control primitives + +Created 9/8/1995 Heikki Tuuri +*******************************************************/ + +#include "univ.i" +#include "srv0srv.h" + +#ifdef _WIN32 +bool os_thread_eq(os_thread_id_t a, os_thread_id_t b) { return a == b; } +void os_thread_yield() { SwitchToThread(); } +os_thread_id_t os_thread_get_curr_id() { return GetCurrentThreadId(); } +#endif + +/****************************************************************//** +Creates a new thread of execution. The execution starts from +the function given. +NOTE: We count the number of threads in os_thread_exit(). A created +thread should always use that to exit so thatthe thread count will be +decremented. +We do not return an error code because if there is one, we crash here. */ +os_thread_t os_thread_create(os_thread_func_t func, void *arg) +{ + os_thread_id_t new_thread_id; + +#ifdef _WIN32 + HANDLE handle; + + handle = CreateThread(NULL, /* no security attributes */ + 0, /* default size stack */ + func, + arg, + 0, /* thread runs immediately */ + &new_thread_id); + + if (!handle) { + /* If we cannot start a new thread, life has no meaning. */ + ib::fatal() << "CreateThread returned " << GetLastError(); + } + + CloseHandle(handle); + + return((os_thread_t)new_thread_id); +#else /* _WIN32 else */ + + pthread_attr_t attr; + + int ret = pthread_attr_init(&attr); + if (UNIV_UNLIKELY(ret)) { + fprintf(stderr, + "InnoDB: Error: pthread_attr_init() returned %d\n", + ret); + abort(); + } + + ret = pthread_create(&new_thread_id, &attr, func, arg); + + ut_a(ret == 0); + + pthread_attr_destroy(&attr); + +#endif /* not _WIN32 */ + + return((os_thread_t)new_thread_id); +} + +/** Detach and terminate the current thread. */ +ATTRIBUTE_NORETURN void os_thread_exit() +{ +#ifdef UNIV_DEBUG_THREAD_CREATION + ib::info() << "Thread exits, id " << os_thread_get_curr_id(); +#endif + +#ifdef UNIV_PFS_THREAD + pfs_delete_thread(); +#endif + +#ifdef _WIN32 + ExitThread(0); +#else + pthread_detach(pthread_self()); + pthread_exit(NULL); +#endif +} + +/*****************************************************************//** +The thread sleeps at least the time given in microseconds. */ +void +os_thread_sleep( +/*============*/ + ulint tm) /*!< in: time in microseconds */ +{ +#ifdef _WIN32 + Sleep((DWORD) tm / 1000); +#elif defined(HAVE_NANOSLEEP) + struct timespec t; + + t.tv_sec = tm / 1000000; + t.tv_nsec = (tm % 1000000) * 1000; + + ::nanosleep(&t, NULL); +#else + struct timeval t; + + t.tv_sec = tm / 1000000; + t.tv_usec = tm % 1000000; + + select(0, NULL, NULL, NULL, &t); +#endif /* _WIN32 */ +} |