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