~drizzle-trunk/drizzle/development

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

Copyright (C) 1995, 2010, 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., 51 Franklin

St, Fifth Floor, Boston, MA 02110-1301 USA

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

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

@file fil/fil0fil.c

The tablespace memory cache

Created 10/25/1995 Heikki Tuuri

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

#include "fil0fil.h"

#include "mem0mem.h"

#include "hash0hash.h"

#include "os0file.h"

#include "mach0data.h"

#include "buf0buf.h"

#include "buf0flu.h"

#include "log0recv.h"

#include "fsp0fsp.h"

#include "srv0srv.h"

#include "srv0start.h"

#include "mtr0mtr.h"

#include "mtr0log.h"

#include "dict0dict.h"

#include "page0page.h"

#include "page0zip.h"

#include "xtrabackup_api.h"

#ifndef UNIV_HOTBACKUP

# include "buf0lru.h"

# include "ibuf0ibuf.h"

# include "sync0sync.h"

# include "os0sync.h"

#else /* !UNIV_HOTBACKUP */

static ulint srv_data_read, srv_data_written;

#endif /* !UNIV_HOTBACKUP */

/*

		IMPLEMENTATION OF THE TABLESPACE MEMORY CACHE

		=============================================

The tablespace cache is responsible for providing fast read/write access to

tablespaces and logs of the database. File creation and deletion is done

in other modules which know more of the logic of the operation, however.

A tablespace consists of a chain of files. The size of the files does not

have to be divisible by the database block size, because we may just leave

the last incomplete block unused. When a new file is appended to the

tablespace, the maximum size of the file is also specified. At the moment,

we think that it is best to extend the file to its maximum size already at

the creation of the file, because then we can avoid dynamically extending

the file when more space is needed for the tablespace.

A block's position in the tablespace is specified with a 32-bit unsigned

integer. The files in the chain are thought to be catenated, and the block

corresponding to an address n is the nth block in the catenated file (where

the first block is named the 0th block, and the incomplete block fragments

at the end of files are not taken into account). A tablespace can be extended

by appending a new file at the end of the chain.

Our tablespace concept is similar to the one of Oracle.

To acquire more speed in disk transfers, a technique called disk striping is

sometimes used. This means that logical block addresses are divided in a

round-robin fashion across several disks. Windows NT supports disk striping,

so there we do not need to support it in the database. Disk striping is

implemented in hardware in RAID disks. We conclude that it is not necessary

to implement it in the database. Oracle 7 does not support disk striping,

either.

Another trick used at some database sites is replacing tablespace files by

raw disks, that is, the whole physical disk drive, or a partition of it, is

opened as a single file, and it is accessed through byte offsets calculated

from the start of the disk or the partition. This is recommended in some

books on database tuning to achieve more speed in i/o. Using raw disk

certainly prevents the OS from fragmenting disk space, but it is not clear

if it really adds speed. We measured on the Pentium 100 MHz + NT + NTFS file

system + EIDE Conner disk only a negligible difference in speed when reading

from a file, versus reading from a raw disk.

To have fast access to a tablespace or a log file, we put the data structures

to a hash table. Each tablespace and log file is given an unique 32-bit

identifier.

Some operating systems do not support many open files at the same time,

though NT seems to tolerate at least 900 open files. Therefore, we put the

open files in an LRU-list. If we need to open another file, we may close the

file at the end of the LRU-list. When an i/o-operation is pending on a file,

the file cannot be closed. We take the file nodes with pending i/o-operations

out of the LRU-list and keep a count of pending operations. When an operation

completes, we decrement the count and return the file node to the LRU-list if

the count drops to zero. */

/** When mysqld is run, the default directory "." is the mysqld datadir,

but in the MySQL Embedded Server Library and ibbackup it is not the default

directory, and we must set the base file path explicitly */

UNIV_INTERN const char*	fil_path_to_mysql_datadir	= ".";

/** The number of fsyncs done to the log */

UNIV_INTERN ulint	fil_n_log_flushes			= 0;

/** Number of pending redo log flushes */

UNIV_INTERN ulint	fil_n_pending_log_flushes		= 0;

/** Number of pending tablespace flushes */

UNIV_INTERN ulint	fil_n_pending_tablespace_flushes	= 0;

/** The null file address */

UNIV_INTERN fil_addr_t	fil_addr_null = {FIL_NULL, 0};

#ifdef UNIV_PFS_MUTEX

/* Key to register fil_system_mutex with performance schema */

UNIV_INTERN mysql_pfs_key_t	fil_system_mutex_key;

#endif /* UNIV_PFS_MUTEX */

#ifdef UNIV_PFS_RWLOCK

/* Key to register file space latch with performance schema */

UNIV_INTERN mysql_pfs_key_t	fil_space_latch_key;

#endif /* UNIV_PFS_RWLOCK */

/** File node of a tablespace or the log data space */

struct fil_node_struct {

	fil_space_t*	space;	/*!< backpointer to the space where this node

				belongs */

	char*		name;	/*!< path to the file */

	ibool		open;	/*!< TRUE if file open */

	os_file_t	handle;	/*!< OS handle to the file, if file open */

	ibool		is_raw_disk;/*!< TRUE if the 'file' is actually a raw

				device or a raw disk partition */

	ulint		size;	/*!< size of the file in database pages, 0 if

				not known yet; the possible last incomplete

				megabyte may be ignored if space == 0 */

	ulint		n_pending;

				/*!< count of pending i/o's on this file;

				closing of the file is not allowed if

				this is > 0 */

	ulint		n_pending_flushes;

				/*!< count of pending flushes on this file;

				closing of the file is not allowed if

				this is > 0 */

	ib_int64_t	modification_counter;/*!< when we write to the file we

				increment this by one */

	ib_int64_t	flush_counter;/*!< up to what

				modification_counter value we have

				flushed the modifications to disk */

	UT_LIST_NODE_T(fil_node_t) chain;

				/*!< link field for the file chain */

	UT_LIST_NODE_T(fil_node_t) LRU;

				/*!< link field for the LRU list */

	ulint		magic_n;/*!< FIL_NODE_MAGIC_N */

};

/** Value of fil_node_struct::magic_n */

#define	FIL_NODE_MAGIC_N	89389

/** Tablespace or log data space: let us call them by a common name space */

struct fil_space_struct {

	char*		name;	/*!< space name = the path to the first file in

				it */

	ulint		id;	/*!< space id */

	ib_int64_t	tablespace_version;

				/*!< in DISCARD/IMPORT this timestamp

				is used to check if we should ignore

				an insert buffer merge request for a

				page because it actually was for the

				previous incarnation of the space */

	ibool		mark;	/*!< this is set to TRUE at database startup if

				the space corresponds to a table in the InnoDB

				data dictionary; so we can print a warning of

				orphaned tablespaces */

	ibool		stop_ios;/*!< TRUE if we want to rename the

				.ibd file of tablespace and want to

				stop temporarily posting of new i/o

				requests on the file */

	ibool		stop_ibuf_merges;

				/*!< we set this TRUE when we start

				deleting a single-table tablespace */

	ibool		is_being_deleted;

				/*!< this is set to TRUE when we start

				deleting a single-table tablespace and its

				file; when this flag is set no further i/o

				or flush requests can be placed on this space,

				though there may be such requests still being

				processed on this space */

	ulint		purpose;/*!< FIL_TABLESPACE, FIL_LOG, or

				FIL_ARCH_LOG */

	UT_LIST_BASE_NODE_T(fil_node_t) chain;

				/*!< base node for the file chain */

	ulint		size;	/*!< space size in pages; 0 if a single-table

				tablespace whose size we do not know yet;

				last incomplete megabytes in data files may be

				ignored if space == 0 */

	ulint		flags;	/*!< compressed page size and file format, or 0 */

	ulint		n_reserved_extents;

				/*!< number of reserved free extents for

				ongoing operations like B-tree page split */

	ulint		n_pending_flushes; /*!< this is positive when flushing

				the tablespace to disk; dropping of the

				tablespace is forbidden if this is positive */

	ulint		n_pending_ibuf_merges;/*!< this is positive

				when merging insert buffer entries to

				a page so that we may need to access

				the ibuf bitmap page in the

				tablespade: dropping of the tablespace

				is forbidden if this is positive */

	hash_node_t	hash;	/*!< hash chain node */

	hash_node_t	name_hash;/*!< hash chain the name_hash table */

#ifndef UNIV_HOTBACKUP

	rw_lock_t	latch;	/*!< latch protecting the file space storage

				allocation */

#endif /* !UNIV_HOTBACKUP */

	UT_LIST_NODE_T(fil_space_t) unflushed_spaces;

				/*!< list of spaces with at least one unflushed

				file we have written to */

	ibool		is_in_unflushed_spaces; /*!< TRUE if this space is

				currently in unflushed_spaces */

	UT_LIST_NODE_T(fil_space_t) space_list;

				/*!< list of all spaces */

	ulint		magic_n;/*!< FIL_SPACE_MAGIC_N */

};

/** Value of fil_space_struct::magic_n */

#define	FIL_SPACE_MAGIC_N	89472

/** The tablespace memory cache */

typedef	struct fil_system_struct	fil_system_t;

/** The tablespace memory cache; also the totality of logs (the log

data space) is stored here; below we talk about tablespaces, but also

the ib_logfiles form a 'space' and it is handled here */

struct fil_system_struct {

#ifndef UNIV_HOTBACKUP

	mutex_t		mutex;		/*!< The mutex protecting the cache */

#endif /* !UNIV_HOTBACKUP */

	hash_table_t*	spaces;		/*!< The hash table of spaces in the

					system; they are hashed on the space

					id */

	hash_table_t*	name_hash;	/*!< hash table based on the space

					name */

	UT_LIST_BASE_NODE_T(fil_node_t) LRU;

					/*!< base node for the LRU list of the

					most recently used open files with no

					pending i/o's; if we start an i/o on

					the file, we first remove it from this

					list, and return it to the start of

					the list when the i/o ends;

					log files and the system tablespace are

					not put to this list: they are opened

					after the startup, and kept open until

					shutdown */

	UT_LIST_BASE_NODE_T(fil_space_t) unflushed_spaces;

					/*!< base node for the list of those

					tablespaces whose files contain

					unflushed writes; those spaces have

					at least one file node where

					modification_counter > flush_counter */

	ulint		n_open;		/*!< number of files currently open */

	ulint		max_n_open;	/*!< n_open is not allowed to exceed

					this */

	ib_int64_t	modification_counter;/*!< when we write to a file we

					increment this by one */

	ulint		max_assigned_id;/*!< maximum space id in the existing

					tables, or assigned during the time

					mysqld has been up; at an InnoDB

					startup we scan the data dictionary

					and set here the maximum of the

					space id's of the tables there */

	ib_int64_t	tablespace_version;

					/*!< a counter which is incremented for

					every space object memory creation;

					every space mem object gets a

					'timestamp' from this; in DISCARD/

					IMPORT this is used to check if we

					should ignore an insert buffer merge

					request */

	UT_LIST_BASE_NODE_T(fil_space_t) space_list;

					/*!< list of all file spaces */

	ibool		space_id_reuse_warned;

					/* !< TRUE if fil_space_create()

					has issued a warning about

					potential space_id reuse */

};

/** The tablespace memory cache. This variable is NULL before the module is

initialized. */

fil_system_t*	fil_system	= NULL;

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

NOTE: you must call fil_mutex_enter_and_prepare_for_io() first!

Prepares a file node for i/o. Opens the file if it is closed. Updates the

pending i/o's field in the node and the system appropriately. Takes the node

off the LRU list if it is in the LRU list. The caller must hold the fil_sys

mutex. */

static

void

fil_node_prepare_for_io(

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

	fil_node_t*	node,	/*!< in: file node */

	fil_system_t*	system,	/*!< in: tablespace memory cache */

	fil_space_t*	space);	/*!< in: space */

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

Updates the data structures when an i/o operation finishes. Updates the

pending i/o's field in the node appropriately. */

static

void

fil_node_complete_io(

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

	fil_node_t*	node,	/*!< in: file node */

	fil_system_t*	system,	/*!< in: tablespace memory cache */

	ulint		type);	/*!< in: OS_FILE_WRITE or OS_FILE_READ; marks

				the node as modified if

				type == OS_FILE_WRITE */

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

Checks if a single-table tablespace for a given table name exists in the

tablespace memory cache.

@return	space id, ULINT_UNDEFINED if not found */

static

ulint

fil_get_space_id_for_table(

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

	const char*	name);	/*!< in: table name in the standard

				'databasename/tablename' format */

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

Frees a space object from the tablespace memory cache. Closes the files in

the chain but does not delete them. There must not be any pending i/o's or

flushes on the files.

@return TRUE on success */

static

ibool

fil_space_free(

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

	ulint		id,		/* in: space id */

	ibool		x_latched);	/* in: TRUE if caller has space->latch

					in X mode */

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

Reads data from a space to a buffer. Remember that the possible incomplete

blocks at the end of file are ignored: they are not taken into account when

calculating the byte offset within a space.

@return DB_SUCCESS, or DB_TABLESPACE_DELETED if we are trying to do

i/o on a tablespace which does not exist */

UNIV_INLINE

ulint

fil_read(

/*=====*/

	ibool	sync,		/*!< in: TRUE if synchronous aio is desired */

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

	ulint	zip_size,	/*!< in: compressed page size in bytes;

				0 for uncompressed pages */

	ulint	block_offset,	/*!< in: offset in number of blocks */

	ulint	byte_offset,	/*!< in: remainder of offset in bytes; in aio

				this must be divisible by the OS block size */

	ulint	len,		/*!< in: how many bytes to read; this must not

				cross a file boundary; in aio this must be a

				block size multiple */

	void*	buf,		/*!< in/out: buffer where to store data read;

				in aio this must be appropriately aligned */

	void*	message)	/*!< in: message for aio handler if non-sync

				aio used, else ignored */

{

	return(fil_io(OS_FILE_READ, sync, space_id, zip_size, block_offset,

					  byte_offset, len, buf, message));

}

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

Writes data to a space from a buffer. Remember that the possible incomplete

blocks at the end of file are ignored: they are not taken into account when

calculating the byte offset within a space.

@return DB_SUCCESS, or DB_TABLESPACE_DELETED if we are trying to do

i/o on a tablespace which does not exist */

UNIV_INLINE

ulint

fil_write(

/*======*/

	ibool	sync,		/*!< in: TRUE if synchronous aio is desired */

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

	ulint	zip_size,	/*!< in: compressed page size in bytes;

				0 for uncompressed pages */

	ulint	block_offset,	/*!< in: offset in number of blocks */

	ulint	byte_offset,	/*!< in: remainder of offset in bytes; in aio

				this must be divisible by the OS block size */

	ulint	len,		/*!< in: how many bytes to write; this must

				not cross a file boundary; in aio this must

				be a block size multiple */

	void*	buf,		/*!< in: buffer from which to write; in aio

				this must be appropriately aligned */

	void*	message)	/*!< in: message for aio handler if non-sync

				aio used, else ignored */

{

	return(fil_io(OS_FILE_WRITE, sync, space_id, zip_size, block_offset,

					   byte_offset, len, buf, message));

}

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

Returns the table space by a given id, NULL if not found. */

UNIV_INLINE

fil_space_t*

fil_space_get_by_id(

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

	ulint	id)	/*!< in: space id */

{

	fil_space_t*	space;

	ut_ad(mutex_own(&fil_system->mutex));

	HASH_SEARCH(hash, fil_system->spaces, id,

		    fil_space_t*, space,

		    ut_ad(space->magic_n == FIL_SPACE_MAGIC_N),

		    space->id == id);

	return(space);

}

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

Returns the table space by a given name, NULL if not found. */

UNIV_INLINE

fil_space_t*

fil_space_get_by_name(

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

	const char*	name)	/*!< in: space name */

{

	fil_space_t*	space;

	ulint		fold;

	ut_ad(mutex_own(&fil_system->mutex));

	fold = ut_fold_string(name);

	HASH_SEARCH(name_hash, fil_system->name_hash, fold,

		    fil_space_t*, space,

		    ut_ad(space->magic_n == FIL_SPACE_MAGIC_N),

		    !strcmp(name, space->name));

	return(space);

}

#ifndef UNIV_HOTBACKUP

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

Returns the version number of a tablespace, -1 if not found.

@return version number, -1 if the tablespace does not exist in the

memory cache */

UNIV_INTERN

ib_int64_t

fil_space_get_version(

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

	ulint	id)	/*!< in: space id */

{

	fil_space_t*	space;

	ib_int64_t	version		= -1;

	ut_ad(fil_system);

	mutex_enter(&fil_system->mutex);

	space = fil_space_get_by_id(id);

	if (space) {

		version = space->tablespace_version;

	}

	mutex_exit(&fil_system->mutex);

	return(version);

}

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

Returns the latch of a file space.

@return	latch protecting storage allocation */

UNIV_INTERN

rw_lock_t*

fil_space_get_latch(

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

	ulint	id,	/*!< in: space id */

	ulint*	flags)	/*!< out: tablespace flags */

{

	fil_space_t*	space;

	ut_ad(fil_system);

	mutex_enter(&fil_system->mutex);

	space = fil_space_get_by_id(id);

	ut_a(space);

	if (flags) {

		*flags = space->flags;

	}

	mutex_exit(&fil_system->mutex);

	return(&(space->latch));

}

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

Returns the type of a file space.

@return	FIL_TABLESPACE or FIL_LOG */

UNIV_INTERN

ulint

fil_space_get_type(

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

	ulint	id)	/*!< in: space id */

{

	fil_space_t*	space;

	ut_ad(fil_system);

	mutex_enter(&fil_system->mutex);

	space = fil_space_get_by_id(id);

	ut_a(space);

	mutex_exit(&fil_system->mutex);

	return(space->purpose);

}

#endif /* !UNIV_HOTBACKUP */

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

Checks if all the file nodes in a space are flushed. The caller must hold

the fil_system mutex.

@return	TRUE if all are flushed */

static

ibool

fil_space_is_flushed(

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

	fil_space_t*	space)	/*!< in: space */

{

	fil_node_t*	node;

	ut_ad(mutex_own(&fil_system->mutex));

	node = UT_LIST_GET_FIRST(space->chain);

	while (node) {

		if (node->modification_counter > node->flush_counter) {

			return(FALSE);

		}

		node = UT_LIST_GET_NEXT(chain, node);

	}

	return(TRUE);

}

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

Appends a new file to the chain of files of a space. File must be closed. */

UNIV_INTERN

void

fil_node_create(

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

	const char*	name,	/*!< in: file name (file must be closed) */

	ulint		size,	/*!< in: file size in database blocks, rounded

				downwards to an integer */

	ulint		id,	/*!< in: space id where to append */

	ibool		is_raw)	/*!< in: TRUE if a raw device or

				a raw disk partition */

{

	fil_node_t*	node;

	fil_space_t*	space;

	ut_a(fil_system);

	ut_a(name);

	mutex_enter(&fil_system->mutex);

	node = static_cast<fil_node_t *>(mem_alloc(sizeof(fil_node_t)));

	node->name = mem_strdup(name);

	node->open = FALSE;

	ut_a(!is_raw || srv_start_raw_disk_in_use);

	node->is_raw_disk = is_raw;

	node->size = size;

	node->magic_n = FIL_NODE_MAGIC_N;

	node->n_pending = 0;

	node->n_pending_flushes = 0;

	node->modification_counter = 0;

	node->flush_counter = 0;

	space = fil_space_get_by_id(id);

	if (!space) {

		ut_print_timestamp(stderr);

		fprintf(stderr,

			"  InnoDB: Error: Could not find tablespace %lu for\n"

			"InnoDB: file ", (ulong) id);

		ut_print_filename(stderr, name);

		fputs(" in the tablespace memory cache.\n", stderr);

		mem_free(node->name);

		mem_free(node);

		mutex_exit(&fil_system->mutex);

		return;

	}

	space->size += size;

	node->space = space;

	UT_LIST_ADD_LAST(chain, space->chain, node);

	if (id < SRV_LOG_SPACE_FIRST_ID && fil_system->max_assigned_id < id) {

		fil_system->max_assigned_id = id;

	}

	mutex_exit(&fil_system->mutex);

}

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

Opens a the file of a node of a tablespace. The caller must own the fil_system

mutex. */

static

void

fil_node_open_file(

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

	fil_node_t*	node,	/*!< in: file node */

	fil_system_t*	system,	/*!< in: tablespace memory cache */

	fil_space_t*	space)	/*!< in: space */

{

	uint64_t	size_bytes;

	ulint		size_low;

	ulint		size_high;

	ibool		ret;

	ibool		success;

	byte*		buf2;

	byte*		page;

	ulint		space_id;

	ulint		flags;

	ut_ad(mutex_own(&(system->mutex)));

	ut_a(node->n_pending == 0);

	ut_a(node->open == FALSE);

	if (node->size == 0) {

		/* It must be a single-table tablespace and we do not know the

		size of the file yet. First we open the file in the normal

		mode, no async I/O here, for simplicity. Then do some checks,

		and close the file again.

		NOTE that we could not use the simple file read function

		os_file_read() in Windows to read from a file opened for

		async I/O! */

		node->handle = os_file_create_simple_no_error_handling(

			innodb_file_data_key, node->name, OS_FILE_OPEN,

			OS_FILE_READ_ONLY, &success);

		if (!success) {

			/* The following call prints an error message */

			os_file_get_last_error(TRUE);

			ut_print_timestamp(stderr);

			fprintf(stderr,

				"  InnoDB: Fatal error: cannot open %s\n."

				"InnoDB: Have you deleted .ibd files"

				" under a running mysqld server?\n",

				node->name);

			ut_a(0);

		}

		os_file_get_size(node->handle, &size_low, &size_high);

		size_bytes = (((uint64_t)size_high) << 32) + size_low;

#ifdef UNIV_HOTBACKUP

		if (space->id == 0) {

			node->size = size_bytes / UNIV_PAGE_SIZE;

			os_file_close(node->handle);

			goto add_size;

		}

#endif /* UNIV_HOTBACKUP */

		ut_a(space->purpose != FIL_LOG);

		ut_a(space->id != 0);

		if (size_bytes < FIL_IBD_FILE_INITIAL_SIZE * UNIV_PAGE_SIZE) {

			fprintf(stderr,

				"InnoDB: Error: the size of single-table"

				" tablespace file %s\n"

				"InnoDB: is only %lu %lu,"

				" should be at least %lu!\n",

				node->name,

				(ulong) size_high,

				(ulong) size_low,

				(ulong) (FIL_IBD_FILE_INITIAL_SIZE

					 * UNIV_PAGE_SIZE));

			ut_a(0);

		}

		/* Read the first page of the tablespace */

		buf2 = static_cast<unsigned char *>(ut_malloc(2 * UNIV_PAGE_SIZE));

		/* Align the memory for file i/o if we might have O_DIRECT

		set */

		page = static_cast<unsigned char *>(ut_align(buf2, UNIV_PAGE_SIZE));

		success = os_file_read(node->handle, page, 0, 0,

				       UNIV_PAGE_SIZE);

		space_id = fsp_header_get_space_id(page);

		flags = fsp_header_get_flags(page);

		ut_free(buf2);

		/* Close the file now that we have read the space id from it */

		os_file_close(node->handle);

		if (UNIV_UNLIKELY(space_id != space->id)) {

			fprintf(stderr,

				"InnoDB: Error: tablespace id is %lu"

				" in the data dictionary\n"

				"InnoDB: but in file %s it is %lu!\n",

				space->id, node->name, space_id);

			ut_error;

		}

		if (UNIV_UNLIKELY(space_id == ULINT_UNDEFINED

				  || space_id == 0)) {

			fprintf(stderr,

				"InnoDB: Error: tablespace id %lu"

				" in file %s is not sensible\n",

				(ulong) space_id, node->name);

			ut_error;

		}

		if (UNIV_UNLIKELY(space->flags != flags)) {

			fprintf(stderr,

				"InnoDB: Error: table flags are %lx"

				" in the data dictionary\n"

				"InnoDB: but the flags in file %s are %lx!\n",

				space->flags, node->name, flags);

			ut_error;

		}

		if (size_bytes >= 1024 * 1024) {

			/* Truncate the size to whole megabytes. */

			size_bytes = ut_2pow_round(size_bytes, 1024 * 1024);

		}

		if (!(flags & DICT_TF_ZSSIZE_MASK)) {

			node->size = (ulint)size_bytes / UNIV_PAGE_SIZE;

		} else {

			node->size = (ulint)

				(size_bytes

				 / dict_table_flags_to_zip_size(flags));

		}

#ifdef UNIV_HOTBACKUP

add_size:

#endif /* UNIV_HOTBACKUP */

		space->size += node->size;

	}

	/* printf("Opening file %s\n", node->name); */

	/* Open the file for reading and writing, in Windows normally in the

	unbuffered async I/O mode, though global variables may make

	os_file_create() to fall back to the normal file I/O mode. */

	if (space->purpose == FIL_LOG) {

		node->handle = os_file_create(innodb_file_log_key,

					      node->name, OS_FILE_OPEN,

					      OS_FILE_AIO, OS_LOG_FILE,

					      &ret);

	} else if (node->is_raw_disk) {

		node->handle = os_file_create(innodb_file_data_key,

					      node->name,

					      OS_FILE_OPEN_RAW,