~percona-dev/percona-xtrabackup/added_custom_version

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

XtraBackup: The another hot backup tool for InnoDB

(c) 2009 Percona Inc.

Created 3/3/2009 Yasufumi Kinoshita

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

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

#ifndef XTRABACKUP_VERSION

#define XTRABACKUP_VERSION "undefined"

#endif

#ifndef XTRABACKUP_REVISION

#define XTRABACKUP_REVISION "undefined"

#endif

//#define XTRABACKUP_TARGET_IS_PLUGIN

#include <my_base.h>

#include <my_getopt.h>

#include <mysql_version.h>

#include <mysql_com.h>

#if (MYSQL_VERSION_ID < 50100)

#define G_PTR gptr

#else /* MYSQL_VERSION_ID < 51000 */

#define G_PTR uchar*

#endif

#include <univ.i>

#include <os0file.h>

#include <os0thread.h>

#include <srv0start.h>

#include <srv0srv.h>

#include <trx0roll.h>

#include <trx0trx.h>

#include <trx0sys.h>

#include <mtr0mtr.h>

#include <row0ins.h>

#include <row0mysql.h>

#include <row0sel.h>

#include <row0upd.h>

#include <log0log.h>

#include <lock0lock.h>

#include <dict0crea.h>

#include <btr0cur.h>

#include <btr0btr.h>

#include <fsp0fsp.h>

#include <sync0sync.h>

#include <fil0fil.h>

#include <trx0xa.h>

#ifdef INNODB_VERSION_SHORT

#include <ibuf0ibuf.h>

#endif

#ifndef INNODB_VERSION_SHORT

#define IB_INT64 ib_longlong

#define LSN64 dulint

#define MACH_READ_64 mach_read_from_8

#define MACH_WRITE_64 mach_write_to_8

#define OS_MUTEX_CREATE() os_mutex_create(NULL)

#else

#define IB_INT64 ib_int64_t

#define LSN64 ib_uint64_t

#if (MYSQL_VERSION_ID < 50500)

#define MACH_READ_64 mach_read_ull

#define MACH_WRITE_64 mach_write_ull

#define OS_MUTEX_CREATE() os_mutex_create(NULL)

#else

#define MACH_READ_64 mach_read_from_8

#define MACH_WRITE_64 mach_write_to_8

#define OS_MUTEX_CREATE() os_mutex_create()

#endif

#define ut_dulint_zero 0

#define ut_dulint_cmp(A, B) (A > B ? 1 : (A == B ? 0 : -1))

#define ut_dulint_add(A, B) (A + B)

#define ut_dulint_minus(A, B) (A - B)

#define ut_dulint_align_down(A, B) (A & ~((ib_int64_t)B - 1))

#define ut_dulint_align_up(A, B) ((A + B - 1) & ~((ib_int64_t)B - 1))

#endif

#ifdef __WIN__

#define SRV_PATH_SEPARATOR	'\\'

#define SRV_PATH_SEPARATOR_STR	"\\"	

#else

#define SRV_PATH_SEPARATOR	'/'

#define SRV_PATH_SEPARATOR_STR	"/"

#endif

#ifndef UNIV_PAGE_SIZE_MAX

#define UNIV_PAGE_SIZE_MAX UNIV_PAGE_SIZE

#endif

#ifndef UNIV_PAGE_SIZE_SHIFT_MAX

#define UNIV_PAGE_SIZE_SHIFT_MAX UNIV_PAGE_SIZE_SHIFT

#endif

#if MYSQL_VERSION_ID >= 50507

/*

   As of MySQL 5.5.7, InnoDB uses thd_wait plugin service.

   We have to provide mock functions to avoid linker errors.

*/

#include <mysql/plugin.h>

#include <mysql/service_thd_wait.h>

void thd_wait_begin(MYSQL_THD thd, thd_wait_type wait_type)

{

	return;

}

void thd_wait_end(MYSQL_THD thd)

{

	return;

}

#endif /* MYSQL_VERSION_ID >= 50507 */

/* prototypes for static functions in original */

#ifndef INNODB_VERSION_SHORT

page_t*

btr_node_ptr_get_child(

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

				/* out: child page, x-latched */

	rec_t*		node_ptr,/* in: node pointer */

	const ulint*	offsets,/* in: array returned by rec_get_offsets() */

	mtr_t*		mtr);	/* in: mtr */

#else

buf_block_t*

btr_node_ptr_get_child(

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

	const rec_t*	node_ptr,/*!< in: node pointer */

	dict_index_t*	index,	/*!< in: index */

	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */

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

buf_block_t*

btr_root_block_get(

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

	dict_index_t*	index,	/*!< in: index tree */

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

#endif

int

fil_file_readdir_next_file(

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

				/* out: 0 if ok, -1 if error even after the

				retries, 1 if at the end of the directory */

	ulint*		err,	/* out: this is set to DB_ERROR if an error

				was encountered, otherwise not changed */

	const char*	dirname,/* in: directory name or path */

	os_file_dir_t	dir,	/* in: directory stream */

	os_file_stat_t*	info);	/* in/out: buffer where the info is returned */

ibool

recv_check_cp_is_consistent(

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

			/* out: TRUE if ok */

	byte*	buf);	/* in: buffer containing checkpoint info */

ulint

recv_find_max_checkpoint(

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

					/* out: error code or DB_SUCCESS */

	log_group_t**	max_group,	/* out: max group */

	ulint*		max_field);	/* out: LOG_CHECKPOINT_1 or

					LOG_CHECKPOINT_2 */

ibool

log_block_checksum_is_ok_or_old_format(

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

			/* out: TRUE if ok, or if the log block may be in the

			format of InnoDB version < 3.23.52 */

	byte*	block);	/* in: pointer to a log block */

ulint

open_or_create_log_file(

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

					/* out: DB_SUCCESS or error code */

        ibool   create_new_db,          /* in: TRUE if we should create a

                                        new database */

	ibool*	log_file_created,	/* out: TRUE if new log file

					created */

	ibool	log_file_has_been_opened,/* in: TRUE if a log file has been

					opened before: then it is an error

					to try to create another log file */

	ulint	k,			/* in: log group number */

	ulint	i);			/* in: log file number in group */

ulint

open_or_create_data_files(

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

				/* out: DB_SUCCESS or error code */

	ibool*	create_new_db,	/* out: TRUE if new database should be

								created */

#ifdef XTRADB_BASED

	ibool*	create_new_doublewrite_file,

#endif 

#ifdef UNIV_LOG_ARCHIVE

	ulint*	min_arch_log_no,/* out: min of archived log numbers in data

				files */

	ulint*	max_arch_log_no,/* out: */

#endif /* UNIV_LOG_ARCHIVE */

	LSN64*	min_flushed_lsn,/* out: min of flushed lsn values in data

				files */

	LSN64*	max_flushed_lsn,/* out: */

	ulint*	sum_of_new_sizes);/* out: sum of sizes of the new files added */

void

os_file_set_nocache(

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

	int		fd,		/* in: file descriptor to alter */

	const char*	file_name,	/* in: used in the diagnostic message */

	const char*	operation_name);	/* in: used in the diagnostic message,

					we call os_file_set_nocache()

					immediately after opening or creating

					a file, so this is either "open" or

					"create" */

#include <fcntl.h>

#include <regex.h>

#ifdef POSIX_FADV_NORMAL

#define USE_POSIX_FADVISE

#endif

/* ==start === definition at fil0fil.c === */

// ##################################################################

// NOTE: We should check the following definitions fit to the source.

// ##################################################################

#ifndef INNODB_VERSION_SHORT

//5.0 5.1

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

};

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;

};

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

};

#else

//Plugin ?

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

};

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

#ifdef XTRADB_BASED

	ibool		is_corrupt;

#endif

	UT_LIST_NODE_T(fil_space_t) space_list;

				/*!< list of all spaces */

	ulint		magic_n;/*!< FIL_SPACE_MAGIC_N */

};

typedef	struct fil_system_struct	fil_system_t;

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

};

#endif /* INNODB_VERSION_SHORT */

typedef struct {

	ulint	page_size;

} xb_delta_info_t;

extern fil_system_t*   fil_system;

/* ==end=== definition  at fil0fil.c === */

my_bool innodb_inited= 0;

/* === xtrabackup specific options === */

char xtrabackup_real_target_dir[FN_REFLEN] = "./xtrabackup_backupfiles/";

char *xtrabackup_target_dir= xtrabackup_real_target_dir;

my_bool xtrabackup_backup = FALSE;

my_bool xtrabackup_stats = FALSE;

my_bool xtrabackup_prepare = FALSE;

my_bool xtrabackup_print_param = FALSE;

my_bool xtrabackup_export = FALSE;

my_bool xtrabackup_apply_log_only = FALSE;

my_bool xtrabackup_suspend_at_end = FALSE;

longlong xtrabackup_use_memory = 100*1024*1024L;

my_bool xtrabackup_create_ib_logfile = FALSE;

long xtrabackup_throttle = 0; /* 0:unlimited */

lint io_ticket;

os_event_t wait_throttle = NULL;

my_bool xtrabackup_stream = FALSE;

char *xtrabackup_incremental = NULL;

LSN64 incremental_lsn;

LSN64 incremental_to_lsn;

LSN64 incremental_last_lsn;

byte* incremental_buffer = NULL;

byte* incremental_buffer_base = NULL;

char *xtrabackup_incremental_basedir = NULL; /* for --backup */

char *xtrabackup_extra_lsndir = NULL; /* for --backup with --extra-lsndir */

char *xtrabackup_incremental_dir = NULL; /* for --prepare */

char *xtrabackup_tables = NULL;

int tables_regex_num;

regex_t *tables_regex;

regmatch_t tables_regmatch[1];

char *xtrabackup_tables_file = NULL;

hash_table_t* tables_hash;

struct xtrabackup_tables_struct{

	char*		name;

	hash_node_t	name_hash;

};

typedef struct xtrabackup_tables_struct	xtrabackup_tables_t;

#ifdef XTRADB_BASED

static ulint		n[SRV_MAX_N_IO_THREADS + 6 + 64];

static os_thread_id_t	thread_ids[SRV_MAX_N_IO_THREADS + 6 + 64];

#else

static ulint		n[SRV_MAX_N_IO_THREADS + 6];

static os_thread_id_t	thread_ids[SRV_MAX_N_IO_THREADS + 6];

#endif

LSN64 checkpoint_lsn_start;

LSN64 checkpoint_no_start;

LSN64 log_copy_scanned_lsn;

IB_INT64 log_copy_offset = 0;

ibool log_copying = TRUE;

ibool log_copying_running = FALSE;

ibool log_copying_succeed = FALSE;

ibool xtrabackup_logfile_is_renamed = FALSE;

uint parallel;

/* === metadata of backup === */

#define XTRABACKUP_METADATA_FILENAME "xtrabackup_checkpoints"

char metadata_type[30] = ""; /*[full-backuped|full-prepared|incremental]*/

#ifndef INNODB_VERSION_SHORT

dulint metadata_from_lsn = {0, 0};

dulint metadata_to_lsn = {0, 0};

dulint metadata_last_lsn = {0, 0};

#else

ib_uint64_t metadata_from_lsn = 0;

ib_uint64_t metadata_to_lsn = 0;

ib_uint64_t metadata_last_lsn = 0;

#endif

#define XB_DELTA_INFO_SUFFIX ".meta"

/* === sharing with thread === */

os_file_t       dst_log = -1;

char            dst_log_path[FN_REFLEN];

/* === some variables from mysqld === */

char mysql_real_data_home[FN_REFLEN] = "./";

char *mysql_data_home= mysql_real_data_home;

static char mysql_data_home_buff[2];

char *opt_mysql_tmpdir = NULL;

MY_TMPDIR mysql_tmpdir_list;

/* === static parameters in ha_innodb.cc */

#define HA_INNOBASE_ROWS_IN_TABLE 10000 /* to get optimization right */

#define HA_INNOBASE_RANGE_COUNT	  100

ulong 	innobase_large_page_size = 0;

/* The default values for the following, type long or longlong, start-up

parameters are declared in mysqld.cc: */

long innobase_additional_mem_pool_size = 1*1024*1024L;

long innobase_buffer_pool_awe_mem_mb = 0;

long innobase_file_io_threads = 4;

long innobase_read_io_threads = 4;

long innobase_write_io_threads = 4;

long innobase_force_recovery = 0;

long innobase_lock_wait_timeout = 50;

long innobase_log_buffer_size = 1024*1024L;

long innobase_log_files_in_group = 2;

long innobase_log_files_in_group_backup;

long innobase_mirrored_log_groups = 1;

long innobase_open_files = 300L;

long innobase_page_size = (1 << 14); /* 16KB */

my_bool innobase_fast_checksum = FALSE;

my_bool	innobase_extra_undoslots = FALSE;

char*	innobase_doublewrite_file = NULL;

longlong innobase_buffer_pool_size = 8*1024*1024L;

longlong innobase_log_file_size = 5*1024*1024L;

longlong innobase_log_file_size_backup;

/* The default values for the following char* start-up parameters

are determined in innobase_init below: */

char*	innobase_data_home_dir			= NULL;

char*	innobase_data_file_path 		= NULL;

char*	innobase_log_group_home_dir		= NULL;

char*	innobase_log_group_home_dir_backup	= NULL;

char*	innobase_log_arch_dir			= NULL;/* unused */

/* The following has a misleading name: starting from 4.0.5, this also

affects Windows: */

char*	innobase_unix_file_flush_method		= NULL;

/* Below we have boolean-valued start-up parameters, and their default

values */

ulong	innobase_fast_shutdown			= 1;

my_bool innobase_log_archive			= FALSE;/* unused */

my_bool innobase_use_doublewrite    = TRUE;

my_bool innobase_use_checksums      = TRUE;

my_bool innobase_use_large_pages    = FALSE;

my_bool	innobase_use_native_aio			= FALSE;

my_bool	innobase_file_per_table			= FALSE;

my_bool innobase_locks_unsafe_for_binlog        = FALSE;

my_bool innobase_rollback_on_timeout		= FALSE;

my_bool innobase_create_status_file		= FALSE;

my_bool innobase_adaptive_hash_index		= TRUE;

static char *internal_innobase_data_file_path	= NULL;

/* The following counter is used to convey information to InnoDB

about server activity: in selects it is not sensible to call

srv_active_wake_master_thread after each fetch or search, we only do

it every INNOBASE_WAKE_INTERVAL'th step. */

#define INNOBASE_WAKE_INTERVAL	32

ulong	innobase_active_counter	= 0;

/* ======== Datafiles iterator ======== */

typedef struct {

	fil_system_t *system;

	fil_space_t  *space;

	fil_node_t   *node;

	ibool        started;

	os_mutex_t   mutex;

} datafiles_iter_t;

static

datafiles_iter_t *

datafiles_iter_new(fil_system_t *system)

{

	datafiles_iter_t *it;

	it = ut_malloc(sizeof(datafiles_iter_t));

	it->mutex = OS_MUTEX_CREATE();

	it->system = system;

	it->space = NULL;

	it->node = NULL;

	it->started = FALSE;

	return it;

}

static

fil_node_t *

datafiles_iter_next(datafiles_iter_t *it, ibool *space_changed)

{

	os_mutex_enter(it->mutex);

	*space_changed = FALSE;

	if (it->node == NULL) {

		if (it->started)

			goto end;

		it->started = TRUE;

	} else {

		it->node = UT_LIST_GET_NEXT(chain, it->node);

		if (it->node != NULL)

			goto end;

	}

	it->space = (it->space == NULL) ?

		UT_LIST_GET_FIRST(it->system->space_list) :

		UT_LIST_GET_NEXT(space_list, it->space);

	while (it->space != NULL &&

	       (it->space->purpose != FIL_TABLESPACE ||

		UT_LIST_GET_LEN(it->space->chain) == 0))

		it->space = UT_LIST_GET_NEXT(space_list, it->space);

	if (it->space == NULL)

		goto end;

	*space_changed = TRUE;

	it->node = UT_LIST_GET_FIRST(it->space->chain);

end:

	os_mutex_exit(it->mutex);

	return it->node;

}

static

void

datafiles_iter_free(datafiles_iter_t *it)

{

	os_mutex_free(it->mutex);

	ut_free(it);

}

/* ======== Date copying thread context ======== */

typedef struct {

	datafiles_iter_t 	*it;

	uint			num;

	uint			*count;

	os_mutex_t		count_mutex;

	os_thread_id_t		id;

} data_thread_ctxt_t;

/* ======== for option and variables ======== */

enum options_xtrabackup

{

  OPT_XTRA_TARGET_DIR=256,

  OPT_XTRA_BACKUP,

  OPT_XTRA_STATS,

  OPT_XTRA_PREPARE,

  OPT_XTRA_EXPORT,

  OPT_XTRA_APPLY_LOG_ONLY,

  OPT_XTRA_PRINT_PARAM,

  OPT_XTRA_SUSPEND_AT_END,

  OPT_XTRA_USE_MEMORY,

  OPT_XTRA_THROTTLE,

  OPT_XTRA_STREAM,

  OPT_XTRA_INCREMENTAL,

  OPT_XTRA_INCREMENTAL_BASEDIR,

  OPT_XTRA_EXTRA_LSNDIR,

  OPT_XTRA_INCREMENTAL_DIR,

  OPT_XTRA_TABLES,

  OPT_XTRA_TABLES_FILE,

  OPT_XTRA_CREATE_IB_LOGFILE,

  OPT_XTRA_PARALLEL,

  OPT_INNODB_CHECKSUMS,

  OPT_INNODB_DATA_FILE_PATH,

  OPT_INNODB_DATA_HOME_DIR,

  OPT_INNODB_ADAPTIVE_HASH_INDEX,

  OPT_INNODB_DOUBLEWRITE,

  OPT_INNODB_FAST_SHUTDOWN,

  OPT_INNODB_FILE_PER_TABLE,

  OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT,

  OPT_INNODB_FLUSH_METHOD,

  OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,

  OPT_INNODB_LOG_ARCH_DIR,

  OPT_INNODB_LOG_ARCHIVE,

  OPT_INNODB_LOG_GROUP_HOME_DIR,

  OPT_INNODB_MAX_DIRTY_PAGES_PCT,

  OPT_INNODB_MAX_PURGE_LAG,

  OPT_INNODB_ROLLBACK_ON_TIMEOUT,

  OPT_INNODB_STATUS_FILE,

  OPT_INNODB_ADDITIONAL_MEM_POOL_SIZE,

  OPT_INNODB_AUTOEXTEND_INCREMENT,

  OPT_INNODB_BUFFER_POOL_SIZE,

  OPT_INNODB_COMMIT_CONCURRENCY,

  OPT_INNODB_CONCURRENCY_TICKETS,

  OPT_INNODB_FILE_IO_THREADS,

#ifdef INNODB_VERSION_SHORT

  OPT_INNODB_IO_CAPACITY,

  OPT_INNODB_READ_IO_THREADS,

  OPT_INNODB_WRITE_IO_THREADS,

#endif

#ifdef XTRADB_BASED

  OPT_INNODB_PAGE_SIZE,

  OPT_INNODB_FAST_CHECKSUM,

  OPT_INNODB_EXTRA_UNDOSLOTS,

  OPT_INNODB_DOUBLEWRITE_FILE,

#endif

  OPT_INNODB_FORCE_RECOVERY,

  OPT_INNODB_LOCK_WAIT_TIMEOUT,

  OPT_INNODB_LOG_BUFFER_SIZE,

  OPT_INNODB_LOG_FILE_SIZE,

  OPT_INNODB_LOG_FILES_IN_GROUP,

  OPT_INNODB_MIRRORED_LOG_GROUPS,

  OPT_INNODB_OPEN_FILES,

  OPT_INNODB_SYNC_SPIN_LOOPS,

  OPT_INNODB_THREAD_CONCURRENCY,

  OPT_INNODB_THREAD_SLEEP_DELAY

};