~drizzle-trunk/drizzle/development

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

The tablespace memory cache

(c) 1995 Innobase Oy

Created 10/25/1995 Heikki Tuuri

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

#include "fil0fil.h"

#include "mem0mem.h"

#include "sync0sync.h"

#include "hash0hash.h"

#include "os0file.h"

#include "os0sync.h"

#include "mach0data.h"

#include "ibuf0ibuf.h"

#include "buf0buf.h"

#include "buf0flu.h"

#include "buf0lru.h"

#include "log0log.h"

#include "log0recv.h"

#include "fsp0fsp.h"

#include "srv0srv.h"

#include "srv0start.h"

#include "mtr0mtr.h"

#include "mtr0log.h"

#include "dict0dict.h"

/*

		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 */

const char*	fil_path_to_mysql_datadir	= ".";

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

ulint	fil_n_log_flushes			= 0;

ulint	fil_n_pending_log_flushes		= 0;

ulint	fil_n_pending_tablespace_flushes	= 0;

/* Null file address */

fil_addr_t	fil_addr_null = {FIL_NULL, 0};

/* 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_longlong	modification_counter;/* when we write to the file we

				increment this by one */

	ib_longlong	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;

};

#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_longlong	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		n_reserved_extents;

				/* number of reserved free extents for

				ongoing operations like B-tree page split */

	ulint		n_pending_flushes; /* this is > 0 when flushing

				the tablespace to disk; dropping of the

				tablespace is forbidden if this is > 0 */

	ulint		n_pending_ibuf_merges;/* this is > 0 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 > 0 */

	hash_node_t	hash;	/* hash chain node */

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

	rw_lock_t	latch;	/* latch protecting the file space storage

				allocation */

	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 the list above */

	UT_LIST_NODE_T(fil_space_t) space_list;

				/* list of all spaces */

	ibuf_data_t*	ibuf_data;

				/* insert buffer data */

	ulint		magic_n;

};

#define	FIL_SPACE_MAGIC_N	89472

/* 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 */

typedef	struct fil_system_struct	fil_system_t;

struct fil_system_struct {

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

	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_longlong	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_longlong	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 */

};

/* 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. */

static

ulint

fil_get_space_id_for_table(

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

				/* out: space id, ULINT_UNDEFINED if not

				found */

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

				'databasename/tablename' format */

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

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

ib_longlong

fil_space_get_version(

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

			/* out: version number, -1 if the tablespace does not

			exist in the memory cache */

	ulint	id)	/* in: space id */

{

	fil_system_t*	system		= fil_system;

	fil_space_t*	space;

	ib_longlong	version		= -1;

	ut_ad(system);

	mutex_enter(&(system->mutex));

	HASH_SEARCH(hash, system->spaces, id, space, space->id == id);

	if (space) {

		version = space->tablespace_version;

	}

	mutex_exit(&(system->mutex));

	return(version);

}

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

Returns the latch of a file space. */

rw_lock_t*

fil_space_get_latch(

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

			/* out: latch protecting storage allocation */

	ulint	id)	/* in: space id */

{

	fil_system_t*	system		= fil_system;

	fil_space_t*	space;

	ut_ad(system);

	mutex_enter(&(system->mutex));

	HASH_SEARCH(hash, system->spaces, id, space, space->id == id);

	ut_a(space);

	mutex_exit(&(system->mutex));

	return(&(space->latch));

}

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

Returns the type of a file space. */

ulint

fil_space_get_type(

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

			/* out: FIL_TABLESPACE or FIL_LOG */

	ulint	id)	/* in: space id */

{

	fil_system_t*	system		= fil_system;

	fil_space_t*	space;

	ut_ad(system);

	mutex_enter(&(system->mutex));

	HASH_SEARCH(hash, system->spaces, id, space, space->id == id);

	ut_a(space);

	mutex_exit(&(system->mutex));

	return(space->purpose);

}

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

Returns the ibuf data of a file space. */

ibuf_data_t*

fil_space_get_ibuf_data(

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

			/* out: ibuf data for this space */

	ulint	id)	/* in: space id */

{

	fil_system_t*	system		= fil_system;

	fil_space_t*	space;

	ut_ad(system);

	ut_a(id == 0);

	mutex_enter(&(system->mutex));

	HASH_SEARCH(hash, system->spaces, id, space, space->id == id);

	mutex_exit(&(system->mutex));

	ut_a(space);

	return(space->ibuf_data);

}

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

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

the fil_system mutex. */

static

ibool

fil_space_is_flushed(

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

				/* out: TRUE if all are 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. */

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_system_t*	system	= fil_system;

	fil_node_t*	node;

	fil_space_t*	space;

	ut_a(system);

	ut_a(name);

	mutex_enter(&(system->mutex));

	node = 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;

	HASH_SEARCH(hash, system->spaces, id, space, space->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(&(system->mutex));

		return;

	}

	space->size += size;

	node->space = space;

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

	mutex_exit(&(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 */

{

	ib_longlong	size_bytes;

	ulint		size_low;

	ulint		size_high;

	ibool		ret;

	ibool		success;

#ifndef UNIV_HOTBACKUP

	byte*		buf2;

	byte*		page;

	ulint		space_id;

#endif /* !UNIV_HOTBACKUP */

	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(

			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 = (((ib_longlong)size_high) << 32)

			+ (ib_longlong)size_low;

#ifdef UNIV_HOTBACKUP

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

#else

		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 = ut_malloc(2 * UNIV_PAGE_SIZE);

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

		set */

		page = 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);

		ut_free(buf2);

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

		os_file_close(node->handle);

		if (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_a(0);

		}

		if (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_a(0);

		}

		if (size_bytes >= FSP_EXTENT_SIZE * UNIV_PAGE_SIZE) {

			node->size = (ulint)

				((size_bytes / (1024 * 1024))

				 * ((1024 * 1024) / UNIV_PAGE_SIZE));

		} else {

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

		}

#endif

		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(node->name, OS_FILE_OPEN,

					      OS_FILE_AIO, OS_LOG_FILE, &ret);

	} else if (node->is_raw_disk) {

		node->handle = os_file_create(node->name,

					      OS_FILE_OPEN_RAW,

					      OS_FILE_AIO, OS_DATA_FILE, &ret);

	} else {

		node->handle = os_file_create(node->name, OS_FILE_OPEN,

					      OS_FILE_AIO, OS_DATA_FILE, &ret);

	}

	ut_a(ret);

	node->open = TRUE;

	system->n_open++;

	if (space->purpose == FIL_TABLESPACE && space->id != 0) {

		/* Put the node to the LRU list */

		UT_LIST_ADD_FIRST(LRU, system->LRU, node);

	}

}

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

Closes a file. */

static

void

fil_node_close_file(

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

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

	fil_system_t*	system)	/* in: tablespace memory cache */

{

	ibool	ret;

	ut_ad(node && system);

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

	ut_a(node->open);

	ut_a(node->n_pending == 0);

	ut_a(node->n_pending_flushes == 0);

	ut_a(node->modification_counter == node->flush_counter);

	ret = os_file_close(node->handle);

	ut_a(ret);

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

	node->open = FALSE;

	ut_a(system->n_open > 0);

	system->n_open--;

	if (node->space->purpose == FIL_TABLESPACE && node->space->id != 0) {

		ut_a(UT_LIST_GET_LEN(system->LRU) > 0);

		/* The node is in the LRU list, remove it */

		UT_LIST_REMOVE(LRU, system->LRU, node);

	}

}

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

Tries to close a file in the LRU list. The caller must hold the fil_sys

mutex. */

static

ibool

fil_try_to_close_file_in_LRU(

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

				/* out: TRUE if success, FALSE if should retry

				later; since i/o's generally complete in <

				100 ms, and as InnoDB writes at most 128 pages

				from the buffer pool in a batch, and then

				immediately flushes the files, there is a good

				chance that the next time we find a suitable

				node from the LRU list */

	ibool	print_info)	/* in: if TRUE, prints information why it

				cannot close a file */

{

	fil_system_t*	system		= fil_system;

	fil_node_t*	node;

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

	node = UT_LIST_GET_LAST(system->LRU);

	if (print_info) {

		fprintf(stderr,

			"InnoDB: fil_sys open file LRU len %lu\n",

			(ulong) UT_LIST_GET_LEN(system->LRU));

	}

	while (node != NULL) {

		if (node->modification_counter == node->flush_counter

		    && node->n_pending_flushes == 0) {

			fil_node_close_file(node, system);

			return(TRUE);

		}

		if (print_info && node->n_pending_flushes > 0) {

			fputs("InnoDB: cannot close file ", stderr);

			ut_print_filename(stderr, node->name);

			fprintf(stderr, ", because n_pending_flushes %lu\n",

				(ulong) node->n_pending_flushes);

		}

		if (print_info

		    && node->modification_counter != node->flush_counter) {

			fputs("InnoDB: cannot close file ", stderr);

			ut_print_filename(stderr, node->name);

			fprintf(stderr,

				", because mod_count %ld != fl_count %ld\n",

				(long) node->modification_counter,

				(long) node->flush_counter);

		}

		node = UT_LIST_GET_PREV(LRU, node);

	}

	return(FALSE);

}

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

Reserves the fil_system mutex and tries to make sure we can open at least one

file while holding it. This should be called before calling

fil_node_prepare_for_io(), because that function may need to open a file. */

static

void

fil_mutex_enter_and_prepare_for_io(

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

	ulint	space_id)	/* in: space id */

{

	fil_system_t*	system		= fil_system;

	fil_space_t*	space;

	ibool		success;

	ibool		print_info	= FALSE;

	ulint		count		= 0;

	ulint		count2		= 0;

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

retry:

	mutex_enter(&(system->mutex));

	if (space_id == 0 || space_id >= SRV_LOG_SPACE_FIRST_ID) {

		/* We keep log files and system tablespace files always open;

		this is important in preventing deadlocks in this module, as

		a page read completion often performs another read from the

		insert buffer. The insert buffer is in tablespace 0, and we

		cannot end up waiting in this function. */

		return;

	}

	if (system->n_open < system->max_n_open) {

		return;

	}

	HASH_SEARCH(hash, system->spaces, space_id, space,

		    space->id == space_id);

	if (space != NULL && space->stop_ios) {

		/* We are going to do a rename file and want to stop new i/o's

		for a while */

		if (count2 > 20000) {

			fputs("InnoDB: Warning: tablespace ", stderr);

			ut_print_filename(stderr, space->name);

			fprintf(stderr,

				" has i/o ops stopped for a long time %lu\n",

				(ulong) count2);

		}

		mutex_exit(&(system->mutex));

		os_thread_sleep(20000);

		count2++;

		goto retry;

	}

	/* If the file is already open, no need to do anything; if the space

	does not exist, we handle the situation in the function which called

	this function */

	if (!space || UT_LIST_GET_FIRST(space->chain)->open) {

		return;

	}

	if (count > 1) {

		print_info = TRUE;

	}

	/* Too many files are open, try to close some */

close_more:

	success = fil_try_to_close_file_in_LRU(print_info);

	if (success && system->n_open >= system->max_n_open) {

		goto close_more;

	}

	if (system->n_open < system->max_n_open) {

		/* Ok */

		return;

	}

	if (count >= 2) {

		ut_print_timestamp(stderr);

		fprintf(stderr,

			"  InnoDB: Warning: too many (%lu) files stay open"

			" while the maximum\n"

			"InnoDB: allowed value would be %lu.\n"

			"InnoDB: You may need to raise the value of"

			" innodb_max_files_open in\n"

			"InnoDB: my.cnf.\n",

			(ulong) system->n_open, (ulong) system->max_n_open);

		return;

	}

	mutex_exit(&(system->mutex));

#ifndef UNIV_HOTBACKUP

	/* Wake the i/o-handler threads to make sure pending i/o's are

	performed */

	os_aio_simulated_wake_handler_threads();

	os_thread_sleep(20000);

#endif

	/* Flush tablespaces so that we can close modified files in the LRU

	list */

	fil_flush_file_spaces(FIL_TABLESPACE);

	count++;

	goto retry;

}

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

Frees a file node object from a tablespace memory cache. */

static

void

fil_node_free(

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

	fil_node_t*	node,	/* in, own: file node */

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

	fil_space_t*	space)	/* in: space where the file node is chained */

{

	ut_ad(node && system && space);

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

	ut_a(node->magic_n == FIL_NODE_MAGIC_N);

	ut_a(node->n_pending == 0);

	if (node->open) {

		/* We fool the assertion in fil_node_close_file() to think

		there are no unflushed modifications in the file */

		node->modification_counter = node->flush_counter;

		if (space->is_in_unflushed_spaces

		    && fil_space_is_flushed(space)) {

			space->is_in_unflushed_spaces = FALSE;

			UT_LIST_REMOVE(unflushed_spaces,

				       system->unflushed_spaces,

				       space);

		}

		fil_node_close_file(node, system);

	}

	space->size -= node->size;

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

	mem_free(node->name);

	mem_free(node);

}

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