143 lines
6.4 KiB
C
143 lines
6.4 KiB
C
/*****************************************************************************
|
|
|
|
Copyright (c) 1995, 2018, Oracle and/or its affiliates. All Rights Reserved.
|
|
|
|
This program is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License, version 2.0, as published by the
|
|
Free Software Foundation.
|
|
|
|
This program is also distributed with certain software (including but not
|
|
limited to OpenSSL) that is licensed under separate terms, as designated in a
|
|
particular file or component or in included license documentation. The authors
|
|
of MySQL hereby grant you an additional permission to link the program and
|
|
your derivative works with the separately licensed software that they have
|
|
included with MySQL.
|
|
|
|
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, version 2.0,
|
|
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 St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/** @file include/buf0dblwr.h
|
|
Doublewrite buffer module
|
|
|
|
Created 2011/12/19 Inaam Rana
|
|
*******************************************************/
|
|
|
|
#ifndef buf0dblwr_h
|
|
#define buf0dblwr_h
|
|
|
|
#include "buf0types.h"
|
|
#include "log0log.h"
|
|
#include "log0recv.h"
|
|
#include "univ.i"
|
|
#include "ut0byte.h"
|
|
|
|
/** Doublewrite system */
|
|
extern buf_dblwr_t *buf_dblwr;
|
|
/** Set to TRUE when the doublewrite buffer is being created */
|
|
extern ibool buf_dblwr_being_created;
|
|
|
|
/** Creates the doublewrite buffer to a new InnoDB installation. The header of
|
|
the doublewrite buffer is placed on the trx system header page.
|
|
@return true if successful, false if not. */
|
|
MY_ATTRIBUTE((warn_unused_result))
|
|
bool buf_dblwr_create(void);
|
|
|
|
/** At a database startup initializes the doublewrite buffer memory structure if
|
|
we already have a doublewrite buffer created in the data files. If we are
|
|
upgrading to an InnoDB version which supports multiple tablespaces, then this
|
|
function performs the necessary update operations. If we are in a crash
|
|
recovery, this function loads the pages from double write buffer into memory.
|
|
@return DB_SUCCESS or error code */
|
|
dberr_t buf_dblwr_init_or_load_pages(pfs_os_file_t file, const char *path);
|
|
|
|
/** Process and remove the double write buffer pages for all tablespaces. */
|
|
void buf_dblwr_process(void);
|
|
|
|
/** frees doublewrite buffer. */
|
|
void buf_dblwr_free(void);
|
|
/** Updates the doublewrite buffer when an IO request is completed. */
|
|
void buf_dblwr_update(
|
|
const buf_page_t *bpage, /*!< in: buffer block descriptor */
|
|
buf_flush_t flush_type); /*!< in: flush type */
|
|
/** Determines if a page number is located inside the doublewrite buffer.
|
|
@return true if the location is inside the two blocks of the
|
|
doublewrite buffer */
|
|
ibool buf_dblwr_page_inside(page_no_t page_no); /*!< in: page number */
|
|
|
|
/** Posts a buffer page for writing. If the doublewrite memory buffer
|
|
is full, calls buf_dblwr_flush_buffered_writes and waits for for free
|
|
space to appear.
|
|
@param[in] bpage buffer block to write */
|
|
void buf_dblwr_add_to_batch(buf_page_t *bpage);
|
|
|
|
/** Flush a batch of writes to the datafiles that have already been
|
|
written to the dblwr buffer on disk. */
|
|
void buf_dblwr_sync_datafiles();
|
|
|
|
/** Flushes possible buffered writes from the doublewrite memory buffer to disk,
|
|
and also wakes up the aio thread if simulated aio is used. It is very
|
|
important to call this function after a batch of writes has been posted,
|
|
and also when we may have to wait for a page latch! Otherwise a deadlock
|
|
of threads can occur. */
|
|
void buf_dblwr_flush_buffered_writes(void);
|
|
/** Writes a page to the doublewrite buffer on disk, sync it, then write
|
|
the page to the datafile and sync the datafile. This function is used
|
|
for single page flushes. If all the buffers allocated for single page
|
|
flushes in the doublewrite buffer are in use we wait here for one to
|
|
become free. We are guaranteed that a slot will become free because any
|
|
thread that is using a slot must also release the slot before leaving
|
|
this function. */
|
|
void buf_dblwr_write_single_page(
|
|
buf_page_t *bpage, /*!< in: buffer block to write */
|
|
bool sync); /*!< in: true if sync IO requested */
|
|
|
|
/** Recover pages from the double write buffer for a specific tablespace.
|
|
The pages that were read from the doublewrite buffer are written to the
|
|
tablespace they belong to.
|
|
@param[in] space Tablespace instance */
|
|
void buf_dblwr_recover_pages(fil_space_t *space);
|
|
|
|
/** Doublewrite control struct */
|
|
struct buf_dblwr_t {
|
|
ib_mutex_t mutex; /*!< mutex protecting the first_free
|
|
field and write_buf */
|
|
page_no_t block1; /*!< the page number of the first
|
|
doublewrite block (64 pages) */
|
|
page_no_t block2; /*!< page number of the second block */
|
|
page_no_t first_free; /*!< first free position in write_buf
|
|
measured in units of UNIV_PAGE_SIZE */
|
|
ulint b_reserved; /*!< number of slots currently reserved
|
|
for batch flush. */
|
|
os_event_t b_event; /*!< event where threads wait for a
|
|
batch flush to end. */
|
|
ulint s_reserved; /*!< number of slots currently
|
|
reserved for single page flushes. */
|
|
os_event_t s_event; /*!< event where threads wait for a
|
|
single page flush slot. */
|
|
bool *in_use; /*!< flag used to indicate if a slot is
|
|
in use. Only used for single page
|
|
flushes. */
|
|
bool batch_running; /*!< set to TRUE if currently a batch
|
|
is being written from the doublewrite
|
|
buffer. */
|
|
byte *write_buf; /*!< write buffer used in writing to the
|
|
doublewrite buffer, aligned to an
|
|
address divisible by UNIV_PAGE_SIZE
|
|
(which is required by Windows aio) */
|
|
byte *write_buf_unaligned; /*!< pointer to write_buf,
|
|
but unaligned */
|
|
buf_page_t **buf_block_arr; /*!< array to store pointers to
|
|
the buffer blocks which have been
|
|
cached to write_buf */
|
|
};
|
|
|
|
#endif
|