~drizzle-trunk/drizzle/development

/*****************************************************************************

Copyright (c) 1995, 2009, Innobase Oy. 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 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., 59 Temple

Place, Suite 330, Boston, MA 02111-1307 USA

*****************************************************************************/

/**************************************************//**

@file include/mtr0log.ic

Mini-transaction logging routines

Created 12/7/1995 Heikki Tuuri

*******************************************************/

#include "mach0data.h"

#include "ut0lst.h"

#include "buf0buf.h"

#include "fsp0types.h"

#include "trx0sys.h"

/********************************************************//**

Opens a buffer to mlog. It must be closed with mlog_close.

@return	buffer, NULL if log mode MTR_LOG_NONE */

UNIV_INLINE

byte*

mlog_open(

/*======*/

	mtr_t*	mtr,	/*!< in: mtr */

	ulint	size)	/*!< in: buffer size in bytes; MUST be

			smaller than DYN_ARRAY_DATA_SIZE! */

{

	dyn_array_t*	mlog;

	mtr->modifications = TRUE;

	if (mtr_get_log_mode(mtr) == MTR_LOG_NONE) {

		return(NULL);

	}

	mlog = &(mtr->log);

	return(dyn_array_open(mlog, size));

}

/********************************************************//**

Closes a buffer opened to mlog. */

UNIV_INLINE

void

mlog_close(

/*=======*/

	mtr_t*	mtr,	/*!< in: mtr */

	byte*	ptr)	/*!< in: buffer space from ptr up was not used */

{

	dyn_array_t*	mlog;

	ut_ad(mtr_get_log_mode(mtr) != MTR_LOG_NONE);

	mlog = &(mtr->log);

	dyn_array_close(mlog, ptr);

}

#ifndef UNIV_HOTBACKUP

/********************************************************//**

Catenates 1 - 4 bytes to the mtr log. The value is not compressed. */

UNIV_INLINE

void

mlog_catenate_ulint(

/*================*/

	mtr_t*	mtr,	/*!< in: mtr */

	ulint	val,	/*!< in: value to write */

	ulint	type)	/*!< in: MLOG_1BYTE, MLOG_2BYTES, MLOG_4BYTES */

{

	dyn_array_t*	mlog;

	byte*		ptr;

	if (mtr_get_log_mode(mtr) == MTR_LOG_NONE) {

		return;

	}

	mlog = &(mtr->log);

#if MLOG_1BYTE != 1

# error "MLOG_1BYTE != 1"

#endif

#if MLOG_2BYTES != 2

# error "MLOG_2BYTES != 2"

#endif

#if MLOG_4BYTES != 4

# error "MLOG_4BYTES != 4"

#endif

#if MLOG_8BYTES != 8

# error "MLOG_8BYTES != 8"

#endif

	ptr = (byte*) dyn_array_push(mlog, type);

	if (type == MLOG_4BYTES) {

		mach_write_to_4(ptr, val);

	} else if (type == MLOG_2BYTES) {

		mach_write_to_2(ptr, val);

	} else {

		ut_ad(type == MLOG_1BYTE);

		mach_write_to_1(ptr, val);

	}

}

/********************************************************//**

Catenates a compressed ulint to mlog. */

UNIV_INLINE

void

mlog_catenate_ulint_compressed(

/*===========================*/

	mtr_t*	mtr,	/*!< in: mtr */

	ulint	val)	/*!< in: value to write */

{

	byte*	log_ptr;

	log_ptr = mlog_open(mtr, 10);

	/* If no logging is requested, we may return now */

	if (log_ptr == NULL) {

		return;

	}

	log_ptr += mach_write_compressed(log_ptr, val);

	mlog_close(mtr, log_ptr);

}

/********************************************************//**

Catenates a compressed dulint to mlog. */

UNIV_INLINE

void

mlog_catenate_dulint_compressed(

/*============================*/

	mtr_t*	mtr,	/*!< in: mtr */

	dulint	val)	/*!< in: value to write */

{

	byte*	log_ptr;

	log_ptr = mlog_open(mtr, 15);

	/* If no logging is requested, we may return now */

	if (log_ptr == NULL) {

		return;

	}

	log_ptr += mach_dulint_write_compressed(log_ptr, val);

	mlog_close(mtr, log_ptr);

}

/********************************************************//**

Writes the initial part of a log record (3..11 bytes).

If the implementation of this function is changed, all

size parameters to mlog_open() should be adjusted accordingly!

@return	new value of log_ptr */

UNIV_INLINE

byte*

mlog_write_initial_log_record_fast(

/*===============================*/

	const byte*	ptr,	/*!< in: pointer to (inside) a buffer

				frame holding the file page where

				modification is made */

	byte		type,	/*!< in: log item type: MLOG_1BYTE, ... */

	byte*		log_ptr,/*!< in: pointer to mtr log which has

				been opened */

	mtr_t*		mtr)	/*!< in: mtr */

{

#ifdef UNIV_DEBUG

	buf_block_t*	block;

#endif

	const byte*	page;

	ulint		space;

	ulint		offset;

	ut_ad(mtr_memo_contains_page(mtr, ptr, MTR_MEMO_PAGE_X_FIX));

	ut_ad(type <= MLOG_BIGGEST_TYPE);

	ut_ad(ptr && log_ptr);

	page = (const byte*) ut_align_down(ptr, UNIV_PAGE_SIZE);

	space = mach_read_from_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);

	offset = mach_read_from_4(page + FIL_PAGE_OFFSET);

	/* check whether the page is in the doublewrite buffer;

	the doublewrite buffer is located in pages

	FSP_EXTENT_SIZE, ..., 3 * FSP_EXTENT_SIZE - 1 in the

	system tablespace */

	if (space == TRX_SYS_SPACE

	    && offset >= FSP_EXTENT_SIZE && offset < 3 * FSP_EXTENT_SIZE) {

		if (trx_doublewrite_buf_is_being_created) {

			/* Do nothing: we only come to this branch in an

			InnoDB database creation. We do not redo log

			anything for the doublewrite buffer pages. */

			return(log_ptr);

		} else {

			fprintf(stderr,

				"Error: trying to redo log a record of type "

				"%d on page %lu of space %lu in the "

				"doublewrite buffer, continuing anyway.\n"

				"Please post a bug report to "

				"bugs.mysql.com.\n",

				type, offset, space);

		}

	}

	mach_write_to_1(log_ptr, type);

	log_ptr++;

	log_ptr += mach_write_compressed(log_ptr, space);

	log_ptr += mach_write_compressed(log_ptr, offset);

	mtr->n_log_recs++;

#ifdef UNIV_LOG_DEBUG

	fprintf(stderr,

		"Adding to mtr log record type %lu space %lu page no %lu\n",

		(ulong) type, space, offset);

#endif

#ifdef UNIV_DEBUG

	/* We now assume that all x-latched pages have been modified! */

	block = (buf_block_t*) buf_block_align(ptr);

	if (!mtr_memo_contains(mtr, block, MTR_MEMO_MODIFY)) {

		mtr_memo_push(mtr, block, MTR_MEMO_MODIFY);

	}

#endif

	return(log_ptr);

}

/********************************************************//**

Writes a log record about an .ibd file create/delete/rename.

@return	new value of log_ptr */

UNIV_INLINE

byte*

mlog_write_initial_log_record_for_file_op(

/*======================================*/

	ulint	type,	/*!< in: MLOG_FILE_CREATE, MLOG_FILE_DELETE, or

			MLOG_FILE_RENAME */

	ulint	space_id,/*!< in: space id, if applicable */

	ulint	page_no,/*!< in: page number (not relevant currently) */

	byte*	log_ptr,/*!< in: pointer to mtr log which has been opened */

	mtr_t*	mtr)	/*!< in: mtr */

{

	ut_ad(log_ptr);

	mach_write_to_1(log_ptr, type);

	log_ptr++;

	/* We write dummy space id and page number */

	log_ptr += mach_write_compressed(log_ptr, space_id);

	log_ptr += mach_write_compressed(log_ptr, page_no);

	mtr->n_log_recs++;

	return(log_ptr);

}

#endif /* !UNIV_HOTBACKUP */