Merge lp:~ihanick/percona-server/5.1-innodb-log_archiving into lp:percona-server/5.1

[Nickolay Ihalainen]

https://blueprints.launchpad.net/percona-server/+spec/log-archiving blueprint implemented.

Based on original Yasufumi work: ~percona-dev/percona-server/5.1.59-innodb_log_archiving

How it works:
1) Additional log archiving thread created inside innodb if log archiving is enabled
2) new transaction log file is created by log archiving script at the start or right after finishing archiving process
3) If active innodb transaction log file is full empty transaction log swapped with the earliest used transaction log file
4) If we have innodb_xtra_log_archive_dir not in the same directory as innodb transaction logs, file move initiated
5) if innodb_xtra_expire_archive_logs_sec is not zero, purge check initiated
6) test case now not using temporary file names and not affected by slow testing environment
7) fixed problems from last MP
8) cross-filesystem archived log renaming

Additionally the patch contains PURGE ARCHIVED LOGS {BEFORE|TO} command and a new handlerton call: purge_archive_logs

Apr 4th:
Fixed problems from last MP:
- Added debug code to check file size on separate filesystem
- use 64bit offsets to copy archived logs
- Implemented and tested IO throttling
- Added innodb variable to control throttling
- use posix_fadvise to prevent caching

Apr 26th:
- fixed indentation and code line lengths
- fixed posix_fadvise usage
- fixed deadlock if archiving enabled dynamically
- Max checkpoint age now increased/decreased on archiving stop/start

Latest test run:
http://jenkins.percona.com/view/Percona%20Server%205.1/job/percona-server-5.1-param/308/

[Laurynas Biveinis (laurynas-biveinis)]

Nickolay -

Overall impression looks good. I have some comments/questions:

What we are going to do when/if UNIV_LOG_ARCHIVE InnoDB log archiving
is enabled upstream? The implementations are not drop-in replacements
for each other (see below), so maybe it's good to prevent potential
user confusion by inventing another name for the XtraDB one?

What is the difference between this implementation and
UNIV_LOG_ARCHIVE anyway? As I see it:
1) this one is simpler and more parallel.
2) UNIV_LOG_ARCHIVE is able to archive up to the last checkpoint,
   while this one is able to archive up to the last log file change.

Are there any other differences?

I am not sure about the archive file naming convention, i.e. including
the LSN in the file name instead of sequence number. With sequence
number it is easier to detect continuity errors when some file gets
lost. Perhaps include both?

SLEEP 4 in the test may result in non-deterministic behaviour on
loaded test machines. It's better to use DEBUG_SYNC facilities.

Why does log_sys->lsn need to be protected by log_sys->archived_mutex
too? I see no need to stop it advancing while the archiving is going
on as far as the log_write_low check is in place.

fil_swap_file does not have a header comment.

Please document the new fields in log_sys struct. I think a better
name for archived_mutex would be arch_sys_mutex or similar.

purge_archived_logs should have an InnoDB style header comment.

Please move SRV_PATH_SEPARATOR, srv_calc_low32, srv_calc_high32
definitions from srv0start.c to srv0start.h instead of copying them to
srv0srv.c

s/archivation/archiving

s/"Log archived until"/"Log archived up to" in log_print()

Diff line 315: whitespace mismatch

Inconsistent code formatting: occurences of "if(foo)" or even
"if( foo)". Should be "if (foo)" everywhere.

I'd try to pretend to support multiple log groups with
UT_LIST_GET_NEXT loop over the log_sys->log_groups, but I guess that's
strictly optional.

review: Needs Fixing

[Alexey Kopytov (akopytov)]

Nickolay,

I didn't review everything. Just thought it would be more efficient to do it iteratively.

Generally, I first suggest trying to make a debug build with your patch (I had a few issues see below), and then trying to run the percona_log_archiving test (it crashes due to an assertion failure, see below).

So the comments I have so far:

   - percona_server_variables_debug.result should also be adjusted
   - compiler warning in srv0srv.c. I suggest replacing

    if(expire_sec <= 0 || (ut_time() - fileinfo.mtime) <= expire_sec) {
  with
    if (ut_time() <= (ib_time_t)
        (fileinfo.mtime + expire_sec)) {
   - there is a compile-time assertion in debug builds, because the
     patch introduces 2 new SQLCOM_ commands, but does not add the
     corresponding SHOW STATUS variables to com_status_vars.
   - there are unused 'protocol' variables in ha_purge_archive_logs()
     and ha_purge_archive_logs_to()
   - after fixing the above issues with debug builds, I got a runtime
     assertion failure when trying to run the percona_log_archive
     test. The reason is that PURGE ARCHIVED LOGS sends neither OK nor
     error packet to the client. You should either call my_ok() and set
     res to FALSE in mysql_execute_command() or call my_error() and set
     res to TRUE, see purge_master_logs() for an example
   - there are main.percona_log_archiving failures in release builds in
     http://jenkins.percona.com/view/Percona%20Server%205.1/job/percona-server-5.1-param/254/#showFailuresLink
   - I think it's better to add the test to the innodb_plugin suite
     rather than main one
   - a more common way to pass test-specific options to mysqld is an
     .opt file, not a .cnf file. there are lots of examples in existing
     tests
   - the test case does "drop table if exists t1;" but then creates and
     uses table with the name 't'
   - some unnecessary changes:

  > @@ -645,5 +646,5 @@
  > { "TRIM", SYM(TRIM)},
  > { "VARIANCE", SYM(VARIANCE_SYM)},
  > { "VAR_POP", SYM(VARIANCE_SYM)},
  > - { "VAR_SAMP", SYM(VAR_SAMP_SYM)},
  > + { "VAR_SAMP", SYM(VAR_SAMP_SYM)}
  > };
  >

  and

  > @@ -4560,6 +4560,8 @@
  > return FALSE;
  > }
  >
  > +
  > +
  > bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat)
  > {
  > List<Item> field_list;
  >

  and

  > @@ -10709,9 +10710,12 @@ select_var_ident:
  > ;
  >
  > purge_options:
  > + ARCHIVED_SYM LOGS_SYM purge_archive_option
  > + |
  > master_or_binary LOGS_SYM purge_option
  > ;
  >
  > +
  > purge_option:
  > TO_SYM TEXT_STRING_sys
  > {
  >

   - please remove commented code, e.g.:

  > + //res = purge_master_logs(thd, lex->to_log);
  > + //fprintf(stderr, "purge archive logs command called %s\n", lex->to_log);
  >

   - SLEEPs in test cases almost never work. They definitely don't work
     for synchronization, but unfortunately there's no way to
     synchronize between mtr and InnoDB, especially when a background
     InnoDB thread has to be executed synchronously. Which means we have
     to modify tests to remove SLEEP()s possibly at the cost of test
     covera...

review: Needs Fixing

[Alexey Kopytov (akopytov)]

Nickolay,

The patch looks generally good to me, but I have a bunch of relatively minor comments:

   - the patch makes ARCHIVED a reserved keyword (so, for example,
     "CREATE TABLE archived(...)" succeeds in upstream server, but fails
     in PS). Please add ARCHIVED_SYM to the keyword_sp rule in sql_yacc.yy

   - innobase_purge_archive_logs() and purge_archived_logs() do
     something odd. So innobase_purge_archive_logs() takes the point in
     time up to which logs must be purged as its 'before_date'
     argument. Basically, all we need to do is to traverse all files in
     the archived logs directory and delete those with mtime <
     before_date, right? Here's what actually happens:

     - innobase_purge_archive_logs() takes the current time, subtracts
       before_date and passes that as the expire_sec argument to
       purge_archived_logs()
     - expire_sec argument is unsigned. So if you specify a point in
       time in the future, i.e. "PURGE ARCHIVED LOGS BEFORE NOW() +
       INTERVAL 1 MONTH" an overflow occurs and unexpected things may
       happen depending on sizeof(time_t) in the OS
     - purge_archived_logs() iterates the log files, takes their mtime,
       adds expire_sec and compares it with _current_ time again. So the
       exact cut-off time is drifting, which may become a problem when
       file deletion takes a long time (which is quite possible)
     - on a side note, purge_archive_logs() skips all files if
       expired_sec is 0. Why?

     So why not just pass before_date to purge_archived_logs() and
     compare mtime with it directly?

   - I think fil_swap_file() does too much unnecessary work on POSIX
     systems. It flushes the file being swapped, then waits for flush to
     complete, then closes the file, just because allegedly "we do not
     trust the operating systems can rename an open file". Well, they
     actually can. It is in the POSIX standard. Windows can do that too,
     but that requires a special flag when opening the file. Since
     Windows is not a priority for us, I suggest enclosing the
     unnecessary for POSIX code in #ifdef __WIN__. We can fix Windows
     later and remove that code in fil_swap_file() completely.

   - fil_swap_file() could use some descriptive comments for the
     function itself and its arguments. Also, fil_rotate_file() would
     probably be a bit more descriptive name.

   - innobase_log_archive_update() has a race condition. The entire
     function body must be protected by log_sys->archived_mutex,
     otherwise multiple concurrent threads calling that function can
     result in multiple log archive threads being created.

   - in innobase_log_archive_update() and
     innobase_log_archive_expire_update() you show update *var_ptr
     rather than innodb_* variables directly. The comment "where the
     formal string goes" in the var_ptr comment looks to be copy-pasted
     and not applicable to those 2 functions?

   - please don't use the Yoda notation, as in "if (FALSE ==
     log_xtra_log_archive_on)"

   - please use OS_FILE_MAX_PATH instead of 10000 in
     purge_archived_logs() and srv_log_archive_thread()

   - there are 2 open_or_...

review: Needs Fixing

[Nickolay Ihalainen (ihanick)]

jenkins build for revision 435
http://jenkins.percona.com/view/Percona%20Server%205.1/job/percona-server-5.1-param/259/

[Alexey Kopytov (akopytov)]

Nickolay,

If I'm not mistaken, the only change since my previous review comments is revision 435 with some changes to tests. It doesn't look like any of my comments have been addressed yet. Is that correct, or I am missing something? Just trying to understand if the patch is ready for review.

review: Needs Information

[Nickolay Ihalainen (ihanick)]

Alexey,

Sorry, just have found your comments at 2012-02-19.
I'm going to fix these problems today and tomorrow.
In lastest MP was fixed only 2012-02-13 problems.

[Nickolay Ihalainen (ihanick)]

Latest jenkins run:
http://jenkins.percona.com/view/Percona%20Server%205.1/job/percona-server-5.1-param/

[Laurynas Biveinis (laurynas-biveinis)]

    percona_log_archiving.test: include have_innodb_plugin.inc instead
    of have_innodb.inc.

    I second Alexey's comments that SLEEP in a testcase will not work
    reliably. We can discuss alternatives on IRC.

    sql/handler.cc changes are inconsistent in "foo = " vs "foo=". It
    should be the latter in all cases.

    Replace if (foo) return TRUE; else return FALSE; constructs with
    return foo; (purge_archive_logs_handlerton,
    purge_archive_logs_to_handlerton)

    Replace (CONSTANT == var) with (var == CONSTANT) (same functions).
    Diff line 365: s/data/date ?
    Line 379: remove commented-out code

    fil_rotate_file can be simplified greatly taking into account
    Alexey's comment that we can rename open files.

    innobase_purge_archive_logs: if illegally formed to_filename is
    passed (i.e. no LSN in the file name), strtoll will return 0,
    calling purge_archived_logs with before_lsn == 0, purging all the
    files, which is probably not the best action. A testcase should be
    added for this case and strtoll errors handled.

    Similar issue is in purge_archived_logs. If someone puts a file
    that is named like archive log file but malformed (no LSN) in the
    archived log directory, strtoll will return 0 there to and the
    correctness of purge_archived_logs needs to be checked.

    The option descriptions:

    Line 805: s/"Set to 1 if you want to have logs archived"/"Enables
    log archiving".

    Line 809: s/"Where full logs should be archived."/"Path to
    archived logs directory"

    Line 813: s/expire time/expiration time

    fil_rotate_file declaration in fil0fil should have comments for
    arguments too, as does the definition.

    I have commented previously that new fields in log_sys struct
    should be commented. I think a better name for archived_mutex
    would be arch_sys_mutex or similar.

    I have asked previously, why do the log_sys->lsn increases need to
    be protected by the log_sys->archived_mutex?

    purge_archived_logs should have a clarification in the header
    comment if both args should not be set at the same time or what
    would happen if they are.

    os_file_rename_throttled: the typecasts for args of rename look
    redundant (the casted-to type is identical to the original type)

    The header comment for open_or_create_new_log_file looks truncated
    ("Creates or opens the next log file and closes that")

    srv_log_archive_thread: s/archivation/archiving (I had this
    comment before)

    I am not sure I understand the error message in
    srv_log_archive_thread: ""InnoDB: Warning: The new log file cannot
    be created. The above errors should be fixed
    will retry 10 seconds later again.". What does it mean "should be
    fixed"? Should a DBA be continuously monitoring the error log and
    fixing something in 10 seconds?

    Please use snprintf instead of sprintf everywhere to avoid buffer
    overflows (except maybe in purge_archived_logs: there sprintf use
    could be safe, but I'm not sure and erring on the side of snprintf
    is always safer).

    Documentation will need some more work, maybe with Hrvoje's
    help. It's OK fo...

review: Needs Fixing

[Nickolay Ihalainen (ihanick)]

> Documentation will need some more work, maybe with Hrvoje's
> help. It's OK for documentation changes to be in a separate MP.

Things should be discussed:

>
> I second Alexey's comments that SLEEP in a testcase will not work
> reliably. We can discuss alternatives on IRC.

> I am not sure I understand the error message in
> srv_log_archive_thread: ""InnoDB: Warning: The new log file cannot
> be created. The above errors should be fixed
> will retry 10 seconds later again.". What does it mean "should be
> fixed"? Should a DBA be continuously monitoring the error log and
> fixing something in 10 seconds?
If logging is enabled we should guarantee that there is no missing files.
What we can do in disk full or invalid permissions situation?

> percona_log_archiving.test: include have_innodb_plugin.inc instead
> of have_innodb.inc.
Done

> sql/handler.cc changes are inconsistent in "foo = " vs "foo=". It
> should be the latter in all cases.
done

> Replace if (foo) return TRUE; else return FALSE; constructs with
> return foo; (purge_archive_logs_handlerton,
> purge_archive_logs_to_handlerton)
done

>
> Replace (CONSTANT == var) with (var == CONSTANT) (same functions).
> Diff line 365: s/data/date ?
> Line 379: remove commented-out code
done

>
> fil_rotate_file can be simplified greatly taking into account
> Alexey's comment that we can rename open files.
We should flush all blocks and close file before finishing archiving.
Should I split this function or this one will be fine?

> innobase_purge_archive_logs: if illegally formed to_filename is
> passed (i.e. no LSN in the file name), strtoll will return 0,
> calling purge_archived_logs with before_lsn == 0, purging all the
> files, which is probably not the best action. A testcase should be
> added for this case and strtoll errors handled.
Fixed, Should I add some error message/produce an warning?

>
> Similar issue is in purge_archived_logs. If someone puts a file
> that is named like archive log file but malformed (no LSN) in the
> archived log directory, strtoll will return 0 there to and the
> correctness of purge_archived_logs needs to be checked.
fixed

>
> The option descriptions:
> Line 805: s/"Set to 1 if you want to have logs archived"/"Enables
> log archiving".
> Line 809: s/"Where full logs should be archived."/"Path to
> archived logs directory"
> Line 813: s/expire time/expiration time
> fil_rotate_file declaration in fil0fil should have comments for
> arguments too, as does the definition.
done

>
> I have commented previously that new fields in log_sys struct
> should be commented. I think a better name for archived_mutex
> would be arch_sys_mutex or similar.
done

>
> I have asked previously, why do the log_sys->lsn increases need to
> be protected by the log_sys->archived_mutex?

In srv_log_archive_thread, log_sys->archived_lsn is calculated, value depends on log_sys->lsn
archived_lsn value is also used to understand if we have enough space in logs inside log_write_low.

E.g. If two or more...

[Nickolay Ihalainen (ihanick)]

http://jenkins.percona.com/view/Percona%20Server%205.1/job/percona-server-5.1-param/295/

[Laurynas Biveinis (laurynas-biveinis)]

I only have cosmetic comments for this MP:

    Re. current SLEEP in testsuite. As previously discussed, I believe
    that it is "almost safe", but I wonder if the following may happen
    on very busy testing servers: around the SLEEP(1) time, the log
    archiving thread is starved (not scheduled to run), SLEEP(1)
    completes, then log archiving thread executes and rotates the log,
    failing the next list_files test. I don't know if that's maybe
    just a theoretical case, and we cannot do much about it anyway
    currently.

    The handler entry purge_archive_logs perhaps could be better
    named purge_archived_logs, but please make this change only if you
    have to resubmit the MP. Likewise for the new functions in handler.h|cc

    The typo fix s/data/date in sql_parse.cc should be made in own
    code, not in otherwise untouched upstream code (i.e. in
    SQLCOM_PURGE_ARCHIVE_BEFORE, not in "PURGE MASTER LOGS BEFORE")

    s/arhiving/archiving in log0log.h new struct log_sys fied
    comments.

    "0 == strcmp(log_xtra_log_archive_dir, srv_log_group_home_dirs[0]"
    in srv_log_archive_thread should be reversed.

Since my comments are so minor, I suggest to wait for Alexey's review before submitting a new MP.

review: Needs Fixing

[Alexey Kopytov (akopytov)]

Nickolay,

I didn't have time to review everything, but the following code in os_file_rename_throttled() caught my eye:

> + success = os_file_get_size(file, &size_low, &size_high);
> + ut_a(success);
> +
> + for (offset_high = 0; offset_high<size_high; ++offset_high) {
> + for (offset = 0; offset<size_low/block_size; ++offset) {

I see the following problems with it:

1. when size_high == 0 (i.e. the file size is < 4 GB), we will have 0 loop iterations, i.e. we won't copy anything.

2. when size_high = 2 and size_low = 1024*1024 (i.e. the file size is 8 GB + 1 MB), we will have 2 iterations, each copying 1 MB, so we'll copy 2 MB in total.

review: Needs Fixing

[Alexey Kopytov (akopytov)]

Oops, it looks like I reviewed and commented on a superseded proposal. But that code is the same with the current MP, so my previous comment still holds.

review: Needs Fixing

[Alexey Kopytov (akopytov)]

Nickolay,

- I think the implementation of file copying in os_file_rename_throttled() could be a lot simpler and easier to read if it just used a 64-bit offset instead of messing with 32-bit parts. You can find an example in fil_reset_too_high_lsns().

- I don't understand this code:

  + if (max_iops > 100 && ((offset_low/block_size) % (max_iops/100)) == 0) {
  + os_thread_sleep(10000 /* 0.01 sec */);

  So what value does the max_iops argument actually has? The comment says "number of I/O operations per second", but looking at the code above, that doesn't seem to be the case.

- max_iops doesn't have any effect, because the caller of os_file_rename_throttled() always passes 0 as its value. Did you mean to add a new configuration variable?

review: Needs Fixing

[Nickolay Ihalainen (ihanick)]

http://jenkins.percona.com/view/Percona%20Server%205.1/job/percona-server-5.1-param/305/

[Alexey Kopytov (akopytov)]

Nickolay,

   - please follow the InnoDB code style and limit the line
     width to 80 characters at least in your code
   - excessive indentation. instead of having:

    if (ret != 0) {
  long indented block;
 }

 return(TRUE);

      wouldn't it be better to have:

 if (ret == 0) {
    return(TRUE); // or "goto end;"
 }

 // long block with less indentation
 return(TRUE);

   - the above also applies to the "if (err == EXDEV)" block
   - POSIX_FADV_DONTNEED is used in a wrong way, see XtraBackup
     bug #925441
   - I think the following for loop:

for (offset = 0; offset <= file_size-(ib_int64_t)block_size; offset += block_size) {

     is equivalent to:

for (offset = 0; offset < file_size; offset += block_size) {

     but is a bit easier to read.

review: Needs Fixing

[Alexey Kopytov (akopytov)]

   - as we discussed previously, the major problem with the current
     approach is that when log archiving is enabled the maximum
     checkpoint age is reduced by 1 log file size, which in the most
     common configuration with 2 log files means the available log space
     is reduced in half. but we will get to this issue later after
     implementing the XtraBackup part of the task;

   - another major problem that I discovered is that log archiving is
     not crash-safe: a crash may lead to 1) partially written archive
     files and 2) log archiving itself not being able to recover without
     user intervention; We should fix that, let's discuss the details later;

   Less significant problems:

   - no error handling in innobase_purge_archive_logs(). The function
     comment says "@return non-zero if error", but it always
     returns zero. The same applies to purge_archived_logs(), it should
     return an error code. Not having error handling in those functions
     is bad because it's currently impossible for a user to know after
     running PURGE ARCHIVED LOGS whether it was successful or not
     without looking at the error log. Instead, the PURGE statement
     itself should return an error to the client.
   - while you're fixing innobase_purge_archive_logs() you may want to
     replace strstr() with is_prefix() and
     strlen(IB_ARCHIVED_LOGS_PREFIX) with a constant,
     e.g. IB_ARCHIVED_LOGS_PREFIX_LEN.
   - as Laurynas wrote, the following change fixes a comment typo in the
     upstream comment. please revert it:

> === modified file 'Percona-Server/sql/sql_parse.cc'
> --- Percona-Server/sql/sql_parse.cc 2011-11-24 16:33:30 +0000
> +++ Percona-Server/sql/sql_parse.cc 2012-05-05 14:06:22 +0000
> @@ -2491,7 +2491,7 @@ mysql_execute_command(THD *thd)
>
> if (check_global_access(thd, SUPER_ACL))
> goto error;
> - /* PURGE MASTER LOGS BEFORE 'data' */
> + /* PURGE MASTER LOGS BEFORE 'date' */
> it= (Item *)lex->value_list.head();
> if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
> it->check_cols(1))
>
   - another change in the upstream code for no apparent reasons. Note
     that it changes code inside #ifdef UNIV_LOG_ARCHIVE which is never
     (and in fact, cannot be) enabled in Percona Server:

> @@ -852,7 +897,7 @@ log_init(void)
> #ifdef UNIV_LOG_ARCHIVE
> /* Under MySQL, log archiving is always off */
> log_sys->archiving_state = LOG_ARCH_OFF;
> - log_sys->archived_lsn = log_sys->lsn;
> + log_sys->archived_lsn = 0;
> log_sys->next_archived_lsn = 0;
>
> log_sys->n_pending_archive_ios = 0;
>

    that initialization should probably be outside of #ifdef UNIV_LOG_ARCHIVE?

   - I wonder if we a failure in os_file_rename_throttled() should
     result in a fatal error, i.e. an assertion failure. Currently, we
     do crash if a read or a write fail on a throttled cross-device
     copy. However, when rename() fails, we just return FALSE, which
     only results in a "Note:" message in the error log. Which looks
     inconsistent to me. E.g. if the destination directory does not
     exist, or we have insufficient privileges to write to it, logs will
     not be a...

review: Needs Fixing

[Laurynas Biveinis (laurynas-biveinis)]

Due to log archiving running in a separate thread we need DBUG_SYNC in code/testcase at least between any places that produce log and check the archived log files, i.e. between last INSERT and following list_files_append_file.

In the code the sync point should be around os_event_set(log_sys->arch_event_rotate_done) call.

review: Needs Fixing

Unmerged revisions

449. By Nickolay Ihalainen on 2012-04-25

merge with 5.1 trunk

448. By Nickolay Ihalainen on 2012-04-25

Fixed deadlock if innodb_xtra_log_archive enabled dynamically. Correct posix_fadvise usage, indentation

447. By Nickolay Ihalainen on 2012-04-04

Add log archiving copy throttle variable to percona server variables test results

446. By Nickolay Ihalainen on 2012-04-03

fix file copy for archived log located on separate disks: prevent caching cleanup

445. By Nickolay Ihalainen on 2012-04-03

log archiving, copy log to separate disk, increase chunk to 64 innodb pages.

444. By Nickolay Ihalainen on 2012-04-03

log archiving, copy log to separate disk: copy now uses 64bit offset, implemented throttling

443. By Nickolay Ihalainen on 2012-04-03

pull changes from 5.1 trunk

442. By Nickolay Ihalainen on 2012-04-02

fix file copy for archived log located on separate disks

441. By Nickolay Ihalainen on 2012-03-26

code standards, comments, test for invalid purge archived logs to filename

440. By Nickolay Ihalainen on 2012-03-21

Added missing comments

=== modified file 'Percona-Server/mysql-test/r/percona_server_variables_debug.result'
--- Percona-Server/mysql-test/r/percona_server_variables_debug.result	2012-01-30 04:30:33 +0000
+++ Percona-Server/mysql-test/r/percona_server_variables_debug.result	2012-04-25 22:22:24 +0000
@@ -161,6 +161,10 @@
 INNODB_USE_SYS_STATS_TABLE
 INNODB_VERSION
 INNODB_WRITE_IO_THREADS
+INNODB_XTRA_EXPIRE_ARCHIVE_LOGS_SEC
+INNODB_XTRA_LOG_ARCHIVE
+INNODB_XTRA_LOG_ARCHIVE_DIR
+INNODB_XTRA_LOG_ARCHIVE_THROTTLE
 INSERT_ID
 INTERACTIVE_TIMEOUT
 JOIN_BUFFER_SIZE

=== modified file 'Percona-Server/mysql-test/r/percona_server_variables_release.result'
--- Percona-Server/mysql-test/r/percona_server_variables_release.result	2011-11-24 02:01:33 +0000
+++ Percona-Server/mysql-test/r/percona_server_variables_release.result	2012-04-25 22:22:24 +0000
@@ -159,6 +159,10 @@
 INNODB_USE_SYS_STATS_TABLE
 INNODB_VERSION
 INNODB_WRITE_IO_THREADS
+INNODB_XTRA_EXPIRE_ARCHIVE_LOGS_SEC
+INNODB_XTRA_LOG_ARCHIVE
+INNODB_XTRA_LOG_ARCHIVE_DIR
+INNODB_XTRA_LOG_ARCHIVE_THROTTLE
 INSERT_ID
 INTERACTIVE_TIMEOUT
 JOIN_BUFFER_SIZE

=== added file 'Percona-Server/mysql-test/suite/innodb_plugin/r/percona_log_archiving.result'
--- Percona-Server/mysql-test/suite/innodb_plugin/r/percona_log_archiving.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/innodb_plugin/r/percona_log_archiving.result	2012-04-25 22:22:24 +0000
@@ -0,0 +1,45 @@
+drop table if exists t;
+create table t (a int not null) ENGINE=InnoDB;
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+SELECT sleep(1);
+sleep(1)
+0
+PURGE ARCHIVED LOGS BEFORE ("tmpval" + INTERVAL 1 SECOND);
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+PURGE ARCHIVED LOGS TO "last_log_file_next";
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+PURGE ARCHIVED LOGS TO "ib_log_archive_#invalid";
+last_log_file
+SET GLOBAL innodb_xtra_log_archive = OFF;
+SELECT @@innodb_xtra_log_archive;
+@@innodb_xtra_log_archive
+0
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+SET GLOBAL innodb_xtra_log_archive = ON;
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+SELECT sleep(1);
+sleep(1)
+0
+SET @saved_innodb_xtra_expire_archive_logs_sec = @@innodb_xtra_expire_archive_logs_sec;
+SET GLOBAL innodb_xtra_expire_archive_logs_sec = 1;
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+SET GLOBAL innodb_xtra_expire_archive_logs_sec = @saved_innodb_xtra_expire_archive_logs_sec;
+SET @saved_innodb_xtra_log_archive_throttle = @@innodb_xtra_log_archive_throttle;
+SET GLOBAL innodb_xtra_log_archive_throttle = 10;
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+SET GLOBAL innodb_xtra_log_archive_throttle = @saved_innodb_xtra_log_archive_throttle;
+last_log_file
+create table archived(id int);
+drop table archived;
+DROP TABLE t;

=== added file 'Percona-Server/mysql-test/suite/innodb_plugin/t/percona_log_archiving-master.opt'
--- Percona-Server/mysql-test/suite/innodb_plugin/t/percona_log_archiving-master.opt	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/innodb_plugin/t/percona_log_archiving-master.opt	2012-04-25 22:22:24 +0000
@@ -0,0 +1,1 @@
+--innodb_xtra_log_archive=1 --innodb_xtra_log_archive_dir=logs_archive --innodb_xtra_expire_archive_logs_sec=3600 --innodb_log_file_size=2M

=== added file 'Percona-Server/mysql-test/suite/innodb_plugin/t/percona_log_archiving.test'
--- Percona-Server/mysql-test/suite/innodb_plugin/t/percona_log_archiving.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/innodb_plugin/t/percona_log_archiving.test	2012-04-25 22:22:24 +0000
@@ -0,0 +1,191 @@
+--source include/have_innodb_plugin.inc
+--disable_warnings
+drop table if exists t;
+--enable_warnings
+
+let $MYSQLD_DATADIR= `SELECT @@datadir`;
+let $MYSQLD_ARCHIVEDIR= `SELECT IF( locate('/', @@innodb_xtra_log_archive_dir) = 1, @@innodb_xtra_log_archive_dir, CONCAT(@@datadir, @@innodb_xtra_log_archive_dir))`;
+let MYSQLD_ARCHIVEDIR = $MYSQLD_ARCHIVEDIR;
+--mkdir $MYSQLD_ARCHIVEDIR
+
+create table t (a int not null) ENGINE=InnoDB;
+
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13);
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+
+--list_files_append_file $MYSQLTEST_VARDIR/tmp/archived_transaction_logs.list $MYSQLD_ARCHIVEDIR ib_log_archive_*
+# Set the purge time 1 second after the last modify time of last ib_log_archive_*
+perl;
+open FSRC, "<".$ENV{'MYSQLTEST_VARDIR'}.'/tmp/archived_transaction_logs.list' or die "Tmp file archived_transaction_logs.list not found";
+open F, ">>".$ENV{'MYSQLTEST_VARDIR'}.'/tmp/percona_archived_logs.tmp' or die "Tmp file percona_archived_logs.tmp not found";
+my $line;
+while(<FSRC>) {
+  chomp;
+  if( index( $_,'ib_log_archive_') >= 0 ) {
+    $line = $_;
+  }
+}
+
+my $binlogpath = $ENV{'MYSQLD_ARCHIVEDIR'}.'/'.$line;
+my @array = stat($binlogpath);
+my $filemodifytime = $array[9];
+my @t = localtime $filemodifytime;
+my $modifytime = sprintf "%04u-%02u-%02u %02u:%02u:%02u",$t[5]+1900,$t[4]+1,$t[3],$t[2],$t[1],$t[0];
+printf F ("let \$last_log_file = %s;\n", $line);
+printf F ("let \$tmpval = %s;\n", $modifytime);
+close F;
+EOF
+
+--source $MYSQLTEST_VARDIR/tmp/percona_archived_logs.tmp
+remove_file $MYSQLTEST_VARDIR/tmp/percona_archived_logs.tmp;
+remove_file $MYSQLTEST_VARDIR/tmp/archived_transaction_logs.list;
+
+SELECT sleep(1);
+
+--replace_result $tmpval tmpval
+--eval PURGE ARCHIVED LOGS BEFORE ("$tmpval" + INTERVAL 1 SECOND)
+--list_files $MYSQLD_ARCHIVEDIR $last_log_file
+
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+
+--list_files_append_file $MYSQLTEST_VARDIR/tmp/archived_transaction_logs.list $MYSQLD_ARCHIVEDIR ib_log_archive_*
+# get last archived transaction log file
+perl;
+open FSRC, "<".$ENV{'MYSQLTEST_VARDIR'}.'/tmp/archived_transaction_logs.list' or die "Tmp file archived_transaction_logs.list not found";
+open F, ">>".$ENV{'MYSQLTEST_VARDIR'}.'/tmp/percona_archived_logs.tmp' or die "Tmp file percona_archived_logs.tmp not found";
+my $line;
+my $next_lsn_file;
+while(<FSRC>) {
+  chomp;
+  if( m/ib_log_archive_(\d+)$/ ) { $line = $_;$next_lsn_file = sprintf "ib_log_archive_%016d", ($1+1); }
+}
+
+printf F ("let \$last_log_file = %s;\n", $line);
+printf F ("let \$last_log_file_next = %s;\n", $next_lsn_file);
+close F;
+EOF
+
+--source $MYSQLTEST_VARDIR/tmp/percona_archived_logs.tmp
+remove_file $MYSQLTEST_VARDIR/tmp/percona_archived_logs.tmp;
+remove_file $MYSQLTEST_VARDIR/tmp/archived_transaction_logs.list;
+
+--replace_result $last_log_file_next last_log_file_next
+--eval PURGE ARCHIVED LOGS TO "$last_log_file_next"
+--list_files $MYSQLD_ARCHIVEDIR $last_log_file
+
+# check invalid filename
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+
+--list_files_append_file $MYSQLTEST_VARDIR/tmp/archived_transaction_logs.list $MYSQLD_ARCHIVEDIR ib_log_archive_*
+# get last archived transaction log file
+perl;
+open FSRC, "<".$ENV{'MYSQLTEST_VARDIR'}.'/tmp/archived_transaction_logs.list' or die "Tmp file archived_transaction_logs.list not found";
+open F, ">>".$ENV{'MYSQLTEST_VARDIR'}.'/tmp/percona_archived_logs.tmp' or die "Tmp file percona_archived_logs.tmp not found";
+my $line;
+my $next_lsn_file;
+while(<FSRC>) {
+  chomp;
+  if( m/ib_log_archive_(\d+)$/ ) { $line = $_;$next_lsn_file = sprintf "ib_log_archive_%016d", ($1+1); }
+}
+
+printf F ("let \$last_log_file = %s;\n", $line);
+printf F ("let \$last_log_file_next = %s;\n", $next_lsn_file);
+close F;
+EOF
+
+--source $MYSQLTEST_VARDIR/tmp/percona_archived_logs.tmp
+remove_file $MYSQLTEST_VARDIR/tmp/percona_archived_logs.tmp;
+remove_file $MYSQLTEST_VARDIR/tmp/archived_transaction_logs.list;
+
+--eval PURGE ARCHIVED LOGS TO "ib_log_archive_#invalid"
+--replace_result $last_log_file last_log_file
+--list_files $MYSQLD_ARCHIVEDIR $last_log_file
+--remove_files_wildcard $MYSQLD_ARCHIVEDIR ib_log_archive_*
+
+# Check enable-disable
+SET GLOBAL innodb_xtra_log_archive = OFF;
+SELECT @@innodb_xtra_log_archive;
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+--list_files $MYSQLD_ARCHIVEDIR ib_log_archive_*
+SET GLOBAL innodb_xtra_log_archive = ON;
+
+
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+
+--list_files_append_file $MYSQLTEST_VARDIR/tmp/archived_transaction_logs.list $MYSQLD_ARCHIVEDIR ib_log_archive_*
+perl;
+open FSRC, "<".$ENV{'MYSQLTEST_VARDIR'}.'/tmp/archived_transaction_logs.list' or die "Tmp file archived_transaction_logs.list not found";
+open F, ">>".$ENV{'MYSQLTEST_VARDIR'}.'/tmp/percona_archived_logs.tmp' or die "Tmp file percona_archived_logs.tmp not found";
+my $line;
+while(<FSRC>) {
+  chomp;
+  if( index( $_,'ib_log_archive_') >= 0 ) { $line = $_; }
+}
+
+printf F ("let \$last_log_file = %s;", $line);
+close F;
+EOF
+
+--source $MYSQLTEST_VARDIR/tmp/percona_archived_logs.tmp
+remove_file $MYSQLTEST_VARDIR/tmp/percona_archived_logs.tmp;
+remove_file $MYSQLTEST_VARDIR/tmp/archived_transaction_logs.list;
+
+SELECT sleep(1);
+
+SET @saved_innodb_xtra_expire_archive_logs_sec = @@innodb_xtra_expire_archive_logs_sec;
+SET GLOBAL innodb_xtra_expire_archive_logs_sec = 1;
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+--list_files $MYSQLD_ARCHIVEDIR $last_log_file
+SET GLOBAL innodb_xtra_expire_archive_logs_sec = @saved_innodb_xtra_expire_archive_logs_sec;
+
+
+
+# check throttle
+SET @saved_innodb_xtra_log_archive_throttle = @@innodb_xtra_log_archive_throttle;
+SET GLOBAL innodb_xtra_log_archive_throttle = 10;
+insert into t (a) select t1.a from t t1, t t2, t t3 LIMIT 100000;
+SET GLOBAL innodb_xtra_log_archive_throttle = @saved_innodb_xtra_log_archive_throttle;
+
+--list_files_append_file $MYSQLTEST_VARDIR/tmp/archived_transaction_logs.list $MYSQLD_ARCHIVEDIR ib_log_archive_*
+# get last archived transaction log file
+perl;
+open FSRC, "<".$ENV{'MYSQLTEST_VARDIR'}.'/tmp/archived_transaction_logs.list' or die "Tmp file archived_transaction_logs.list not found";
+open F, ">>".$ENV{'MYSQLTEST_VARDIR'}.'/tmp/percona_archived_logs.tmp' or die "Tmp file percona_archived_logs.tmp not found";
+my $line;
+my $next_lsn_file;
+while(<FSRC>) {
+  chomp;
+  if( m/ib_log_archive_(\d+)$/ ) { $line = $_;$next_lsn_file = sprintf "ib_log_archive_%016d", ($1+1); }
+}
+
+printf F ("let \$last_log_file = %s;\n", $line);
+printf F ("let \$last_log_file_next = %s;\n", $next_lsn_file);
+close F;
+EOF
+
+--source $MYSQLTEST_VARDIR/tmp/percona_archived_logs.tmp
+remove_file $MYSQLTEST_VARDIR/tmp/percona_archived_logs.tmp;
+remove_file $MYSQLTEST_VARDIR/tmp/archived_transaction_logs.list;
+
+
+--replace_result $last_log_file last_log_file
+--list_files $MYSQLD_ARCHIVEDIR $last_log_file
+
+
+create table archived(id int);
+drop table archived;
+
+DROP TABLE t;
+
+--remove_files_wildcard $MYSQLD_ARCHIVEDIR ib_log_archive_*
+--rmdir $MYSQLD_ARCHIVEDIR

=== modified file 'Percona-Server/sql/handler.cc'
--- Percona-Server/sql/handler.cc	2011-11-24 16:33:30 +0000
+++ Percona-Server/sql/handler.cc	2012-04-25 22:22:24 +0000
@@ -4597,6 +4597,48 @@
   return result;
 }
 
+static my_bool purge_archive_logs_handlerton(THD *thd, plugin_ref plugin,
+                                   void *arg)
+{
+  ulong before_timestamp= *(ulong*) arg;
+  handlerton *hton= plugin_data(plugin, handlerton *);
+
+  if (hton->purge_archive_logs == NULL)
+    return TRUE;
+
+  return hton->purge_archive_logs(hton, before_timestamp, NULL);
+}
+
+bool ha_purge_archive_logs(THD *thd, handlerton *db_type, void* args)
+{
+  if (db_type == NULL)
+    return plugin_foreach(thd, purge_archive_logs_handlerton,
+                           MYSQL_STORAGE_ENGINE_PLUGIN, args);
+
+  return false;
+}
+
+static my_bool purge_archive_logs_to_handlerton(THD *thd, plugin_ref plugin,
+                                   void *arg)
+{
+  const char* to_filename= (const char*) arg;
+  handlerton *hton= plugin_data(plugin, handlerton *);
+
+  if (hton->purge_archive_logs == NULL)
+    return TRUE;
+
+  return hton->purge_archive_logs(hton, 0, to_filename);
+}
+
+bool ha_purge_archive_logs_to(THD *thd, handlerton *db_type, void* args)
+{
+  if (db_type == NULL)
+    return plugin_foreach(thd, purge_archive_logs_to_handlerton,
+                           MYSQL_STORAGE_ENGINE_PLUGIN, args);
+
+  return false;
+}
+
 /*
   Function to check if the conditions for row-based binlogging is
   correct for the table.

=== modified file 'Percona-Server/sql/handler.h'
--- Percona-Server/sql/handler.h	2012-01-17 14:05:16 +0000
+++ Percona-Server/sql/handler.h	2012-04-25 22:22:24 +0000
@@ -693,6 +693,8 @@
    int (*fill_files_table)(handlerton *hton, THD *thd,
                            TABLE_LIST *tables,
                            class Item *cond);
+   int (*purge_archive_logs)(handlerton *hton, time_t before_date, const char* to_filename);
+
    uint32 flags;                                /* global handler flags */
    /*
       Those handlerton functions below are properly initialized at handler
@@ -2074,6 +2076,11 @@
 int ha_prepare(THD *thd);
 int ha_recover(HASH *commit_list);
 
+/* remove old archived transaction logs files */
+bool ha_purge_archive_logs(THD *thd, handlerton *db_type, void* args);
+bool ha_purge_archive_logs_to(THD *thd, handlerton *db_type, void* args);
+
+
 /* transactions: these functions never call handlerton functions directly */
 int ha_commit_trans(THD *thd, bool all);
 int ha_autocommit_or_rollback(THD *thd, int error);

=== modified file 'Percona-Server/sql/lex.h'
--- Percona-Server/sql/lex.h	2011-11-24 02:01:23 +0000
+++ Percona-Server/sql/lex.h	2012-04-25 22:22:24 +0000
@@ -68,6 +68,7 @@
   { "ANALYZE",		SYM(ANALYZE_SYM)},
   { "AND",		SYM(AND_SYM)},
   { "ANY",              SYM(ANY_SYM)},
+  { "ARCHIVED",		SYM(ARCHIVED_SYM)},
   { "AS",		SYM(AS)},
   { "ASC",		SYM(ASC)},
   { "ASCII",		SYM(ASCII_SYM)},

=== modified file 'Percona-Server/sql/mysqld.cc'
--- Percona-Server/sql/mysqld.cc	2012-03-16 09:07:44 +0000
+++ Percona-Server/sql/mysqld.cc	2012-04-25 22:22:24 +0000
@@ -3070,6 +3070,8 @@
   {"prepare_sql",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PREPARE]), SHOW_LONG_STATUS},
   {"purge",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PURGE]), SHOW_LONG_STATUS},
   {"purge_before_date",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PURGE_BEFORE]), SHOW_LONG_STATUS},
+  {"purge_archived",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PURGE_ARCHIVE]), SHOW_LONG_STATUS},
+  {"purge_archived_before_date",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PURGE_ARCHIVE_BEFORE]), SHOW_LONG_STATUS},
   {"release_savepoint",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RELEASE_SAVEPOINT]), SHOW_LONG_STATUS},
   {"rename_table",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RENAME_TABLE]), SHOW_LONG_STATUS},
   {"rename_user",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RENAME_USER]), SHOW_LONG_STATUS},

=== modified file 'Percona-Server/sql/sql_lex.h'
--- Percona-Server/sql/sql_lex.h	2011-11-24 02:01:33 +0000
+++ Percona-Server/sql/sql_lex.h	2012-04-25 22:22:24 +0000
@@ -130,6 +130,8 @@
   // TODO(mcallaghan): update status_vars in mysqld to export these
   SQLCOM_SHOW_USER_STATS, SQLCOM_SHOW_TABLE_STATS, SQLCOM_SHOW_INDEX_STATS,
   SQLCOM_SHOW_CLIENT_STATS, SQLCOM_SHOW_THREAD_STATS,
+  SQLCOM_PURGE_ARCHIVE,
+  SQLCOM_PURGE_ARCHIVE_BEFORE,
   /* This should be the last !!! */
   SQLCOM_END
 };

=== modified file 'Percona-Server/sql/sql_parse.cc'
--- Percona-Server/sql/sql_parse.cc	2011-11-24 16:33:30 +0000
+++ Percona-Server/sql/sql_parse.cc	2012-04-25 22:22:24 +0000
@@ -2491,7 +2491,7 @@
 
     if (check_global_access(thd, SUPER_ACL))
       goto error;
-    /* PURGE MASTER LOGS BEFORE 'data' */
+    /* PURGE MASTER LOGS BEFORE 'date' */
     it= (Item *)lex->value_list.head();
     if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
         it->check_cols(1))
@@ -2508,6 +2508,49 @@
     res = purge_master_logs_before_date(thd, (ulong)it->val_int());
     break;
   }
+  case SQLCOM_PURGE_ARCHIVE:
+  {
+    if (check_global_access(thd, SUPER_ACL))
+      goto error;
+    /* PURGE ARCHIVED LOGS TO 'file' */
+    if (ha_purge_archive_logs_to(NULL, NULL, lex->to_log)) {
+      my_ok(thd);
+    } else {
+      my_error(ER_LOG_PURGE_UNKNOWN_ERR, MYF(0), "PURGE ARCHIVE LOGS TO");
+      goto error;
+    }
+
+    break;
+  }
+  case SQLCOM_PURGE_ARCHIVE_BEFORE:
+  {
+    Item *it;
+
+    if (check_global_access(thd, SUPER_ACL))
+      goto error;
+    /* PURGE ARCHIVE LOGS BEFORE 'data' */
+    it= (Item *)lex->value_list.head();
+    if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
+        it->check_cols(1))
+    {
+      my_error(ER_WRONG_ARGUMENTS, MYF(0), "PURGE ARCHIVE LOGS BEFORE");
+      goto error;
+    }
+    it= new Item_func_unix_timestamp(it);
+    /*
+      it is OK only emulate fix_fieds, because we need only
+      value of constant
+    */
+    it->quick_fix_field();
+    ulong before_timestamp = (ulong)it->val_int();
+    if (ha_purge_archive_logs(NULL, NULL, &before_timestamp )) {
+      my_ok(thd);
+    } else {
+      my_error(ER_LOG_PURGE_UNKNOWN_ERR, MYF(0), "PURGE ARCHIVE LOGS BEFORE");
+      goto error;
+    }
+    break;
+  }
 #endif
   case SQLCOM_SHOW_WARNS:
   {

=== modified file 'Percona-Server/sql/sql_yacc.yy'
--- Percona-Server/sql/sql_yacc.yy	2012-04-02 02:09:15 +0000
+++ Percona-Server/sql/sql_yacc.yy	2012-04-25 22:22:24 +0000
@@ -714,6 +714,7 @@
 %token  AND_AND_SYM                   /* OPERATOR */
 %token  AND_SYM                       /* SQL-2003-R */
 %token  ANY_SYM                       /* SQL-2003-R */
+%token	ARCHIVED_SYM		      /* MYSQL      */
 %token  AS                            /* SQL-2003-R */
 %token  ASC                           /* SQL-2003-N */
 %token  ASCII_SYM                     /* MYSQL-FUNC */
@@ -10715,6 +10716,8 @@
         ;
 
 purge_options:
+	ARCHIVED_SYM LOGS_SYM purge_archive_option
+	|
           master_or_binary LOGS_SYM purge_option
         ;
 
@@ -10732,6 +10735,22 @@
           }
         ;
 
+purge_archive_option:
+          TO_SYM TEXT_STRING_sys
+          {
+            Lex->to_log = $2.str;
+            Lex->sql_command= SQLCOM_PURGE_ARCHIVE;
+          }
+        | BEFORE_SYM expr
+          {
+            LEX *lex= Lex;
+            lex->value_list.empty();
+            lex->value_list.push_front($2);
+            lex->sql_command= SQLCOM_PURGE_ARCHIVE_BEFORE;
+          }
+        ;
+
+
 /* kill threads */
 
 kill:
@@ -11776,6 +11795,7 @@
         | AGGREGATE_SYM            {}
         | ALGORITHM_SYM            {}
         | ANY_SYM                  {}
+        | ARCHIVED_SYM             {}
         | AT_SYM                   {}
         | AUTHORS_SYM              {}
         | AUTO_INC                 {}

=== modified file 'Percona-Server/storage/innodb_plugin/fil/fil0fil.c'
--- Percona-Server/storage/innodb_plugin/fil/fil0fil.c	2012-04-02 02:09:15 +0000
+++ Percona-Server/storage/innodb_plugin/fil/fil0fil.c	2012-04-25 22:22:24 +0000
@@ -2658,6 +2658,228 @@
 	return(success);
 }
 
+/********************************************************************//**
+Rotates tablespace like logrotate does: renames tablespace file,
+new tablespace file is created with the same name and tablespace header
+as original tablespace
+@return	TRUE if success */
+UNIV_INTERN
+ibool
+fil_rotate_file(
+/*==========*/
+	ulint		id, 	/*!< in: space id */
+	ulint		block_offset_in,	/*!< in: header offset in a tablespace */
+	const char*	old_file_rename_to,	/*!< in: src tablespace file name */
+	const char*	new_file_rename_from,	/*!< in: dst tablespace file name */
+	ulint		hdr_size)	/*!< in: tablespace header size */
+
+{
+	ibool		success;
+	fil_space_t*	space;
+	fil_node_t*	node;
+	ulint		block_offset;
+	os_file_t	file;
+	ulint		size;
+	ulint		size_high;
+	ulint		count		= 0;
+
+	byte*		buf_ptr = NULL;
+	byte*		buf = NULL;
+
+	ut_a(id != 0);
+
+retry:
+	block_offset = block_offset_in;
+	count++;
+
+	if (count > 1000) {
+		ut_print_timestamp(stderr);
+		fputs("  InnoDB: Warning: problems renaming ", stderr);
+		ut_print_filename(stderr, old_file_rename_to);
+		fputs(" or ", stderr);
+		ut_print_filename(stderr, new_file_rename_from);
+		fprintf(stderr, ", %lu iterations\n", (ulong) count);
+	}
+
+	mutex_enter(&fil_system->mutex);
+
+	space = fil_space_get_by_id(id);
+
+	if (space == NULL) {
+		fprintf(stderr,
+			"InnoDB: Error: cannot find space id %lu"
+			" in the tablespace memory cache\n",
+			(ulong) id);
+		mutex_exit(&fil_system->mutex);
+
+		return(FALSE);
+	}
+
+	if (count > 25000) {
+error_exit:
+		space->stop_ios = FALSE;
+		mutex_exit(&fil_system->mutex);
+
+		if (buf_ptr) {
+			ut_free(buf_ptr);
+		}
+
+		return(FALSE);
+	}
+
+	/* We temporarily close the .ibd file because we do not trust that
+	operating systems can rename an open file. For the closing we have to
+	wait until there are no pending i/o's or flushes on the file. */
+
+	space->stop_ios = TRUE;
+
+	node = UT_LIST_GET_FIRST(space->chain);
+
+	for (;;) {
+		if (UNIV_UNLIKELY(node == NULL)) {
+			fprintf(stderr,
+				"InnoDB: Error: The specified block_offset %lu"
+				" in space %lu,\n"
+				"InnoDB: space name %s, which is outside the tablespace bounds.\n",
+				(ulong) block_offset, (ulong) id,
+				space->name);
+
+			goto error_exit;
+		}
+
+		ut_a(node->size != 0);
+
+		if (node->size > block_offset) {
+			/* Found! */
+			break;
+		} else {
+			block_offset -= node->size;
+			node = UT_LIST_GET_NEXT(chain, node);
+		}
+	}
+
+	if (node->n_pending > 0 || node->n_pending_flushes > 0) {
+		/* There are pending i/o's or flushes, sleep for a while and
+		retry */
+
+		mutex_exit(&fil_system->mutex);
+
+		os_thread_sleep(20000);
+
+		goto retry;
+
+	} else if (node->modification_counter > node->flush_counter) {
+		/* Flush the space */
+
+		mutex_exit(&fil_system->mutex);
+
+		os_thread_sleep(20000);
+
+		fil_flush(id, TRUE);
+
+		goto retry;
+
+	} else if (node->open) {
+		/* Close the file */
+
+		fil_node_close_file(node, fil_system);
+	}
+
+	/* store old header */
+	if (hdr_size > 0) {
+		buf_ptr = ut_malloc(2 * hdr_size);
+		buf = ut_align(buf_ptr, hdr_size);
+
+		file = os_file_create(node->name, OS_FILE_OPEN, OS_FILE_NORMAL,
+				      OS_LOG_FILE, &success);
+		ut_a(success);
+
+		success = os_file_read(file, buf, 0, 0, hdr_size);
+		ut_a(success);
+
+		os_file_close(file);
+	}
+
+	/* check size of the new file */
+	file = os_file_create(new_file_rename_from, OS_FILE_OPEN, OS_FILE_NORMAL,
+			      OS_LOG_FILE, &success);
+	if (!success) {
+		fprintf(stderr,
+			"InnoDB: Error in opening %s\n", new_file_rename_from);
+		goto error_exit;
+	}
+
+	success = os_file_get_size(file, &size, &size_high);
+	ut_a(success);
+
+	if (size != (0xFFFFFFFFUL & (node->size << UNIV_PAGE_SIZE_SHIFT))
+	    || size_high != (node->size >> (32 - UNIV_PAGE_SIZE_SHIFT))) {
+		fprintf(stderr,
+			"InnoDB: Error: file %s is"
+			" of different size %lu %lu bytes\n"
+			"InnoDB: than intended %lu %lu bytes!\n",
+			new_file_rename_from, (ulong) size_high, (ulong) size,
+			(ulong) (node->size >> (32 - UNIV_PAGE_SIZE_SHIFT)),
+			(ulong) (0xFFFFFFFFUL & (node->size << UNIV_PAGE_SIZE_SHIFT)));
+		os_file_close(file);
+		goto error_exit;
+	}
+
+	/* copy stored header */
+	if (hdr_size > 0) {
+		success = os_file_write(new_file_rename_from, file, buf, 0, 0, hdr_size);
+		if (!success) {
+			fprintf(stderr,
+				"InnoDB: Error: failed to initialize"
+				" header of %s\n",
+				new_file_rename_from);
+			os_file_close(file);
+			goto error_exit;
+		}
+		success = os_file_flush(file, TRUE);
+		if (!success) {
+			fprintf(stderr,
+				"InnoDB: Error: failed to initialize"
+				" header of %s\n",
+				new_file_rename_from);
+			os_file_close(file);
+			goto error_exit;
+		}
+	}
+
+	success = os_file_close(file);
+	ut_a(success);
+
+	/* Rename the tablespace and the node in the memory cache */
+	success = os_file_rename(node->name, old_file_rename_to);
+
+	if (success) {
+		success = os_file_rename(new_file_rename_from, node->name);
+
+		if (!success) {
+			ut_a(os_file_rename(old_file_rename_to, node->name));
+		}
+	}
+
+	if (success) {
+		fprintf(stderr,
+			"InnoDB: file %s was renamed to %s\n"
+			"InnoDB: file %s was renamed to %s\n",
+			node->name, old_file_rename_to,
+			new_file_rename_from, node->name);
+	}
+
+	space->stop_ios = FALSE;
+
+	mutex_exit(&fil_system->mutex);
+
+	if (buf_ptr) {
+		ut_free(buf_ptr);
+	}
+
+	return(success);
+}
+
 /*******************************************************************//**
 Creates a new single-table tablespace to a database directory of MySQL.
 Database directories are under the 'datadir' of MySQL. The datadir is the

=== modified file 'Percona-Server/storage/innodb_plugin/handler/ha_innodb.cc'
--- Percona-Server/storage/innodb_plugin/handler/ha_innodb.cc	2012-04-02 02:09:15 +0000
+++ Percona-Server/storage/innodb_plugin/handler/ha_innodb.cc	2012-04-25 22:22:24 +0000
@@ -186,6 +186,10 @@
 static my_bool	innobase_log_archive			= FALSE;
 static char*	innobase_log_arch_dir			= NULL;
 #endif /* UNIV_LOG_ARCHIVE */
+static my_bool	innobase_xtra_log_archive		= FALSE;
+static char*	innobase_xtra_log_archive_dir		= NULL;
+static ulong	innodb_xtra_expire_archive_logs_sec	= 0;
+static uint	innodb_xtra_archive_logs_throttle	= 0;
 static my_bool	innobase_use_doublewrite		= TRUE;
 static my_bool	innobase_use_checksums			= TRUE;
 static my_bool	innobase_fast_checksum			= FALSE;
@@ -316,6 +320,31 @@
 static const char innobase_hton_name[]= "InnoDB";
 
 /*************************************************************//**
+Removes old archived transaction log files.
+@return	non-zero if error */
+static int innobase_purge_archive_logs(
+	handlerton *hton,		/*!< in: InnoDB handlerton */
+	time_t before_date,		/*!< in: all files modified
+					before timestamp should be removed */
+	const char* to_filename)	/*!< in: this and earler files
+					should be removed */
+{
+	if (before_date > 0) {
+		purge_archived_logs(before_date, 0);
+	} else if (to_filename) {
+		if (strstr(to_filename, IB_ARCHIVED_LOGS_PREFIX) == to_filename) {
+			unsigned long long log_file_lsn = strtoll(to_filename
+					+ strlen(IB_ARCHIVED_LOGS_PREFIX),
+					NULL, 10);
+			if (log_file_lsn > 0) {
+				purge_archived_logs(0, log_file_lsn);
+			}
+		}
+	}
+	return 0;
+}
+
+/*************************************************************//**
 Check for a valid value of innobase_commit_concurrency.
 @return	0 for valid innodb_commit_concurrency */
 static
@@ -2134,6 +2163,7 @@
         innobase_hton->flags=HTON_NO_FLAGS;
         innobase_hton->release_temporary_latches=innobase_release_temporary_latches;
 	innobase_hton->alter_table_flags = innobase_alter_table_flags;
+	innobase_hton->purge_archive_logs = innobase_purge_archive_logs;
 
 	ut_a(DATA_MYSQL_TRUE_VARCHAR == (ulint)MYSQL_TYPE_VARCHAR);
 
@@ -2503,6 +2533,15 @@
 #ifdef UNIV_LOG_ARCHIVE
 	srv_log_archive_on = (ulint) innobase_log_archive;
 #endif /* UNIV_LOG_ARCHIVE */
+	log_xtra_log_archive_on = (ulint) innobase_xtra_log_archive;
+	log_xtra_log_arch_expire_sec = (ulint) innodb_xtra_expire_archive_logs_sec;
+	log_xtra_log_arch_throttle = (ulint) innodb_xtra_archive_logs_throttle;
+
+	if (innobase_xtra_log_archive_dir && strlen(innobase_xtra_log_archive_dir) > 0) {
+		log_xtra_log_archive_dir = innobase_xtra_log_archive_dir;
+	} else {
+		log_xtra_log_archive_dir = innobase_log_group_home_dir;
+	}
 	srv_log_buffer_size = (ulint) innobase_log_buffer_size;
 
 	srv_buf_pool_size = (ulint) innobase_buffer_pool_size;
@@ -11320,6 +11359,75 @@
 }
 
 /****************************************************************//**
+Update the system variable innobase_log_archive using the "saved"
+value. This function is registered as a callback with MySQL. */
+static
+void
+innobase_log_archive_update(
+/*==============================*/
+	THD*				thd,		/*!< in: thread handle */
+	struct st_mysql_sys_var*	var,		/*!< in: pointer to
+							system variable */
+	void*				var_ptr,	/*!< out: unused */
+	const void*			save)		/*!< in: immediate result
+							from check function */
+{
+	mutex_enter(&(log_sys->arch_sys_mutex));
+	if (*(my_bool*) save) {
+		if (log_xtra_log_archive_on == FALSE) {
+			log_sys->archived_lsn=0;
+			innobase_xtra_log_archive=TRUE;
+			log_xtra_log_archive_on=TRUE;
+			os_thread_create(&srv_log_archive_thread, NULL, NULL);
+		}
+	} else {
+		if (log_xtra_log_archive_on == TRUE) {
+			innobase_xtra_log_archive=FALSE;
+			log_xtra_log_archive_on=FALSE;
+			os_event_set(log_sys->arch_event_rotate_start);
+		}
+	}
+	mutex_exit(&(log_sys->arch_sys_mutex));
+}
+
+/****************************************************************//**
+Update the system variable innodb_xtra_expire_archive_logs_sec using
+the "saved" value. This function is registered as a callback with MySQL. */
+static
+void
+innobase_log_archive_expire_update(
+/*==============================*/
+	THD*				thd,		/*!< in: thread handle */
+	struct st_mysql_sys_var*	var,		/*!< in: pointer to
+							system variable */
+	void*				var_ptr,	/*!< out: unused */
+	const void*			save)		/*!< in: immediate result
+							from check function */
+{
+	mutex_enter(&(log_sys->arch_sys_mutex));
+	log_xtra_log_arch_expire_sec = innodb_xtra_expire_archive_logs_sec = *(ulint*) save;
+	mutex_exit(&(log_sys->arch_sys_mutex));
+}
+/****************************************************************//**
+Update the system variable innodb_xtra_expire_archive_logs_sec using
+the "saved" value. This function is registered as a callback with MySQL. */
+static
+void
+innobase_log_archive_throttle_update(
+/*==============================*/
+	THD*				thd,		/*!< in: thread handle */
+	struct st_mysql_sys_var*	var,		/*!< in: pointer to
+							system variable */
+	void*				var_ptr,	/*!< out: unused */
+	const void*			save)		/*!< in: immediate result
+							from check function */
+{
+	mutex_enter(&(log_sys->arch_sys_mutex));
+	log_xtra_log_arch_throttle = innodb_xtra_archive_logs_throttle = *static_cast<const uint*>(save);
+	mutex_exit(&(log_sys->arch_sys_mutex));
+}
+
+/****************************************************************//**
 Update the system variable innodb_old_blocks_pct using the "saved"
 value. This function is registered as a callback with MySQL. */
 static
@@ -11680,6 +11788,24 @@
   "Set to 1 if you want to have logs archived.", NULL, NULL, FALSE);
 #endif /* UNIV_LOG_ARCHIVE */
 
+static MYSQL_SYSVAR_BOOL(xtra_log_archive, innobase_xtra_log_archive,
+  PLUGIN_VAR_OPCMDARG,
+  "Enables log archiving.", NULL, innobase_log_archive_update, FALSE);
+
+static MYSQL_SYSVAR_STR(xtra_log_archive_dir, innobase_xtra_log_archive_dir,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Path to archived logs directory.", NULL, NULL, NULL);
+
+static MYSQL_SYSVAR_ULONG(xtra_expire_archive_logs_sec, innodb_xtra_expire_archive_logs_sec,
+  PLUGIN_VAR_OPCMDARG,
+  "Expiration time for archived innodb transaction logs.",
+  NULL, innobase_log_archive_expire_update, 0, 0, ~0L, 0);
+
+static MYSQL_SYSVAR_UINT(xtra_log_archive_throttle, innodb_xtra_archive_logs_throttle,
+  PLUGIN_VAR_OPCMDARG,
+  "number of read+write pairs of operations per second for archived innodb transaction logs cross device copy operation.",
+  NULL, innobase_log_archive_throttle_update, 0, 0, ~0L, 0);
+
 static MYSQL_SYSVAR_STR(log_group_home_dir, innobase_log_group_home_dir,
   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
   "Path to InnoDB log files.", NULL, NULL, NULL);
@@ -12121,6 +12247,10 @@
   MYSQL_SYSVAR(log_arch_dir),
   MYSQL_SYSVAR(log_archive),
 #endif /* UNIV_LOG_ARCHIVE */
+  MYSQL_SYSVAR(xtra_log_archive),
+  MYSQL_SYSVAR(xtra_log_archive_dir),
+  MYSQL_SYSVAR(xtra_expire_archive_logs_sec),
+  MYSQL_SYSVAR(xtra_log_archive_throttle),
   MYSQL_SYSVAR(log_buffer_size),
   MYSQL_SYSVAR(log_file_size),
   MYSQL_SYSVAR(log_files_in_group),

=== modified file 'Percona-Server/storage/innodb_plugin/include/fil0fil.h'
--- Percona-Server/storage/innodb_plugin/include/fil0fil.h	2011-12-09 16:53:35 +0000
+++ Percona-Server/storage/innodb_plugin/include/fil0fil.h	2012-04-25 22:22:24 +0000
@@ -426,7 +426,20 @@
 	const char*	new_name);	/*!< in: new table name in the standard
 					databasename/tablename format
 					of InnoDB */
-
+/********************************************************************//**
+Rotates tablespace like logrotate does: renames tablespace file,
+new tablespace file is created with the same name and tablespace header
+as original tablespace
+@return	TRUE if success */
+UNIV_INTERN
+ibool
+fil_rotate_file(
+/*==========*/
+	ulint		id, 			/*!< in: space id */
+	ulint		block_offset_in,	/*!< in: header offset in a tablespace */
+	const char*	old_file_rename_to,	/*!< in: src tablespace file name */
+	const char*	new_file_rename_from,	/*!< in: dst tablespace file name */
+	ulint		hdr_size);		/*!< in: tablespace header size */
 /*******************************************************************//**
 Creates a new single-table tablespace to a database directory of MySQL.
 Database directories are under the 'datadir' of MySQL. The datadir is the

=== modified file 'Percona-Server/storage/innodb_plugin/include/log0log.h'
--- Percona-Server/storage/innodb_plugin/include/log0log.h	2012-04-02 02:09:15 +0000
+++ Percona-Server/storage/innodb_plugin/include/log0log.h	2012-04-25 22:22:24 +0000
@@ -56,6 +56,10 @@
 # define log_do_write TRUE
 #endif /* UNIV_DEBUG */
 
+extern ibool	log_xtra_log_archive_on;
+extern const char* log_xtra_log_archive_dir;
+extern time_t	log_xtra_log_arch_expire_sec;
+extern uint	log_xtra_log_arch_throttle;
 /** Wait modes for log_write_up_to @{ */
 #define LOG_NO_WAIT		91
 #define LOG_WAIT_ONE_GROUP	92
@@ -75,6 +79,26 @@
 /*==========================================*/
 	ulint	limit);	/*!< in: limit to set */
 #endif /* !UNIV_HOTBACKUP */
+/******************************************************//**
+Calculates the offset of an lsn within a log group.
+@return	offset within the log group */
+UNIV_INTERN
+ulint
+log_group_calc_lsn_offset(
+/*======================*/
+	ib_uint64_t		lsn,	/*!< in: lsn, must be within 4 GB of
+					group->lsn */
+	const log_group_t*	group);	/*!< in: log group */
+
+/*****************************************************************//**
+Calculates the recommended highest values for lsn - last_checkpoint_lsn,
+lsn - buf_get_oldest_modification(), and lsn - max_archive_lsn_age.
+@return error value FALSE if the smallest log group is too small to
+accommodate the number of OS threads in the database server */
+ibool
+log_calc_max_ages(void);
+/*===================*/
+
 /*******************************************************************//**
 Calculates where in log files we find a specified lsn.
 @return	log file number */
@@ -953,6 +977,10 @@
 					become signaled */
 	/* @} */
 #endif /* UNIV_LOG_ARCHIVE */
+	os_event_t	arch_event_rotate_start; /*!< initiates transaction log archiving */
+	os_event_t	arch_event_rotate_done;  /*!< logging thread can continue normal work after receiving this event */
+	mutex_t		arch_sys_mutex;		 /*!< protects LSN and archiving thread manipulations */
+	ib_uint64_t	archived_lsn;		 /*!< LSN of last archived transaction log file */
 };
 
 #ifdef UNIV_LOG_ARCHIVE

=== modified file 'Percona-Server/storage/innodb_plugin/include/log0log.ic'
--- Percona-Server/storage/innodb_plugin/include/log0log.ic	2010-06-10 14:31:28 +0000
+++ Percona-Server/storage/innodb_plugin/include/log0log.ic	2012-04-25 22:22:24 +0000
@@ -372,7 +372,11 @@
 
 	ut_ad(log_sys->buf_free <= log_sys->buf_size);
 
+	if (log_xtra_log_archive_on)
+		mutex_enter(&(log_sys->arch_sys_mutex));
 	log_sys->lsn += len;
+	if (log_xtra_log_archive_on)
+		mutex_exit(&(log_sys->arch_sys_mutex));
 
 #ifdef UNIV_LOG_DEBUG
 	log_check_log_recs(log_sys->buf + log_sys->old_buf_free,

=== modified file 'Percona-Server/storage/innodb_plugin/include/os0file.h'
--- Percona-Server/storage/innodb_plugin/include/os0file.h	2011-11-24 02:00:47 +0000
+++ Percona-Server/storage/innodb_plugin/include/os0file.h	2012-04-25 22:22:24 +0000
@@ -403,6 +403,20 @@
 	const char*	oldpath,	/*!< in: old file path as a
 					null-terminated string */
 	const char*	newpath);	/*!< in: new file path */
+/***************************************************************************
+Renames a file (can also move it to another directory and another drive).
+If file should be placed to a different disks throttle will applied.
+@return	TRUE if success */
+ibool
+os_file_rename_throttled(
+/*===========*/
+	const char*	oldpath,	/* in: old file path as a
+					null-terminated
+				        string */
+	const char*	newpath, 	/* in: new file path */
+	unsigned int	throttle);	/* in: number of read+write pairs of
+					operations per second. */
+
 /***********************************************************************//**
 Closes a file handle. In case of error, error number can be retrieved with
 os_file_get_last_error.

=== modified file 'Percona-Server/storage/innodb_plugin/include/srv0srv.h'
--- Percona-Server/storage/innodb_plugin/include/srv0srv.h	2011-11-24 02:01:25 +0000
+++ Percona-Server/storage/innodb_plugin/include/srv0srv.h	2012-04-25 22:22:24 +0000
@@ -185,6 +185,8 @@
 extern dulint	srv_archive_recovery_limit_lsn;
 #endif /* UNIV_LOG_ARCHIVE */
 
+#define IB_ARCHIVED_LOGS_PREFIX "ib_log_archive_"
+
 extern char*	srv_file_flush_method_str;
 extern ulint	srv_unix_file_flush_method;
 extern ulint	srv_win_file_flush_method;
@@ -445,6 +447,7 @@
 #endif
 	SRV_PURGE,	/* thread purging undo records */
 	SRV_PURGE_WORKER,	/* thread purging undo records */
+	SRV_ARCHIVE,
 	SRV_MASTER	/**< the master thread, (whose type number must
 			be biggest) */
 };
@@ -643,6 +646,13 @@
 /*====================*/
 	void*	arg);	/*!< in: a dummy parameter required by
 			os_thread_create */
+/********************************************************************//**
+A thread which controls archiving transaction log files */
+UNIV_INTERN
+os_thread_ret_t
+srv_log_archive_thread(
+/*===================*/
+	void*	arg);
 /******************************************************************//**
 Outputs to a file the output of the InnoDB Monitor.
 @return FALSE if not all information printed
@@ -665,6 +675,18 @@
 srv_export_innodb_status(void);
 /*==========================*/
 
+/*************************************************************//**
+Removes old archived transaction log files.
+Both parameters couldn't be provided at the same time */
+UNIV_INTERN
+void
+purge_archived_logs(
+	time_t before_date,		/*!< in: all files modified
+					before timestamp should be removed */
+	unsigned long long before_lsn);	/*!< in: files with this lsn in name
+					and earler should be removed */
+/*==========================*/
+
 /** Thread slot in the thread table */
 typedef struct srv_slot_struct	srv_slot_t;
 

=== modified file 'Percona-Server/storage/innodb_plugin/include/srv0start.h'
--- Percona-Server/storage/innodb_plugin/include/srv0start.h	2011-11-24 02:00:36 +0000
+++ Percona-Server/storage/innodb_plugin/include/srv0start.h	2012-04-25 22:22:24 +0000
@@ -37,6 +37,22 @@
 /*=======================*/
 	char*	str);	/*!< in/out: null-terminated character string */
 /*********************************************************************//**
+Calculates the low 32 bits when a file size which is given as a number
+database pages is converted to the number of bytes.
+@return	low 32 bytes of file size when expressed in bytes */
+ulint
+srv_calc_low32(
+/*===========*/
+	ulint	file_size);	/*!< in: file size in database pages */
+/*********************************************************************//**
+Calculates the high 32 bits when a file size which is given as a number
+database pages is converted to the number of bytes.
+@return	high 32 bytes of file size when expressed in bytes */
+ulint
+srv_calc_high32(
+/*============*/
+	ulint	file_size);	/*!< in: file size in database pages */
+/*********************************************************************//**
 Reads the data files and their sizes from a character string given in
 the .cnf file.
 @return	TRUE if ok, FALSE on parse error */
@@ -134,4 +150,10 @@
 /** reserved for extra system tables */
 #define SRV_EXTRA_SYS_SPACE_FIRST_ID	0xFFFFFFE0UL
 
+#ifdef __WIN__
+#define SRV_PATH_SEPARATOR	'\\'
+#else
+#define SRV_PATH_SEPARATOR	'/'
+#endif
+
 #endif

=== modified file 'Percona-Server/storage/innodb_plugin/log/log0log.c'
--- Percona-Server/storage/innodb_plugin/log/log0log.c	2012-04-02 02:09:15 +0000
+++ Percona-Server/storage/innodb_plugin/log/log0log.c	2012-04-25 22:22:24 +0000
@@ -97,6 +97,11 @@
 UNIV_INTERN byte	log_archive_io;
 #endif /* UNIV_LOG_ARCHIVE */
 
+UNIV_INTERN ibool	log_xtra_log_archive_on = FALSE;
+
+UNIV_INTERN const char* log_xtra_log_archive_dir = NULL;
+UNIV_INTERN time_t	log_xtra_log_arch_expire_sec;
+UNIV_INTERN uint	log_xtra_log_arch_throttle = 0;
 /* A margin for free space in the log buffer before a log entry is catenated */
 #define LOG_BUF_WRITE_MARGIN	(4 * OS_FILE_LOG_BLOCK_SIZE)
 
@@ -287,10 +292,13 @@
 	ulint	str_len)	/*!< in: string length */
 {
 	log_t*	log	= log_sys;
+	log_group_t*	group;
 	ulint	len;
 	ulint	data_len;
 	byte*	log_block;
 
+	group = UT_LIST_GET_FIRST(log->log_groups);
+
 	ut_ad(mutex_own(&(log->mutex)));
 part_loop:
 	ut_ad(!recv_no_log_write);
@@ -311,6 +319,30 @@
 			- LOG_BLOCK_TRL_SIZE;
 	}
 
+	/* If the log write is across file border,
+	   should check the archive was done. */
+	if (log_xtra_log_archive_on) {
+		if ((log_group_calc_lsn_offset(log->lsn, group)
+					/ group->file_size)
+		   != (log_group_calc_lsn_offset(log->lsn + len, group)
+			   / group->file_size)) {
+			os_event_set(log_sys->arch_event_rotate_start);
+		}
+wait_for_archived:
+		mutex_enter(&(log_sys->arch_sys_mutex));
+		if ( !(log_sys->archived_lsn) || 
+				log->lsn + len <= log_sys->archived_lsn
+				+ log_group_get_capacity(group)) {
+			mutex_exit(&(log_sys->arch_sys_mutex));
+		} else {
+			os_event_reset(log_sys->arch_event_rotate_done);
+			mutex_exit(&(log_sys->arch_sys_mutex));
+			os_event_set(log_sys->arch_event_rotate_start); /* for safety */
+			os_event_wait(log_sys->arch_event_rotate_done);
+			goto wait_for_archived;
+		}
+	}
+
 	ut_memcpy(log->buf + log->buf_free, str, len);
 
 	str_len -= len;
@@ -327,12 +359,20 @@
 					    log_sys->next_checkpoint_no);
 		len += LOG_BLOCK_HDR_SIZE + LOG_BLOCK_TRL_SIZE;
 
+		if (log_xtra_log_archive_on)
+			mutex_enter(&(log_sys->arch_sys_mutex));
 		log->lsn += len;
+		if (log_xtra_log_archive_on)
+			mutex_exit(&(log_sys->arch_sys_mutex));
 
 		/* Initialize the next block header */
 		log_block_init(log_block + OS_FILE_LOG_BLOCK_SIZE, log->lsn);
 	} else {
+		if (log_xtra_log_archive_on)
+			mutex_enter(&(log_sys->arch_sys_mutex));
 		log->lsn += len;
+		if (log_xtra_log_archive_on)
+			mutex_exit(&(log_sys->arch_sys_mutex));
 	}
 
 	log->buf_free += len;
@@ -552,7 +592,7 @@
 /******************************************************//**
 Calculates the offset of an lsn within a log group.
 @return	offset within the log group */
-static
+UNIV_INTERN
 ulint
 log_group_calc_lsn_offset(
 /*======================*/
@@ -670,7 +710,6 @@
 lsn - buf_get_oldest_modification(), and lsn - max_archive_lsn_age.
 @return error value FALSE if the smallest log group is too small to
 accommodate the number of OS threads in the database server */
-static
 ibool
 log_calc_max_ages(void)
 /*===================*/
@@ -710,6 +749,11 @@
 		group = UT_LIST_GET_NEXT(log_groups, group);
 	}
 
+	/* log_archive needs over 1 file margin */
+	if (log_xtra_log_archive_on) {
+		smallest_capacity = smallest_archive_margin;
+	}
+
 	/* Add extra safety */
 	smallest_capacity = smallest_capacity - smallest_capacity / 10;
 
@@ -786,6 +830,7 @@
 	log_sys = mem_alloc(sizeof(log_t));
 
 	mutex_create(&log_sys->mutex, SYNC_LOG);
+	mutex_create(&log_sys->arch_sys_mutex, SYNC_NO_ORDER_CHECK);
 
 	mutex_enter(&(log_sys->mutex));
 
@@ -852,7 +897,7 @@
 #ifdef UNIV_LOG_ARCHIVE
 	/* Under MySQL, log archiving is always off */
 	log_sys->archiving_state = LOG_ARCH_OFF;
-	log_sys->archived_lsn = log_sys->lsn;
+	log_sys->archived_lsn = 0;
 	log_sys->next_archived_lsn = 0;
 
 	log_sys->n_pending_archive_ios = 0;
@@ -872,6 +917,11 @@
 	log_sys->archiving_on = os_event_create(NULL);
 #endif /* UNIV_LOG_ARCHIVE */
 
+	log_sys->arch_event_rotate_start = os_event_create(NULL);
+	os_event_set(log_sys->arch_event_rotate_start);
+	log_sys->arch_event_rotate_done = os_event_create(NULL);
+	os_event_set(log_sys->arch_event_rotate_done);
+
 	/*----------------------------*/
 
 	log_block_init(log_sys->buf, log_sys->lsn);
@@ -1693,13 +1743,29 @@
 log_complete_checkpoint(void)
 /*=========================*/
 {
+	log_group_t*	group;
+
 	ut_ad(mutex_own(&(log_sys->mutex)));
 	ut_ad(log_sys->n_pending_checkpoint_writes == 0);
 
+	group = UT_LIST_GET_FIRST(log_sys->log_groups);
+
+	if (log_xtra_log_archive_on) {
+		mutex_enter(&(log_sys->arch_sys_mutex));
+
+		if ((log_group_calc_lsn_offset(log_sys->next_checkpoint_lsn, group) / group->file_size)
+		    != (log_group_calc_lsn_offset(log_sys->last_checkpoint_lsn, group) / group->file_size)) {
+			os_event_set(log_sys->arch_event_rotate_start);
+		}
+	}
+
 	log_sys->next_checkpoint_no++;
 
 	log_sys->last_checkpoint_lsn = log_sys->next_checkpoint_lsn;
 
+	if (log_xtra_log_archive_on)
+		mutex_exit(&(log_sys->arch_sys_mutex));
+
 	rw_lock_x_unlock_gen(&(log_sys->checkpoint_lock), LOG_CHECKPOINT);
 }
 
@@ -3158,6 +3224,15 @@
 		goto loop;
 	}
 
+	if (log_xtra_log_archive_on
+	    && srv_n_threads_active[SRV_ARCHIVE] != 0) {
+
+		mutex_exit(&kernel_mutex);
+		os_event_set(log_sys->arch_event_rotate_start);
+
+		goto loop;
+	}
+
 	/* Check that the purge threads ended */
 	if (srv_use_purge_thread
 	    && (srv_n_threads_active[SRV_PURGE] != 0
@@ -3375,6 +3450,14 @@
 		log_sys->flushed_to_disk_lsn,
 		log_sys->last_checkpoint_lsn);
 
+	if (log_xtra_log_archive_on) {
+		mutex_enter(&(log_sys->arch_sys_mutex));
+		fprintf(file,
+			"Log archived until  %llu\n",
+			log_sys->archived_lsn);
+		mutex_exit(&(log_sys->arch_sys_mutex));
+	}
+
 	fprintf(file,
 		"Max checkpoint age    %lu\n"
 		"Checkpoint age target %lu\n"
@@ -3479,12 +3562,16 @@
 	rw_lock_free(&log_sys->checkpoint_lock);
 
 	mutex_free(&log_sys->mutex);
+	mutex_free(&log_sys->arch_sys_mutex);
 
 #ifdef UNIV_LOG_ARCHIVE
 	rw_lock_free(&log_sys->archive_lock);
 	os_event_create(log_sys->archiving_on);
 #endif /* UNIV_LOG_ARCHIVE */
 
+	os_event_free(log_sys->arch_event_rotate_start);
+	os_event_free(log_sys->arch_event_rotate_done);
+
 #ifdef UNIV_LOG_DEBUG
 	recv_sys_debug_free();
 #endif

=== modified file 'Percona-Server/storage/innodb_plugin/os/os0file.c'
--- Percona-Server/storage/innodb_plugin/os/os0file.c	2011-12-15 15:27:38 +0000
+++ Percona-Server/storage/innodb_plugin/os/os0file.c	2012-04-25 22:22:24 +0000
@@ -1685,6 +1685,158 @@
 	return(TRUE);
 #endif
 }
+/***************************************************************************
+Renames a file (can also move it to another directory and another drive).
+If file should be placed to a different disks throttle will applied.
+@return	TRUE if success */
+ibool
+os_file_rename_throttled(
+/*===========*/
+	const char*	oldpath,	/* in: old file path as a
+					null-terminated string */
+	const char*	newpath, 	/* in: new file path */
+	unsigned int	throttle)	/* in: number of read+write pairs of
+					operations per second. */
+{
+#ifdef __WIN__
+	return os_file_rename(oldpath, newpath);
+#else
+	int	ret;
+	ulint	err;
+	ulint		block_size = 64*UNIV_PAGE_SIZE;
+	os_file_t	file;
+	os_file_t	new_file;
+	byte*		buf_ptr = NULL;
+	byte*		buf = NULL;
+	ibool		success;
+	ib_int64_t	file_size;
+	ib_int64_t	offset;
+	ulint		prev_time = 0 , cur_time = 0;
+	int		num_io = 0;
+
+	ret = rename(oldpath, newpath);
+
+	if (ret == 0) {
+		return(TRUE);
+	}
+
+	err = (ulint) errno;
+
+	if (err != EXDEV) {
+		os_file_handle_error_no_exit(oldpath, "rename");
+		return(FALSE);
+	}
+
+	buf_ptr = ut_malloc(2*block_size);
+	buf = ut_align(buf_ptr, block_size);
+
+	file = os_file_create(oldpath, OS_FILE_OPEN, OS_FILE_NORMAL,
+			OS_LOG_FILE, &success);
+	ut_a(success);
+	new_file = os_file_create(newpath, OS_FILE_CREATE, OS_FILE_NORMAL,
+			OS_LOG_FILE, &success);
+	ut_a(success);
+
+#ifndef USE_POSIX_FADVISE
+#ifdef POSIX_FADV_NORMAL
+#define USE_POSIX_FADVISE
+#endif
+#endif
+
+#ifdef USE_POSIX_FADVISE
+	posix_fadvise(new_file, 0, 0, POSIX_FADV_SEQUENTIAL);
+	posix_fadvise(file, 0, 0, POSIX_FADV_SEQUENTIAL);
+#endif
+	file_size = os_file_get_size_as_iblonglong(file);
+	ut_a(file_size != -1);
+
+	if (throttle) {
+		prev_time = ut_time_ms();
+	}
+
+	for (offset = 0; offset < file_size; offset += block_size) {
+		success = os_file_read(file, buf,
+				(ulint)(offset & 0xFFFFFFFFUL),
+				(ulint)(offset >> 32),
+				block_size);
+		ut_a(success);
+		success = os_file_write(newpath, new_file, buf,
+				(ulint)(offset & 0xFFFFFFFFUL),
+				(ulint)(offset >> 32),
+				block_size);
+		ut_a(success);
+
+		if (!throttle) {
+			continue;
+		}
+
+		++num_io;
+		cur_time = ut_time_ms();
+
+		if ((cur_time - prev_time) > 0 &&
+			num_io*1000/(cur_time - prev_time) <= throttle) {
+			continue;
+		}
+
+		os_thread_sleep(1000000/throttle
+				- 1000*(cur_time - prev_time)/num_io);
+
+		prev_time = cur_time;
+		num_io = 0;
+	}
+
+	if (file_size - offset > 0) {
+		success = os_file_read(file, buf,
+				(ulint)(offset & 0xFFFFFFFFUL),
+				(ulint)(offset >> 32),
+				file_size - offset);
+		ut_a(success);
+		success = os_file_write(newpath, new_file, buf,
+				(ulint)(offset & 0xFFFFFFFFUL),
+				(ulint)(offset >> 32),
+				file_size - offset);
+		ut_a(success);
+	}
+
+	success = os_file_flush(new_file, TRUE);
+	ut_a(success);
+
+#ifdef UNIV_DEBUG
+	{
+		ib_int64_t	new_file_size;
+
+		new_file_size = os_file_get_size_as_iblonglong(new_file);
+		ut_a(new_file_size != -1);
+
+		if (new_file_size != file_size) {
+			fputs(	"  InnoDB: Warning: problems moving "
+				"to different disk: wrong file size", stderr);
+			ut_print_filename(stderr, newpath);
+			fputs("\n",stderr);
+		}
+	}
+#endif
+
+#ifdef USE_POSIX_FADVISE
+	posix_fadvise(new_file, 0, 0, POSIX_FADV_DONTNEED);
+	posix_fadvise(file, 0, 0, POSIX_FADV_DONTNEED);
+#endif
+
+
+	os_file_close(file);
+	os_file_close(new_file);
+	success = os_file_delete_if_exists(oldpath);
+	ut_a(success);
+
+	if (buf_ptr) {
+		ut_free(buf_ptr);
+	}
+
+	return(TRUE);
+#endif
+}
+
+
 
 /***********************************************************************//**
 Closes a file handle. In case of error, error number can be retrieved with

=== modified file 'Percona-Server/storage/innodb_plugin/srv/srv0srv.c'
--- Percona-Server/storage/innodb_plugin/srv/srv0srv.c	2011-11-24 02:01:25 +0000
+++ Percona-Server/storage/innodb_plugin/srv/srv0srv.c	2012-04-25 22:22:24 +0000
@@ -2674,6 +2674,372 @@
 	OS_THREAD_DUMMY_RETURN;
 }
 
+/*********************************************************************//**
+Creates or opens the next log file. The file will be closed after the call */
+static
+ulint
+open_or_create_new_log_file(
+/*========================*/
+	const char*	name)
+{
+	ibool		ret;
+	ulint		size;
+	ulint		size_high;
+	os_file_t	new_file;
+
+	new_file = os_file_create(name, OS_FILE_CREATE, OS_FILE_NORMAL,
+				  OS_LOG_FILE, &ret);
+	if (ret == FALSE) {
+		if (os_file_get_last_error(FALSE) != OS_FILE_ALREADY_EXISTS) {
+			fprintf(stderr,
+				"InnoDB: Error in creating"
+				" or opening %s\n", name);
+
+			return(DB_ERROR);
+		}
+
+		new_file = os_file_create(name, OS_FILE_OPEN, OS_FILE_AIO,
+					  OS_LOG_FILE, &ret);
+		if (!ret) {
+			fprintf(stderr,
+				"InnoDB: Error in opening %s\n", name);
+			return(DB_ERROR);
+		}
+
+		ret = os_file_get_size(new_file, &size, &size_high);
+		ut_a(ret);
+
+		if (size != srv_calc_low32(srv_log_file_size)
+		    || size_high != srv_calc_high32(srv_log_file_size)) {
+
+			fprintf(stderr,
+				"InnoDB: Error: log file %s is"
+				" of different size %lu %lu bytes\n"
+				"InnoDB: than specified in the .cnf"
+				" file %lu %lu bytes! Rename or remove the file.\n",
+				name, (ulong) size_high, (ulong) size,
+				(ulong) srv_calc_high32(srv_log_file_size),
+				(ulong) srv_calc_low32(srv_log_file_size));
+
+			return(DB_ERROR);
+		}
+	} else {
+		ut_print_timestamp(stderr);
+
+		fprintf(stderr,
+			"  InnoDB: Log file %s did not exist:"
+			" new to be created\n",
+			name);
+
+		fprintf(stderr, "InnoDB: Setting log file %s size to %lu MB\n",
+			name, (ulong) srv_log_file_size
+				      >> (20 - UNIV_PAGE_SIZE_SHIFT));
+
+		fprintf(stderr,
+			"InnoDB: Database physically writes the file"
+			" full: wait...\n");
+
+		ret = os_file_set_size(name, new_file,
+				       srv_calc_low32(srv_log_file_size),
+				       srv_calc_high32(srv_log_file_size));
+		if (!ret) {
+			fprintf(stderr,
+				"InnoDB: Error in creating %s:"
+				" probably out of disk space\n",
+				name);
+
+			return(DB_ERROR);
+		}
+
+		fprintf(stderr,
+			"InnoDB: Setting log file was done\n");
+	}
+
+	ret = os_file_close(new_file);
+	ut_a(ret);
+
+	return(DB_SUCCESS);
+}
+
+/*************************************************************//**
+Removes old archived transaction log files.
+Both parameters couldn't be provided at the same time */
+void
+purge_archived_logs(
+	time_t before_date,		/*!< in: all files modified
+					before timestamp should be removed */
+	unsigned long long before_lsn)	/*!< in: files with this lsn in name
+					and earler should be removed */
+{
+	os_file_dir_t dir;
+	os_file_stat_t fileinfo;
+	char		archived_log_filename[OS_FILE_MAX_PATH];
+	ulint		dirnamelen;
+
+	if (log_xtra_log_archive_dir) {
+		dir = os_file_opendir(log_xtra_log_archive_dir, FALSE);
+		if (!dir) {
+			fprintf(stderr,
+				"InnoDB: Note: opening archived log directory "
+				"%s was failed. "
+				"Purge archived logs are not available\n",
+				log_xtra_log_archive_dir);
+			return;
+		}
+	} else {
+		return;
+	}
+
+	dirnamelen = strlen(log_xtra_log_archive_dir);
+
+	memcpy(archived_log_filename, log_xtra_log_archive_dir, dirnamelen);
+	if (dirnamelen &&
+		archived_log_filename[dirnamelen - 1] != SRV_PATH_SEPARATOR) {
+		archived_log_filename[dirnamelen++] = SRV_PATH_SEPARATOR;
+	}
+
+	memset(&fileinfo, 0, sizeof(fileinfo));
+	while(!os_file_readdir_next_file(log_xtra_log_archive_dir, dir,
+				&fileinfo) ) {
+		if (fileinfo.name != strstr(fileinfo.name,
+					IB_ARCHIVED_LOGS_PREFIX)) {
+		}
+		if (dirnamelen + strlen(fileinfo.name) + 2 > OS_FILE_MAX_PATH)
+			continue;
+
+		snprintf(archived_log_filename + dirnamelen, OS_FILE_MAX_PATH,
+				"%s", fileinfo.name);
+
+		if (before_lsn) {
+			ib_uint64_t log_file_lsn = strtoll(fileinfo.name +
+					strlen(IB_ARCHIVED_LOGS_PREFIX),
+					NULL, 10);
+			if (log_file_lsn == 0 || before_lsn <= log_file_lsn) {
+				continue;
+			}
+		} else {
+			fileinfo.mtime = 0;
+			if (os_file_get_status(archived_log_filename,
+					&fileinfo) == FALSE ||
+					fileinfo.mtime == 0) {
+				fprintf(stderr,
+					"InnoDB: Note: read archived log last"
+					" modification date for: %s.\n",
+					archived_log_filename);
+				continue;
+			}
+
+			if (before_date == 0 || fileinfo.mtime > before_date) {
+				continue;
+			}
+		}
+
+		if (os_file_delete(archived_log_filename) == FALSE) {
+			fprintf(stderr,
+				"InnoDB: Note: can't delete archived log file"
+				" %s.\n", archived_log_filename);
+		}
+	}
+
+	os_file_closedir(dir);
+}
+
+
+/*********************************************************************//**
+A thread which controls archiving transaction log files */
+UNIV_INTERN
+os_thread_ret_t
+srv_log_archive_thread(
+/*===================*/
+	void*	arg __attribute__((unused)))
+{
+	log_group_t*	group = UT_LIST_GET_FIRST(log_sys->log_groups);
+	ibool		next_is_prepared;
+	ulint		err;
+	char		new_file_name[OS_FILE_MAX_PATH];
+	char		archive_file_name[OS_FILE_MAX_PATH];
+	char		final_file_name[OS_FILE_MAX_PATH];
+	ulint		dirnamelen;
+	ulint		final_dirnamelen;
+
+	ut_a(log_xtra_log_archive_on);
+
+	mutex_enter(&kernel_mutex);
+	srv_table_reserve_slot(SRV_ARCHIVE);
+	srv_n_threads_active[SRV_ARCHIVE]++;
+	mutex_exit(&kernel_mutex);
+
+	log_calc_max_ages();
+	log_check_margins();
+
+	/* initialization */
+	/* assume before the current file was archived already */
+	mutex_enter(&(log_sys->arch_sys_mutex));
+	log_sys->archived_lsn = log_sys->lsn
+		- ((log_group_calc_lsn_offset(log_sys->lsn - 1, group)
+		% group->file_size) + 1 - LOG_FILE_HDR_SIZE);
+	os_event_set(log_sys->arch_event_rotate_done);
+	mutex_exit(&(log_sys->arch_sys_mutex));
+
+	fprintf(stderr, "InnoDB: Note: "
+			"transaction log archiving thread started.\n");
+
+	/* confirm new file and create if needed */
+	dirnamelen = strlen(srv_log_group_home_dirs[0]);
+	ut_a(dirnamelen < (sizeof new_file_name) - 31 - sizeof "ib_logfile");
+
+        if (log_xtra_log_archive_dir &&
+			strcmp(log_xtra_log_archive_dir,
+				srv_log_group_home_dirs[0]) != 0
+	   ) {
+		final_dirnamelen = strlen(log_xtra_log_archive_dir);
+		memcpy(final_file_name, log_xtra_log_archive_dir,
+				final_dirnamelen);
+		if (final_dirnamelen &&
+				final_file_name[final_dirnamelen - 1]
+				!= SRV_PATH_SEPARATOR) {
+			final_file_name[final_dirnamelen++]
+				= SRV_PATH_SEPARATOR;
+		}
+	} else {
+		final_dirnamelen = 0;
+	}
+
+	memcpy(new_file_name, srv_log_group_home_dirs[0], dirnamelen);
+	if (dirnamelen && new_file_name[dirnamelen - 1] != SRV_PATH_SEPARATOR) {
+		new_file_name[dirnamelen++] = SRV_PATH_SEPARATOR;
+	}
+	memcpy(archive_file_name, new_file_name, dirnamelen);
+
+	snprintf(new_file_name + dirnamelen,
+			OS_FILE_MAX_PATH, "%s", "ib_next_logfile");
+
+	next_is_prepared = FALSE;
+
+loop:
+	os_event_reset(log_sys->arch_event_rotate_start);
+
+/* NOTICE: waiting the event log_sys->arch_event_rotate_done is done with
+   log_sys->mutex holding.
+   So, we cannot obtain log_sys->mutex in this thread.
+   The values shared with the other threads should be protected by
+   log_sys->arch_sys_mutex */
+
+retry_create_file:
+	if (!next_is_prepared) {
+		err = open_or_create_new_log_file(new_file_name);
+		if (err == DB_SUCCESS) {
+			next_is_prepared = TRUE;
+		} else {
+			next_is_prepared = FALSE;
+			fprintf(stderr, "InnoDB: Warning: "
+					"The new log file cannot be created. "
+					"The above errors should be fixed\n"
+					"will retry 10 seconds later again.\n");
+			os_thread_sleep(10000000);
+			goto retry_create_file;
+		}
+	}
+
+	ut_a(next_is_prepared);
+
+	mutex_enter(&(log_sys->arch_sys_mutex));
+	if (log_sys->last_checkpoint_lsn
+	    >= log_sys->archived_lsn + (group->file_size - LOG_FILE_HDR_SIZE)) {
+		ulint	hdr_offset;
+		ibool	success;
+
+		mutex_exit(&(log_sys->arch_sys_mutex));
+		trx_sys_print_mysql_binlog_offset();
+
+		snprintf(archive_file_name + dirnamelen,
+				OS_FILE_MAX_PATH, "%s%016lld",
+				IB_ARCHIVED_LOGS_PREFIX,
+				log_sys->archived_lsn);
+
+		if (final_dirnamelen) {
+			snprintf(final_file_name + final_dirnamelen,
+					OS_FILE_MAX_PATH, "%s%016lld",
+					IB_ARCHIVED_LOGS_PREFIX,
+					log_sys->archived_lsn);
+		}
+
+		hdr_offset = log_group_calc_lsn_offset(
+					log_sys->archived_lsn, group)
+			/ group->file_size * group->file_size / UNIV_PAGE_SIZE;
+
+		success = fil_rotate_file(group->space_id, hdr_offset,
+					archive_file_name, new_file_name,
+					LOG_FILE_HDR_SIZE);
+
+		if (success) {
+			mutex_enter(&(log_sys->arch_sys_mutex));
+			log_sys->archived_lsn += group->file_size
+				- LOG_FILE_HDR_SIZE;
+			os_event_set(log_sys->arch_event_rotate_done);
+			mutex_exit(&(log_sys->arch_sys_mutex));
+			next_is_prepared = FALSE;
+
+			if (log_xtra_log_archive_dir &&
+					!os_file_rename_throttled(
+						archive_file_name,
+						final_file_name,
+						log_xtra_log_arch_throttle)
+	
+			   ) {
+				fprintf(stderr, "InnoDB: Note: "
+						"moving archived log to "
+						"%s was failed\n",
+						final_file_name);
+			}
+
+			if (log_xtra_log_arch_expire_sec) {
+				purge_archived_logs(ut_time()
+						- log_xtra_log_arch_expire_sec,
+						0);
+			}
+
+
+			goto retry_create_file;
+		} else {
+			fprintf(stderr,
+				"InnoDB: Error: archiving %s was failed\n"
+				"        will retry 10 seconds later again.\n",
+				archive_file_name);
+			os_thread_sleep(10000000);
+			goto retry_create_file;
+		}
+	} else {
+		mutex_exit(&(log_sys->arch_sys_mutex));
+	}
+
+	if (srv_shutdown_state > 0 || log_xtra_log_archive_on == FALSE) {
+		fprintf(stderr,
+				"InnoDB: stopping transaction log archiving\n"
+		       );
+		goto exit_func;
+	}
+
+	os_event_wait(log_sys->arch_event_rotate_start);
+
+	goto loop;
+
+exit_func:
+	os_event_set(log_sys->arch_event_rotate_done);
+
+	if(srv_shutdown_state == 0) {
+		log_calc_max_ages();
+		log_check_margins();
+	}
+
+	mutex_enter(&kernel_mutex);
+	srv_n_threads_active[SRV_ARCHIVE]--;
+	mutex_exit(&kernel_mutex);
+	os_thread_exit(NULL);
+
+	OS_THREAD_DUMMY_RETURN; /* srv_log_archive_thread() */
+}
+
 /*******************************************************************//**
 Tells the InnoDB server that there has been activity in the database
 and wakes up the master thread if it is suspended (not sleeping). Used

=== modified file 'Percona-Server/storage/innodb_plugin/srv/srv0start.c'
--- Percona-Server/storage/innodb_plugin/srv/srv0start.c	2011-11-24 02:00:47 +0000
+++ Percona-Server/storage/innodb_plugin/srv/srv0start.c	2012-04-25 22:22:24 +0000
@@ -127,9 +127,9 @@
 static ulint		ios;
 
 /** io_handler_thread parameters for thread identification */
-static ulint		n[SRV_MAX_N_IO_THREADS + 7 + UNIV_MAX_PARALLELISM];
+static ulint		n[SRV_MAX_N_IO_THREADS + 8 + UNIV_MAX_PARALLELISM];
 /** io_handler_thread identifiers */
-static os_thread_id_t	thread_ids[SRV_MAX_N_IO_THREADS + 7 + UNIV_MAX_PARALLELISM];
+static os_thread_id_t	thread_ids[SRV_MAX_N_IO_THREADS + 8 + UNIV_MAX_PARALLELISM];
 
 /** We use this mutex to test the return value of pthread_mutex_trylock
    on successful locking. HP-UX does NOT return 0, though Linux et al do. */
@@ -490,12 +490,6 @@
 }
 #endif /* !UNIV_HOTBACKUP */
 
-#ifdef __WIN__
-#define SRV_PATH_SEPARATOR	'\\'
-#else
-#define SRV_PATH_SEPARATOR	'/'
-#endif
-
 /*********************************************************************//**
 Normalizes a directory path for Windows: converts slashes to backslashes. */
 UNIV_INTERN
@@ -520,7 +514,6 @@
 Calculates the low 32 bits when a file size which is given as a number
 database pages is converted to the number of bytes.
 @return	low 32 bytes of file size when expressed in bytes */
-static
 ulint
 srv_calc_low32(
 /*===========*/
@@ -533,7 +526,6 @@
 Calculates the high 32 bits when a file size which is given as a number
 database pages is converted to the number of bytes.
 @return	high 32 bytes of file size when expressed in bytes */
-static
 ulint
 srv_calc_high32(
 /*============*/
@@ -1880,6 +1872,12 @@
 	os_thread_create(&srv_LRU_dump_restore_thread, NULL,
 			 thread_ids + 5 + SRV_MAX_N_IO_THREADS);
 
+	/* Create the thread which archives transaction log files */
+	if (log_xtra_log_archive_on) {
+		os_thread_create(&srv_log_archive_thread, NULL,
+				 thread_ids + 6 + SRV_MAX_N_IO_THREADS);
+	}
+
 	/* If srv_blocking_lru_restore is TRUE, load buffer pool contents
 	synchronously */
 	if (srv_auto_lru_dump && srv_blocking_lru_restore)
@@ -1909,13 +1907,13 @@
 		ulint i;
 
 		os_thread_create(&srv_purge_thread, NULL, thread_ids
-				 + (6 + SRV_MAX_N_IO_THREADS));
+				 + (7 + SRV_MAX_N_IO_THREADS));
 
 		for (i = 0; i < srv_use_purge_thread - 1; i++) {
-			n[7 + i + SRV_MAX_N_IO_THREADS] = i; /* using as index for arrays in purge_sys */
+			n[8 + i + SRV_MAX_N_IO_THREADS] = i; /* using as index for arrays in purge_sys */
 			os_thread_create(&srv_purge_worker_thread,
-					 n + (7 + i + SRV_MAX_N_IO_THREADS),
-					 thread_ids + (7 + i + SRV_MAX_N_IO_THREADS));
+					 n + (8 + i + SRV_MAX_N_IO_THREADS),
+					 thread_ids + (8 + i + SRV_MAX_N_IO_THREADS));
 		}
 	}
 #ifdef UNIV_DEBUG

=== modified file 'doc/source/index.rst'
--- doc/source/index.rst	2012-04-02 09:36:37 +0000
+++ doc/source/index.rst	2012-04-25 22:22:24 +0000
@@ -126,6 +126,7 @@
    management/udf_maatkit
    management/innodb_fake_changes
    management/innodb_kill_idle_trx
+   management/innodb_log_archiving
 
 Diagnostics Improvements
 ========================

=== added file 'doc/source/management/innodb_log_archiving.rst'
--- doc/source/management/innodb_log_archiving.rst	1970-01-01 00:00:00 +0000
+++ doc/source/management/innodb_log_archiving.rst	2012-04-25 22:22:24 +0000
@@ -0,0 +1,59 @@
+.. _innodb_fast_index_creation:
+
+=====================
+ Innodb Log archiving
+=====================
+
+The purpose of archiving logs is to be able to use them as a form of incremental backup.
+
+By replaying archived logs since the last backup taken with xtrabackup, you can get an online incremental backup.
+
+When log archiving is enabled, instead of rotating through log files, XtraDB will create a new one. There should always be one spare log file so that transactions are never stalled at log file rotation.
+
+``PURGE ARCHIVE LOGS``
+================
+
+Syntax:
+
+PURGE ARCHIVED LOGS { TO 'filename' | BEFORE `datetime`}
+
+Examples:
+
+PURGE ARCHIVED LOGS TO 'ib_log_archive_000262325167341';
+
+PURGE ARCHIVED LOGS BEFORE '2008-04-02 22:46:26';
+
+
+
+System Variables
+================
+
+.. variable:: innodb_xtra_log_archive
+
+     :cli: Yes
+     :conf: Yes
+     :scope: Global
+     :dyn: Yes
+     :vartype: Boolean
+     :default: OFF
+     :range: ON/OFF
+
+.. variable:: innodb_xtra_log_archive_dir
+
+     :cli: Yes
+     :conf: Yes
+     :scope: Global
+     :dyn: No
+     :vartype: String
+     :default: ''
+
+.. variable:: innodb_xtra_expire_archive_logs_sec
+
+     :cli: Yes
+     :conf: Yes
+     :scope: Global
+     :dyn: Yes
+     :vartype: Integer
+     :default: 0
+     :range: 0-
+