SOURCES (MYSQL_5_0): mysql-xtrabackup.patch (NEW) - revision 1 from lp:~per...

glen glen at pld-linux.org
Tue Mar 3 01:24:08 CET 2009


Author: glen                         Date: Tue Mar  3 00:24:08 2009 GMT
Module: SOURCES                       Tag: MYSQL_5_0
---- Log message:
- revision 1 from lp:~percona-dev/percona-xtrabackup/xtrabackup-prototype

---- Files affected:
SOURCES:
   mysql-xtrabackup.patch (NONE -> 1.1.2.1)  (NEW)

---- Diffs:

================================================================
Index: SOURCES/mysql-xtrabackup.patch
diff -u /dev/null SOURCES/mysql-xtrabackup.patch:1.1.2.1
--- /dev/null	Tue Mar  3 01:24:09 2009
+++ SOURCES/mysql-xtrabackup.patch	Tue Mar  3 01:24:03 2009
@@ -0,0 +1,2060 @@
+--- mysql-5.0.75/innobase/log/log0recv.c        2008-12-19 02:19:36.000000000 +0900
++++ mysql-5.0.75_1/innobase/log/log0recv.c      2009-02-27 19:41:07.000000000 +0900
+@@ -479,7 +479,7 @@
+
+ /************************************************************
+ Looks for the maximum consistent checkpoint from the log groups. */
+-static
++//static
+ ulint
+ recv_find_max_checkpoint(
+ /*=====================*/
+@@ -644,7 +644,7 @@
+ Checks the 4-byte checksum to the trailer checksum field of a log block.
+ We also accept a log block in the old format < InnoDB-3.23.52 where the
+ checksum field contains the log block number. */
+-static
++//static
+ ibool
+ log_block_checksum_is_ok_or_old_format(
+ /*===================================*/
+
+--- mysql-5.0.75/innobase/os/os0file.c  2008-12-19 02:19:36.000000000 +0900
++++ mysql-5.0.75_1/innobase/os/os0file.c        2009-02-26 11:54:47.000000000 +0900
+@@ -435,7 +435,7 @@
+ }
+
+ #undef USE_FILE_LOCK
+-#define USE_FILE_LOCK
++//#define USE_FILE_LOCK
+ #if defined(UNIV_HOTBACKUP) || defined(__WIN__) || defined(__NETWARE__)
+ /* InnoDB Hot Backup does not lock the data files.
+  * On Windows, mandatory locking is used.
+
+--- mysql-5.0.75/innobase/srv/srv0start.c       2008-12-19 02:19:37.000000000 +0900
++++ mysql-5.0.75_1/innobase/srv/srv0start.c     2009-02-26 11:48:30.000000000 +0900
+@@ -547,7 +547,7 @@
+ #ifndef UNIV_HOTBACKUP
+ /*************************************************************************
+ Creates or opens the log files and closes them. */
+-static
++//static
+ ulint
+ open_or_create_log_file(
+ /*====================*/
+@@ -693,7 +693,7 @@
+
+ /*************************************************************************
+ Creates or opens database data files and closes them. */
+-static
++//static
+ ulint
+ open_or_create_data_files(
+ /*======================*/
+--- /dev/null	2006-03-28 14:00:37.000000000 +0300
++++ mysql-5.0.75/innobase/xtrabackup/Makefile	2009-03-02 17:54:29.089780153 +0200
+@@ -0,0 +1,32 @@
++LIBS=	-lpthread -lrt
++DEFS=	-DUNIV_LINUX -DMYSQL_SERVER
++
++#x86_32
++CFLAGS=	-O2 -g -fmessage-length=0 -D_FORTIFY_SOURCE=2
++
++#5.0
++INC=	-I. -I.. -I./../include -I./../../include
++INNODBOBJS=	../usr/libusr.a ../srv/libsrv.a ../dict/libdict.a ../que/libque.a\
++		../srv/libsrv.a ../ibuf/libibuf.a ../row/librow.a ../pars/libpars.a\
++		../btr/libbtr.a ../trx/libtrx.a ../read/libread.a ../usr/libusr.a\
++		../buf/libbuf.a ../ibuf/libibuf.a ../eval/libeval.a ../log/liblog.a\
++		../fsp/libfsp.a ../fut/libfut.a ../fil/libfil.a ../lock/liblock.a\
++		../mtr/libmtr.a ../page/libpage.a ../rem/librem.a ../thr/libthr.a\
++		../sync/libsync.a ../data/libdata.a ../mach/libmach.a ../ha/libha.a\
++		../dyn/libdyn.a ../mem/libmem.a ../sync/libsync.a ../ut/libut.a\
++		../os/libos.a ../ut/libut.a
++MYSQLOBJS=	../../mysys/libmysys.a ../../strings/libmystrings.a
++
++.SUFFIXES: .o .c
++
++.c.o:
++	$(CC) $(CFLAGS) $(INC) $(DEFS) -c $*.c
++
++all: xtrabackup
++
++xtrabackup : xtrabackup.o $(INNODBOBJS) $(MYSQLOBJS)
++	$(CC) xtrabackup.o $(INNODBOBJS) $(MYSQLOBJS) $(LIBS) -o xtrabackup
++
++clean:
++	rm -f *.o xtrabackup
++
+--- /dev/null	2006-03-28 14:00:37.000000000 +0300
++++ mysql-5.0.75/innobase/xtrabackup/xtrabackup.c	2009-03-02 17:54:29.086446549 +0200
+@@ -0,0 +1,1969 @@
++#define XTRABACKUP_VERSION "prototype-0.0"
++
++//#define XTRABACKUP_TARGET_IS_PLUGIN
++
++#include <my_base.h>
++#include <my_getopt.h>
++#include <mysql_version.h>
++
++#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>
++
++/* ==start === definition at fil0fil.c === */
++
++/* 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 */
++};
++extern fil_system_t*   fil_system;
++
++/* ==end=== definition  at fil0fil.c === */
++
++
++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_prepare = FALSE;
++
++my_bool xtrabackup_suspend_at_end = FALSE;
++longlong xtrabackup_use_memory = 8*1024*1024L;
++
++long xtrabackup_throttle = 0; /* 0:unlimited */
++my_bool xtrabackup_stream = FALSE;
++
++static ulint		n[SRV_MAX_N_IO_THREADS + 5];
++static os_thread_id_t	thread_ids[SRV_MAX_N_IO_THREADS + 5];
++
++dulint checkpoint_lsn_start;
++dulint checkpoint_no_start;
++dulint log_copy_scanned_lsn;
++ib_longlong log_copy_offset = 0;
++ibool log_copying = TRUE;
++ibool log_copying_running = FALSE;
++ibool log_copying_succeed = FALSE;
++
++/* === 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_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_mirrored_log_groups = 1;
++long innobase_open_files = 300L;
++
++longlong innobase_buffer_pool_size = 8*1024*1024L;
++longlong innobase_log_file_size = 5*1024*1024L;
++
++/* 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_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			= 0;
++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;
++
++
++/* ======== for option and variables ======== */
++
++enum options_xtrabackup
++{
++  OPT_XTRA_TARGET_DIR=256,
++  OPT_XTRA_BACKUP,
++  OPT_XTRA_PREPARE,
++  OPT_XTRA_SUSPEND_AT_END,
++  OPT_XTRA_USE_MEMORY,
++  OPT_XTRA_THROTTLE,
++  OPT_XTRA_STREAM,
++  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,
++  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
++};
++
++static struct my_option my_long_options[] =
++{
++  {"target-dir", OPT_XTRA_TARGET_DIR, "destination directory", (gptr*) &xtrabackup_target_dir,
++   (gptr*) &xtrabackup_target_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
++  {"backup", OPT_XTRA_BACKUP, "take backup to target-dir",
++   (gptr*) &xtrabackup_backup, (gptr*) &xtrabackup_backup,
++   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
++  {"prepare", OPT_XTRA_PREPARE, "prepare a backup for starting mysql server on the backup.",
++   (gptr*) &xtrabackup_prepare, (gptr*) &xtrabackup_prepare,
++   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
++  {"use-memory", OPT_XTRA_USE_MEMORY, "** nothing for now (planned to use instead of buffer_pool_size) **",
++   (gptr*) &xtrabackup_use_memory, (gptr*) &xtrabackup_use_memory,
++   0, GET_LL, REQUIRED_ARG, 8*1024*1024L, 1024*1024L, LONGLONG_MAX, 0,
++   1024*1024L, 0},
++  {"suspend-at-end", OPT_XTRA_SUSPEND_AT_END, "creates a file 'xtrabackup_suspended' and waits until the user deletes that file at the end of '--backup'",
++   (gptr*) &xtrabackup_suspend_at_end, (gptr*) &xtrabackup_suspend_at_end,
++   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
++  {"throttle", OPT_XTRA_THROTTLE, "limit count of IO operations per second to IOS values",
++   (gptr*) &xtrabackup_throttle, (gptr*) &xtrabackup_throttle,
++   0, GET_LONG, REQUIRED_ARG, 0, 0, LONG_MAX, 0, 1, 0},
++  {"stream", OPT_XTRA_STREAM, "** nothing for now **",
++   (gptr*) &xtrabackup_stream, (gptr*) &xtrabackup_stream,
++   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
++
++  {"datadir", 'h', "Path to the database root.", (gptr*) &mysql_data_home,
++   (gptr*) &mysql_data_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
++  {"tmpdir", 't',
++   "Path for temporary files. Several paths may be specified, separated by a "
++#if defined(__WIN__) || defined(OS2) || defined(__NETWARE__)
++   "semicolon (;)"
++#else
++   "colon (:)"
++#endif
++   ", in this case they are used in a round-robin fashion.",
++   (gptr*) &opt_mysql_tmpdir,
++   (gptr*) &opt_mysql_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
++
++  {"innodb_adaptive_hash_index", OPT_INNODB_ADAPTIVE_HASH_INDEX,
++   "Enable InnoDB adaptive hash index (enabled by default).  "
++   "Disable with --skip-innodb-adaptive-hash-index.",
++   (gptr*) &innobase_adaptive_hash_index,
++   (gptr*) &innobase_adaptive_hash_index,
++   0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
++  {"innodb_additional_mem_pool_size", OPT_INNODB_ADDITIONAL_MEM_POOL_SIZE,
++   "Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.",
++   (gptr*) &innobase_additional_mem_pool_size,
++   (gptr*) &innobase_additional_mem_pool_size, 0, GET_LONG, REQUIRED_ARG,
++   1*1024*1024L, 512*1024L, LONG_MAX, 0, 1024, 0},
++  {"innodb_autoextend_increment", OPT_INNODB_AUTOEXTEND_INCREMENT,
++   "Data file autoextend increment in megabytes",
++   (gptr*) &srv_auto_extend_increment,
++   (gptr*) &srv_auto_extend_increment,
++   0, GET_ULONG, REQUIRED_ARG, 8L, 1L, 1000L, 0, 1L, 0},
++  {"innodb_buffer_pool_size", OPT_INNODB_BUFFER_POOL_SIZE,
++   "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
++   (gptr*) &innobase_buffer_pool_size, (gptr*) &innobase_buffer_pool_size, 0,
++   GET_LL, REQUIRED_ARG, 8*1024*1024L, 1024*1024L, LONGLONG_MAX, 0,
++   1024*1024L, 0},
++  {"innodb_checksums", OPT_INNODB_CHECKSUMS, "Enable InnoDB checksums validation (enabled by default). \
++Disable with --skip-innodb-checksums.", (gptr*) &innobase_use_checksums,
++   (gptr*) &innobase_use_checksums, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
++/*
++  {"innodb_commit_concurrency", OPT_INNODB_COMMIT_CONCURRENCY,
++   "Helps in performance tuning in heavily concurrent environments.",
++   (gptr*) &srv_commit_concurrency, (gptr*) &srv_commit_concurrency,
++   0, GET_ULONG, REQUIRED_ARG, 0, 0, 1000, 0, 1, 0},
++*/
++/*
++  {"innodb_concurrency_tickets", OPT_INNODB_CONCURRENCY_TICKETS,
++   "Number of times a thread is allowed to enter InnoDB within the same \
++    SQL query after it has once got the ticket",
++   (gptr*) &srv_n_free_tickets_to_enter,
++   (gptr*) &srv_n_free_tickets_to_enter,
++   0, GET_ULONG, REQUIRED_ARG, 500L, 1L, ULONG_MAX, 0, 1L, 0},
++*/
++  {"innodb_data_file_path", OPT_INNODB_DATA_FILE_PATH,
++   "Path to individual files and their sizes.", (gptr*) &innobase_data_file_path,
++   (gptr*) &innobase_data_file_path, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
++  {"innodb_data_home_dir", OPT_INNODB_DATA_HOME_DIR,
++   "The common part for InnoDB table spaces.", (gptr*) &innobase_data_home_dir,
++   (gptr*) &innobase_data_home_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0,
++   0},
++  {"innodb_doublewrite", OPT_INNODB_DOUBLEWRITE, "Enable InnoDB doublewrite buffer (enabled by default). \
++Disable with --skip-innodb-doublewrite.", (gptr*) &innobase_use_doublewrite,
++   (gptr*) &innobase_use_doublewrite, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
++/*
++  {"innodb_fast_shutdown", OPT_INNODB_FAST_SHUTDOWN,
++   "Speeds up the shutdown process of the InnoDB storage engine. Possible "
++   "values are 0, 1 (faster)"
++   " or 2 (fastest - crash-like)"
++   ".",
++   (gptr*) &innobase_fast_shutdown,
++   (gptr*) &innobase_fast_shutdown, 0, GET_ULONG, OPT_ARG, 1, 0,
++   2, 0, 0, 0},
++*/
++  {"innodb_file_io_threads", OPT_INNODB_FILE_IO_THREADS,
++   "Number of file I/O threads in InnoDB.", (gptr*) &innobase_file_io_threads,
++   (gptr*) &innobase_file_io_threads, 0, GET_LONG, REQUIRED_ARG, 4, 4, 64, 0,
++   1, 0},
++  {"innodb_file_per_table", OPT_INNODB_FILE_PER_TABLE,
++   "Stores each InnoDB table to an .ibd file in the database dir.",
++   (gptr*) &innobase_file_per_table,
++   (gptr*) &innobase_file_per_table, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
++  {"innodb_flush_log_at_trx_commit", OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT,
++   "Set to 0 (write and flush once per second), 1 (write and flush at each commit) or 2 (write at commit, flush once per second).",
++   (gptr*) &srv_flush_log_at_trx_commit,
++   (gptr*) &srv_flush_log_at_trx_commit,
++   0, GET_ULONG, OPT_ARG,  1, 0, 2, 0, 0, 0},
++  {"innodb_flush_method", OPT_INNODB_FLUSH_METHOD,
++   "With which method to flush data.", (gptr*) &innobase_unix_file_flush_method,
++   (gptr*) &innobase_unix_file_flush_method, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
++   0, 0, 0},
++
++/* ####### Should we use this option? ####### */
++  {"innodb_force_recovery", OPT_INNODB_FORCE_RECOVERY,
++   "Helps to save your data in case the disk image of the database becomes corrupt.",
++   (gptr*) &innobase_force_recovery, (gptr*) &innobase_force_recovery, 0,
++   GET_LONG, REQUIRED_ARG, 0, 0, 6, 0, 1, 0},
++
++  {"innodb_lock_wait_timeout", OPT_INNODB_LOCK_WAIT_TIMEOUT,
++   "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back.",
++   (gptr*) &innobase_lock_wait_timeout, (gptr*) &innobase_lock_wait_timeout,
++   0, GET_LONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},
++/*
++  {"innodb_locks_unsafe_for_binlog", OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,
++   "Force InnoDB not to use next-key locking. Instead use only row-level locking",
++   (gptr*) &innobase_locks_unsafe_for_binlog,
++   (gptr*) &innobase_locks_unsafe_for_binlog, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
++*/
++/*
++  {"innodb_log_arch_dir", OPT_INNODB_LOG_ARCH_DIR,
++   "Where full logs should be archived.", (gptr*) &innobase_log_arch_dir,
++   (gptr*) &innobase_log_arch_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
++*/
++  {"innodb_log_buffer_size", OPT_INNODB_LOG_BUFFER_SIZE,
++   "The size of the buffer which InnoDB uses to write log to the log files on disk.",
++   (gptr*) &innobase_log_buffer_size, (gptr*) &innobase_log_buffer_size, 0,
++   GET_LONG, REQUIRED_ARG, 1024*1024L, 256*1024L, LONG_MAX, 0, 1024, 0},
++  {"innodb_log_file_size", OPT_INNODB_LOG_FILE_SIZE,
++   "Size of each log file in a log group.",
++   (gptr*) &innobase_log_file_size, (gptr*) &innobase_log_file_size, 0,
++   GET_LL, REQUIRED_ARG, 5*1024*1024L, 1*1024*1024L, LONGLONG_MAX, 0,
++   1024*1024L, 0},
++  {"innodb_log_files_in_group", OPT_INNODB_LOG_FILES_IN_GROUP,
++   "Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
++   (gptr*) &innobase_log_files_in_group, (gptr*) &innobase_log_files_in_group,
++   0, GET_LONG, REQUIRED_ARG, 2, 2, 100, 0, 1, 0},
++  {"innodb_log_group_home_dir", OPT_INNODB_LOG_GROUP_HOME_DIR,
++   "Path to InnoDB log files.", (gptr*) &innobase_log_group_home_dir,
++   (gptr*) &innobase_log_group_home_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0,
++   0, 0},
++  {"innodb_max_dirty_pages_pct", OPT_INNODB_MAX_DIRTY_PAGES_PCT,
++   "Percentage of dirty pages allowed in bufferpool.", (gptr*) &srv_max_buf_pool_modified_pct,
++   (gptr*) &srv_max_buf_pool_modified_pct, 0, GET_ULONG, REQUIRED_ARG, 90, 0, 100, 0, 0, 0},
++/*
++  {"innodb_max_purge_lag", OPT_INNODB_MAX_PURGE_LAG,
++   "Desired maximum length of the purge queue (0 = no limit)",
++   (gptr*) &srv_max_purge_lag,
++   (gptr*) &srv_max_purge_lag, 0, GET_ULONG, REQUIRED_ARG, 0, 0, ULONG_MAX,
++   0, 1L, 0},
++*/
++/*
++  {"innodb_mirrored_log_groups", OPT_INNODB_MIRRORED_LOG_GROUPS,
++   "Number of identical copies of log groups we keep for the database. Currently this should be set to 1.",
++   (gptr*) &innobase_mirrored_log_groups,
++   (gptr*) &innobase_mirrored_log_groups, 0, GET_LONG, REQUIRED_ARG, 1, 1, 10,
++   0, 1, 0},
++*/
++  {"innodb_open_files", OPT_INNODB_OPEN_FILES,
++   "How many files at the maximum InnoDB keeps open at the same time.",
++   (gptr*) &innobase_open_files, (gptr*) &innobase_open_files, 0,
++   GET_LONG, REQUIRED_ARG, 300L, 10L, LONG_MAX, 0, 1L, 0},
++/*
++  {"innodb_rollback_on_timeout", OPT_INNODB_ROLLBACK_ON_TIMEOUT,
++   "Roll back the complete transaction on lock wait timeout, for 4.x compatibility (disabled by default)",
++   (gptr*) &innobase_rollback_on_timeout, (gptr*) &innobase_rollback_on_timeout,
++   0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
++*/
++/*
++  {"innodb_status_file", OPT_INNODB_STATUS_FILE,
++   "Enable SHOW INNODB STATUS output in the innodb_status.<pid> file",
<<Diff was trimmed, longer than 597 lines>>


More information about the pld-cvs-commit mailing list