mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2026-05-07 07:35:32 +02:00
Code Issues Projects Releases Packages Wiki Activity

MDEV-16264: Remove IORequest::IGNORE_MISSING

Browse source 
After MDEV-11556, not even crash recovery should attempt to access
non-existing pages. But, buf_load() is not validating its input
and must thus be able to ignore missing pages, so that is why
buf_read_page_background() does that.
This commit is contained in:
Marko Mäkelä 2019-11-15 19:55:40 +02:00
commit a69cff295c
4 changed files with 19 additions and 59 deletions
Download patch file Download diff file Expand all files Collapse all files

40
storage/innobase/buf/buf0rea.cc
View file

@ -100,12 +100,11 @@ flag is cleared and the x-lock released by an i/o-handler thread.
if we are trying
to read from a non-existent tablespace
@param[in] sync true if synchronous aio is desired
@param[in] type IO type, SIMULATED, IGNORE_MISSING
@param[in] mode BUF_READ_IBUF_PAGES_ONLY, ...,
@param[in] page_id page id
@param[in] zip_size ROW_FORMAT=COMPRESSED page size, or 0
@param[in] unzip true=request uncompressed page
@param[in] ignore_missing_space true=ignore missing space when reading
@param[in] ignore whether to ignore out-of-bounds page_id
@return 1 if a read request was queued, 0 if the page already resided
in buf_pool, or if the page is in the doublewrite buffer blocks in
which case it is never read into the pool, or if the tablespace does
@ -115,12 +114,11 @@ ulint
buf_read_page_low(
dberr_t* err,
bool sync,
ulint type,
ulint mode,
const page_id_t page_id,
ulint zip_size,
bool unzip,
bool ignore_missing_space = false)
bool ignore = false)
{
buf_page_t* bpage;
@ -176,20 +174,17 @@ buf_read_page_low(
dst = ((buf_block_t*) bpage)->frame;
}
IORequest request(type | IORequest::READ);
*err = fil_io(
request, sync, page_id, zip_size, 0,
IORequestRead, sync, page_id, zip_size, 0,
zip_size ? zip_size : srv_page_size,
dst, bpage, ignore_missing_space);
dst, bpage, ignore);
if (sync) {
thd_wait_end(NULL);
}
if (UNIV_UNLIKELY(*err != DB_SUCCESS)) {
if (IORequest::ignore_missing(type)
|| *err == DB_TABLESPACE_DELETED) {
if (ignore || *err == DB_TABLESPACE_DELETED) {
buf_read_page_handle_error(bpage);
return(0);
}
@ -344,7 +339,6 @@ read_ahead:
if (!ibuf_bitmap_page(cur_page_id, zip_size)) {
count += buf_read_page_low(
&err, false,
0,
ibuf_mode,
cur_page_id, zip_size, false);
@ -404,8 +398,7 @@ dberr_t buf_read_page(const page_id_t page_id, ulint zip_size)
of the buffer pool mutex becomes an expensive bottleneck. */
count = buf_read_page_low(
&err, true,
0, BUF_READ_ANY_PAGE, page_id, zip_size, false);
&err, true, BUF_READ_ANY_PAGE, page_id, zip_size, false);
srv_stats.buf_pool_reads.add(count);
@ -435,9 +428,8 @@ buf_read_page_background(const page_id_t page_id, ulint zip_size, bool sync)
count = buf_read_page_low(
&err, sync,
IORequest::IGNORE_MISSING,
BUF_READ_ANY_PAGE,
page_id, zip_size, false);
page_id, zip_size, false, true);
switch (err) {
case DB_SUCCESS:
@ -707,7 +699,6 @@ buf_read_ahead_linear(const page_id_t page_id, ulint zip_size, bool ibuf)
if (!ibuf_bitmap_page(cur_page_id, zip_size)) {
count += buf_read_page_low(
&err, false,
0,
ibuf_mode, cur_page_id, zip_size, false);
switch (err) {
@ -792,20 +783,9 @@ buf_read_recv_pages(
}
dberr_t err;
if (sync && i + 1 == n_stored) {
buf_read_page_low(
&err, true,
0,
BUF_READ_ANY_PAGE,
cur_page_id, zip_size, true);
} else {
buf_read_page_low(
&err, false,
0,
BUF_READ_ANY_PAGE,
cur_page_id, zip_size, true);
}
buf_read_page_low(
&err, sync && i + 1 == n_stored,
BUF_READ_ANY_PAGE, cur_page_id, zip_size, true);
if (err == DB_DECRYPTION_FAILED || err == DB_PAGE_CORRUPTED) {
ib::error() << "Recovery failed to read or decrypt "

14
storage/innobase/fil/fil0fil.cc
View file

@ -4097,7 +4097,7 @@ inline void IORequest::set_fil_node(fil_node_t* node)
aligned
@param[in] message message for aio handler if non-sync aio
used, else ignored
@param[in] ignore_missing_space true=ignore missing space duging read
@param[in] ignore whether to ignore out-of-bounds page_id
@return DB_SUCCESS, or DB_TABLESPACE_DELETED
if we are trying to do i/o on a tablespace which does not exist */
dberr_t
@ -4110,7 +4110,7 @@ fil_io(
ulint len,
void* buf,
void* message,
bool ignore_missing_space)
bool ignore)
{
os_offset_t offset;
IORequest req_type(type);
@ -4181,7 +4181,7 @@ fil_io(
mutex_exit(&fil_system.mutex);
if (!req_type.ignore_missing() && !ignore_missing_space) {
if (!ignore) {
ib::error()
<< "Trying to do I/O to a tablespace which"
" does not exist. I/O type: "
@ -4199,8 +4199,7 @@ fil_io(
for (;;) {
if (node == NULL) {
if (req_type.ignore_missing()) {
if (ignore) {
mutex_exit(&fil_system.mutex);
return(DB_ERROR);
}
@ -4234,7 +4233,7 @@ fil_io(
&& fil_is_user_tablespace_id(space->id)) {
mutex_exit(&fil_system.mutex);
if (!req_type.ignore_missing()) {
if (!ignore) {
ib::error()
<< "Trying to do I/O to a tablespace"
" which exists without .ibd data file."
@ -4262,8 +4261,7 @@ fil_io(
if (node->size <= cur_page_no
&& space->id != TRX_SYS_SPACE
&& fil_type_is_data(space->purpose)) {
if (req_type.ignore_missing()) {
if (ignore) {
/* If we can tolerate the non-existent pages, we
should return with DB_ERROR and let caller decide
what to do. */

4
storage/innobase/include/fil0fil.h
View file

@ -1420,7 +1420,7 @@ fil_space_extend(
aligned
@param[in] message message for aio handler if non-sync aio
used, else ignored
@param[in] ignore_missing_space true=ignore missing space during read
@param[in] ignore whether to ignore out-of-bounds page_id
@return DB_SUCCESS, or DB_TABLESPACE_DELETED
if we are trying to do i/o on a tablespace which does not exist */
dberr_t
@ -1433,7 +1433,7 @@ fil_io(
ulint len,
void* buf,
void* message,
bool ignore_missing_space = false);
bool ignore = false);
/**********************************************************************//**
Waits for an aio operation to complete. This function is used to write the

20
storage/innobase/include/os0file.h
View file

@ -215,12 +215,8 @@ public:
/** Disable partial read warnings */
DISABLE_PARTIAL_IO_WARNINGS = 32,
/** Ignore failed reads of non-existent pages */
IGNORE_MISSING = 128,
/** Use punch hole if available*/
PUNCH_HOLE = 256,
PUNCH_HOLE = 64,
};
/** Default constructor */
@ -269,13 +265,6 @@ public:
/** Destructor */
~IORequest() { }
/** @return true if ignore missing flag is set */
static bool ignore_missing(ulint type)
MY_ATTRIBUTE((warn_unused_result))
{
return((type & IGNORE_MISSING) == IGNORE_MISSING);
}
/** @return true if it is a read request */
bool is_read() const
MY_ATTRIBUTE((warn_unused_result))
@ -317,13 +306,6 @@ public:
m_type |= DISABLE_PARTIAL_IO_WARNINGS;
}
/** @return true if missing files should be ignored */
bool ignore_missing() const
MY_ATTRIBUTE((warn_unused_result))
{
return(ignore_missing(m_type));
}
/** @return true if punch hole should be used */
bool punch_hole() const
MY_ATTRIBUTE((warn_unused_result))