Mirrors
/
mariadb
mirror of https://github.com/MariaDB/server
3
0
Fork 0
Code Releases Activity
Browse Source

Cleanup: Remove OS_FILE_ON_ERROR_NO_EXIT 

Ever since commit 412ee0330c
or commit a440d6ed3a
InnoDB should generally not abort when failing to open or create files.
In Datafile::open_or_create() we had failed to set the flag
to avoid abort() on failure, but everywhere else we were setting it.

We may still call abort() via os_file_handle_error().

Reviewed by: Vladislav Vaintroub
pull/3045/head
Marko Mäkelä 2 years ago
parent
7f7329f092
commit
3dd7b0a80c
8 changed files with 152 additions and 312 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      storage/innobase/buf/buf0flu.cc
  2. 5
      storage/innobase/fil/fil0fil.cc
  3. 47
      storage/innobase/include/os0file.h
  4. 8
      storage/innobase/include/os0file.inl
  5. 3
      storage/innobase/log/log0log.cc
  6. 8
      storage/innobase/log/log0recv.cc
  7. 376
      storage/innobase/os/os0file.cc
  8. 14
      storage/innobase/srv/srv0start.cc

3
storage/innobase/buf/buf0flu.cc
View File

@ -1900,8 +1900,7 @@ inline void log_t::write_checkpoint(lsn_t end_lsn) noexcept
ut_ad(!log.is_opened());
bool success;
log.m_file=
os_file_create_func(get_log_file_path().c_str(),
OS_FILE_OPEN | OS_FILE_ON_ERROR_NO_EXIT,
os_file_create_func(get_log_file_path().c_str(), OS_FILE_OPEN,
OS_FILE_NORMAL, OS_LOG_FILE, false, &success);
ut_a(success);
ut_a(log.is_opened());

5
storage/innobase/fil/fil0fil.cc
View File

@ -361,8 +361,7 @@ static bool fil_node_open_file_low(fil_node_t *node)
bool success;
node->handle= os_file_create(innodb_data_file_key, node->name,
node->is_raw_disk
? OS_FILE_OPEN_RAW | OS_FILE_ON_ERROR_NO_EXIT
: OS_FILE_OPEN | OS_FILE_ON_ERROR_NO_EXIT,
? OS_FILE_OPEN_RAW : OS_FILE_OPEN,
OS_FILE_AIO, type,
srv_read_only_mode, &success);
@ -1922,7 +1921,7 @@ fil_ibd_create(
file = os_file_create(
innodb_data_file_key, path,
OS_FILE_CREATE | OS_FILE_ON_ERROR_NO_EXIT,
OS_FILE_CREATE,
OS_FILE_AIO, type, srv_read_only_mode, &success);
if (!success) {

47
storage/innobase/include/os0file.h
View File

@ -109,22 +109,21 @@ struct pfs_os_file_t
/** Options for os_file_create_func @{ */
enum os_file_create_t {
OS_FILE_OPEN = 51, /*!< to open an existing file (if
doesn't exist, error) */
OS_FILE_CREATE, /*!< to create new file (if
exists, error) */
OS_FILE_OPEN_RAW, /*!< to open a raw device or disk
partition */
OS_FILE_OPEN_RETRY, /*!< open with retry */
/** Flags that can be combined with the above values. Please ensure
that the above values stay below 128. */
OS_FILE_ON_ERROR_NO_EXIT = 128, /*!< do not exit on unknown errors */
OS_FILE_ON_ERROR_SILENT = 256 /*!< don't print diagnostic messages to
the log unless it is a fatal error,
this flag is only used if
ON_ERROR_NO_EXIT is set */
/** create a new file */
OS_FILE_CREATE= 0,
/** open an existing file */
OS_FILE_OPEN,
/** retry opening an existing file */
OS_FILE_OPEN_RETRY,
/** open a raw block device */
OS_FILE_OPEN_RAW,
/** do not display diagnostic messages */
OS_FILE_ON_ERROR_SILENT= 4,
OS_FILE_CREATE_SILENT= OS_FILE_CREATE | OS_FILE_ON_ERROR_SILENT,
OS_FILE_OPEN_SILENT= OS_FILE_OPEN | OS_FILE_ON_ERROR_SILENT,
OS_FILE_OPEN_RETRY_SILENT= OS_FILE_OPEN_RETRY | OS_FILE_ON_ERROR_SILENT
};
static const ulint OS_FILE_READ_ONLY = 333;
@ -346,7 +345,7 @@ A simple function to open or create a file.
pfs_os_file_t
os_file_create_simple_func(
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint access_type,
bool read_only,
bool* success);
@ -355,7 +354,7 @@ os_file_create_simple_func(
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] create_mode OS_FILE_CREATE or OS_FILE_OPEN
@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
@ -366,7 +365,7 @@ A simple function to open or create a file.
pfs_os_file_t
os_file_create_simple_no_error_handling_func(
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint access_type,
bool read_only,
bool* success)
@ -400,7 +399,7 @@ Opens an existing file or creates a new.
pfs_os_file_t
os_file_create_func(
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint purpose,
ulint type,
bool read_only,
@ -598,7 +597,7 @@ pfs_os_file_t
pfs_os_file_create_simple_func(
mysql_pfs_key_t key,
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint access_type,
bool read_only,
bool* success,
@ -614,7 +613,7 @@ monitor file creation/open.
@param[in] key Performance Schema Key
@param[in] name name of the file or path as a null-terminated
string
@param[in] create_mode create mode
@param[in] create_mode OS_FILE_CREATE or OS_FILE_OPEN
@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
@ -629,7 +628,7 @@ pfs_os_file_t
pfs_os_file_create_simple_no_error_handling_func(
mysql_pfs_key_t key,
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint access_type,
bool read_only,
bool* success,
@ -662,7 +661,7 @@ pfs_os_file_t
pfs_os_file_create_func(
mysql_pfs_key_t key,
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint purpose,
ulint type,
bool read_only,

8
storage/innobase/include/os0file.inl
View File

@ -45,7 +45,7 @@ pfs_os_file_t
pfs_os_file_create_simple_func(
mysql_pfs_key_t key,
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint access_type,
bool read_only,
bool* success,
@ -80,7 +80,7 @@ monitor file creation/open.
@param[in] key Performance Schema Key
@param[in] name name of the file or path as a null-terminated
string
@param[in] create_mode create mode
@param[in] create_mode OS_FILE_CREATE or OS_FILE_OPEN
@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
@ -95,7 +95,7 @@ pfs_os_file_t
pfs_os_file_create_simple_no_error_handling_func(
mysql_pfs_key_t key,
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint access_type,
bool read_only,
bool* success,
@ -146,7 +146,7 @@ pfs_os_file_t
pfs_os_file_create_func(
mysql_pfs_key_t key,
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint purpose,
ulint type,
bool read_only,

3
storage/innobase/log/log0log.cc
View File

@ -466,8 +466,7 @@ log_t::resize_start_status log_t::resize_start(os_offset_t size) noexcept
resize_lsn.store(1, std::memory_order_relaxed);
resize_target= 0;
resize_log.m_file=
os_file_create_func(path.c_str(),
OS_FILE_CREATE | OS_FILE_ON_ERROR_NO_EXIT,
os_file_create_func(path.c_str(), OS_FILE_CREATE,
OS_FILE_NORMAL, OS_LOG_FILE, false, &success);
if (success)
{

8
storage/innobase/log/log0recv.cc
View File

@ -844,8 +844,7 @@ processed:
inside recv_sys_t::recover_deferred(). */
bool success;
handle= os_file_create(innodb_data_file_key, filename,
OS_FILE_CREATE | OS_FILE_ON_ERROR_NO_EXIT |
OS_FILE_ON_ERROR_SILENT,
OS_FILE_CREATE_SILENT,
OS_FILE_AIO, OS_DATA_FILE, false, &success);
}
space->add(filename, handle, size, false, false);
@ -1714,7 +1713,7 @@ dberr_t recv_sys_t::find_checkpoint()
std::string path{get_log_file_path()};
bool success;
os_file_t file{os_file_create_func(path.c_str(),
OS_FILE_OPEN | OS_FILE_ON_ERROR_NO_EXIT,
OS_FILE_OPEN,
OS_FILE_NORMAL, OS_LOG_FILE,
srv_read_only_mode, &success)};
if (file == OS_FILE_CLOSED)
@ -1744,8 +1743,7 @@ dberr_t recv_sys_t::find_checkpoint()
{
path= get_log_file_path(LOG_FILE_NAME_PREFIX).append(std::to_string(i));
file= os_file_create_func(path.c_str(),
OS_FILE_OPEN | OS_FILE_ON_ERROR_NO_EXIT |
OS_FILE_ON_ERROR_SILENT,
OS_FILE_OPEN_SILENT,
OS_FILE_NORMAL, OS_LOG_FILE, true, &success);
if (file == OS_FILE_CLOSED)
break;

376
storage/innobase/os/os0file.cc
View File

@ -200,17 +200,10 @@ os_file_handle_error_cond_exit(
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)
@param operation name of operation that failed */
static void os_file_handle_error(const char *operation)
{
/* Exit in case of unknown error */
return(os_file_handle_error_cond_exit(name, operation, true, false));
os_file_handle_error_cond_exit(nullptr, operation, true, false);
}
/** Does error handling when a file operation fails.
@ -942,7 +935,7 @@ os_file_flush_func(
ib::error() << "The OS said file flush did not succeed";
os_file_handle_error(NULL, "flush");
os_file_handle_error("flush");
/* It is a fatal error if a file flush does not succeed, because then
the database can get corrupt on disk */
@ -965,7 +958,7 @@ A simple function to open or create a file.
pfs_os_file_t
os_file_create_simple_func(
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint access_type,
bool read_only,
bool* success)
@ -976,23 +969,14 @@ os_file_create_simple_func(
int create_flag = O_RDONLY | O_CLOEXEC;
ut_a(!(create_mode & OS_FILE_ON_ERROR_SILENT));
ut_a(!(create_mode & OS_FILE_ON_ERROR_NO_EXIT));
if (read_only) {
} else if (create_mode == OS_FILE_OPEN) {
if (access_type != OS_FILE_READ_ONLY) {
create_flag = O_RDWR | O_CLOEXEC;
}
} else if (create_mode == OS_FILE_CREATE) {
create_flag = O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC;
} else {
ib::error()
<< "Unknown file create mode ("
<< create_mode
<< " for file '" << name << "'";
return(OS_FILE_CLOSED);
ut_ad(create_mode == OS_FILE_OPEN);
if (access_type != OS_FILE_READ_ONLY) {
create_flag = O_RDWR | O_CLOEXEC;
}
}
bool retry;
@ -1025,10 +1009,10 @@ os_file_create_simple_func(
}
#endif
*success = false;
retry = os_file_handle_error(
retry = os_file_handle_error_no_exit(
name,
create_mode == OS_FILE_OPEN
? "open" : "create");
create_mode == OS_FILE_CREATE
? "create" : "open", false);
} else {
*success = true;
retry = false;
@ -1154,48 +1138,34 @@ Opens an existing file or creates a new.
pfs_os_file_t
os_file_create_func(
const char* name,
ulint create_mode,
os_file_create_t 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;
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 (read_only) {
create_flag = O_RDONLY | O_CLOEXEC;
} else if (create_mode == OS_FILE_OPEN
|| create_mode == OS_FILE_OPEN_RAW
|| create_mode == OS_FILE_OPEN_RETRY) {
create_flag = O_RDWR | O_CLOEXEC;
} else if (create_mode == OS_FILE_CREATE) {
} else if (create_mode == OS_FILE_CREATE
|| create_mode == OS_FILE_CREATE_SILENT) {
create_flag = O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC;
} else {
ib::error()
<< "Unknown file create mode (" << create_mode << ")"
<< " for file '" << name << "'";
return(OS_FILE_CLOSED);
ut_ad(create_mode == OS_FILE_OPEN
|| create_mode == OS_FILE_OPEN_SILENT
|| create_mode == OS_FILE_OPEN_RETRY
|| create_mode == OS_FILE_OPEN_RETRY_SILENT
|| create_mode == OS_FILE_OPEN_RAW);
create_flag = O_RDWR | O_CLOEXEC;
}
#ifdef O_DIRECT
@ -1219,10 +1189,14 @@ os_file_create_func(
} else if (log_sys.log_buffered) {
skip_o_direct:
os_file_log_buffered();
} else if (create_mode != OS_FILE_CREATE && !log_sys.is_opened()) {
} else if (create_mode != OS_FILE_CREATE
&& create_mode != OS_FILE_CREATE_SILENT
&& !log_sys.is_opened()) {
if (stat(name, &st)) {
if (errno == ENOENT) {
if (on_error_silent) goto not_found;
if (create_mode & OS_FILE_ON_ERROR_SILENT) {
goto not_found;
}
sql_print_error(
"InnoDB: File %s was not found", name);
goto not_found;
@ -1256,9 +1230,8 @@ os_file_create_func(
}
os_file_t file;
bool retry;
do {
for (;;) {
file = open(name, create_flag | direct_flag, os_innodb_umask);
if (file == -1) {
@ -1270,34 +1243,26 @@ os_file_create_func(
os_file_log_buffered();
}
# endif
if (create_mode == OS_FILE_CREATE) {
if (create_mode == OS_FILE_CREATE
|| create_mode == OS_FILE_CREATE_SILENT) {
/* Linux may create the file
before rejecting the O_DIRECT. */
unlink(name);
}
retry = true;
continue;
}
#endif
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);
if (!os_file_handle_error_no_exit(
name, (create_flag & O_CREAT)
? "create" : "open",
create_mode & OS_FILE_ON_ERROR_SILENT)) {
break;
}
} else {
*success = true;
retry = false;
break;
}
} while (retry);
}
if (!*success) {
#ifdef __linux__
@ -1307,8 +1272,7 @@ not_found:
}
#ifdef __linux__
if (!read_only && create_mode == OS_FILE_CREATE
&& type == OS_LOG_FILE) {
if ((create_flag & O_CREAT) && type == OS_LOG_FILE) {
if (fstat(file, &st) || !os_file_log_maybe_unbuffered(st)) {
os_file_log_buffered();
} else {
@ -1324,7 +1288,8 @@ not_found:
&& !my_disable_locking
&& os_file_lock(file, name)) {
if (create_mode == OS_FILE_OPEN_RETRY) {
if (create_mode == OS_FILE_OPEN_RETRY
|| create_mode == OS_FILE_OPEN_RETRY_SILENT) {
ib::info()
<< "Retrying to lock the first data file";
@ -1355,7 +1320,7 @@ 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] create_mode OS_FILE_CREATE or OS_FILE_OPEN
@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
@ -1366,7 +1331,7 @@ A simple function to open or create a file.
pfs_os_file_t
os_file_create_simple_no_error_handling_func(
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint access_type,
bool read_only,
bool* success)
@ -1374,30 +1339,19 @@ os_file_create_simple_no_error_handling_func(
os_file_t file;
int create_flag = O_RDONLY | O_CLOEXEC;
ut_a(!(create_mode & OS_FILE_ON_ERROR_SILENT));
ut_a(!(create_mode & OS_FILE_ON_ERROR_NO_EXIT));
*success = false;
if (read_only) {
} else if (create_mode == OS_FILE_OPEN) {
} else if (create_mode == OS_FILE_CREATE) {
create_flag = O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC;
} else {
ut_ad(create_mode == OS_FILE_OPEN);
if (access_type != OS_FILE_READ_ONLY) {
ut_a(access_type == OS_FILE_READ_WRITE
|| access_type == OS_FILE_READ_ALLOW_DELETE);
create_flag = O_RDWR;
}
} else if (create_mode == OS_FILE_CREATE) {
create_flag = O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC;
} else {
ib::error()
<< "Unknown file create mode "
<< create_mode << " for file '" << name << "'";
return(OS_FILE_CLOSED);
}
file = open(name, create_flag, os_innodb_umask);
@ -1520,7 +1474,7 @@ bool os_file_close_func(os_file_t file)
if (!ret)
return true;
os_file_handle_error(NULL, "close");
os_file_handle_error("close");
return false;
}
@ -1793,7 +1747,7 @@ bool os_file_flush_func(os_file_t file)
if (srv_start_raw_disk_in_use && GetLastError() == ERROR_INVALID_FUNCTION)
return true;
os_file_handle_error(nullptr, "flush");
os_file_handle_error("flush");
/* It is a fatal error if a file flush does not succeed, because then
the database can get corrupt on disk */
@ -1907,7 +1861,7 @@ A simple function to open or create a file.
pfs_os_file_t
os_file_create_simple_func(
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint access_type,
bool read_only,
bool* success)
@ -1916,65 +1870,31 @@ os_file_create_simple_func(
*success = false;
DWORD access;
DWORD access = GENERIC_READ;
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) {
if (read_only || 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);
ut_ad(create_mode == OS_FILE_CREATE);
create_flag = CREATE_NEW;
}
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);
ut_ad(access_type == OS_FILE_READ_WRITE);
access = GENERIC_READ | GENERIC_WRITE;
}
bool retry;
do {
for (;;) {
/* Use default security attributes and no template file. */
file = CreateFile(
@ -1982,22 +1902,18 @@ os_file_create_simple_func(
FILE_SHARE_READ | FILE_SHARE_DELETE,
my_win_file_secattr(), 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;
if (file != INVALID_HANDLE_VALUE) {
*success = true;
break;
}
} while (retry);
if (!os_file_handle_error_no_exit(name,
create_flag == CREATE_NEW
? "create" : "open",
false)) {
break;
}
}
return(file);
}
@ -2066,16 +1982,13 @@ Opens an existing file or creates a new.
pfs_os_file_t
os_file_create_func(
const char* name,
ulint create_mode,
os_file_create_t 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;
@ -2086,50 +1999,30 @@ os_file_create_func(
return(OS_FILE_CLOSED);
);
DWORD create_flag;
DWORD create_flag = OPEN_EXISTING;
DWORD share_mode = read_only
? FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE
: FILE_SHARE_READ | FILE_SHARE_DELETE;
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) {
switch (create_mode) {
case 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) {
break;
case OS_FILE_CREATE_SILENT:
case OS_FILE_CREATE:
create_flag = CREATE_NEW;
} else {
ib::error()
<< "Unknown file create mode (" << create_mode << ") "
<< " for file '" << name << "'";
return(OS_FILE_CLOSED);
break;
default:
ut_ad(create_mode == OS_FILE_OPEN
|| create_mode == OS_FILE_OPEN_SILENT
|| create_mode == OS_FILE_OPEN_RETRY_SILENT
|| create_mode == OS_FILE_OPEN_RETRY);
break;
}
DWORD attributes = (purpose == OS_FILE_AIO && srv_use_native_aio)
@ -2187,18 +2080,11 @@ os_file_create_func(
break;
}
operation = (create_mode == OS_FILE_CREATE && !read_only) ?
"create" : "open";
operation = create_flag == CREATE_NEW ? "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) {
if (!os_file_handle_error_no_exit(name, operation,
create_mode
& OS_FILE_ON_ERROR_SILENT)) {
break;
}
}
@ -2225,79 +2111,42 @@ A simple function to open or create a file.
pfs_os_file_t
os_file_create_simple_no_error_handling_func(
const char* name,
ulint create_mode,
os_file_create_t create_mode,
ulint access_type,
bool read_only,
bool* success)
{
os_file_t file;
*success = false;
DWORD access;
DWORD create_flag;
DWORD access = GENERIC_READ;
DWORD create_flag = OPEN_EXISTING;
DWORD attributes = 0;
DWORD share_mode = read_only
? FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE
: FILE_SHARE_READ | FILE_SHARE_DELETE;
DWORD share_mode = 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;
if (read_only) {
share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE
| FILE_SHARE_DELETE;
} else {
if (create_mode == OS_FILE_CREATE) {
create_flag = CREATE_NEW;
} else {
ut_ad(create_mode == OS_FILE_OPEN);
}
ib::error()
<< "Unknown file access type (" << access_type << ") "
<< "for file '" << name << "'";
return(OS_FILE_CLOSED);
switch (access_type) {
case OS_FILE_READ_ONLY: break;
case OS_FILE_READ_WRITE:
access = GENERIC_READ | GENERIC_WRITE;
break;
default:
ut_ad(access_type == OS_FILE_READ_ALLOW_DELETE);
/* A backup program has to give mariadbd the maximum
freedom to do what it likes with the file */
share_mode |= FILE_SHARE_DELETE | FILE_SHARE_WRITE
| FILE_SHARE_READ;
}
}
file = CreateFile((LPCTSTR) name,
@ -2465,7 +2314,7 @@ bool os_file_close_func(os_file_t file)
ut_ad(file);
if (!CloseHandle(file))
{
os_file_handle_error(NULL, "close");
os_file_handle_error("close");
return false;
}
@ -2903,8 +2752,8 @@ os_file_read_func(
if (ulint(n_bytes) == n || err != DB_SUCCESS)
return err;
os_file_handle_error_cond_exit(type.node ? type.node->name : nullptr, "read",
false, false);
os_file_handle_error_no_exit(type.node ? type.node->name : nullptr, "read",
false);
sql_print_error("InnoDB: Tried to read %zu bytes at offset %llu"
" of file %s, but was only able to read %zd",
n, offset, type.node ? type.node->name : "(unknown)",
@ -3791,8 +3640,9 @@ func_exit:
if (srv_thread_pool->submit_io(cb)) {
slots->release(cb);
os_file_handle_error(type.node->name, type.is_read()
? "aio read" : "aio write");
os_file_handle_error_no_exit(type.node->name, type.is_read()
? "aio read" : "aio write",
false);
err = DB_IO_ERROR;
type.node->space->release();
}

14
storage/innobase/srv/srv0start.cc
View File

@ -201,7 +201,7 @@ static dberr_t create_log_file(bool create_new_db, lsn_t lsn)
bool ret;
os_file_t file{
os_file_create_func(logfile0.c_str(),
OS_FILE_CREATE | OS_FILE_ON_ERROR_NO_EXIT,
OS_FILE_CREATE,
OS_FILE_NORMAL, OS_LOG_FILE, false, &ret)
};
@ -632,9 +632,8 @@ static uint32_t srv_undo_tablespace_open(bool create, const char* name,
}
}
pfs_os_file_t fh= os_file_create(innodb_data_file_key, name, OS_FILE_OPEN |
OS_FILE_ON_ERROR_NO_EXIT |
OS_FILE_ON_ERROR_SILENT,
pfs_os_file_t fh= os_file_create(innodb_data_file_key, name,
OS_FILE_OPEN_SILENT,
OS_FILE_AIO, OS_DATA_FILE,
srv_read_only_mode, &success);
@ -731,9 +730,7 @@ srv_check_undo_redo_logs_exists()
fh = os_file_create_func(
name,
OS_FILE_OPEN_RETRY
| OS_FILE_ON_ERROR_NO_EXIT
| OS_FILE_ON_ERROR_SILENT,
OS_FILE_OPEN_RETRY_SILENT,
OS_FILE_NORMAL,
OS_DATA_FILE,
srv_read_only_mode,
@ -755,8 +752,7 @@ srv_check_undo_redo_logs_exists()
auto logfilename = get_log_file_path();
fh = os_file_create_func(logfilename.c_str(),
OS_FILE_OPEN_RETRY | OS_FILE_ON_ERROR_NO_EXIT
| OS_FILE_ON_ERROR_SILENT,
OS_FILE_OPEN_RETRY_SILENT,
OS_FILE_NORMAL, OS_LOG_FILE,
srv_read_only_mode, &ret);

Write Preview
Loading…
Cancel
Save