Merge lp:~akopytov/percona-server/bug1131189-5.6 into lp:percona-server/5.6

[Alexey Kopytov]

http://jenkins.percona.com/view/PS%205.6/job/percona-server-5.6-param/118/

[Laurynas Biveinis (laurynas-biveinis)]

    - The patch would be OK, but I did find one issue which IMHO
      requires recommitting (although the test cycle could be
      skipped) or follow-up addressing (I don't have a strong opinion
      on recomitting vs follow-up): trx_rw_is_active_low is a
      bool-returning function that returns NULL in one of the code
      paths.

    - If we are recommitting, then in_trx_serial_list should be bool,
      not ibool as well, and true/false used instead of 0/1 for
      setting it, spurious newline at diff line 278. The row0sel.cc
      change is spurious as well?

    Random remark:

    - trx_descr_cmp() should be defined in trx0trx.ic, not .c? So
      then compiler can resolve the function pointer to inlining. It
      is also possible to use std::binary_search() in the brave new
      C++ world.

    Last and least absolutely random remarks:

    - I don't fully understand the header comment for
      trx_rw_get_active_trx_by_id() stating that the returned pointer
      must not be dereferenced unless lock_sys->mutex is held. But
      the function itself dereferences the pointer in
      trx_state_eq()? I see that all callers hold the
      lock_sys->mutex, thus it does not seem to be a real issue
      though.

    - Upstream started making heavy use of __attribute__ function
      annotations to cause extra warnings on misuse, especially
      nonnull, warn_unused_result. Maybe not bad idea for us well
      where it applies.

review: Needs Fixing

[Laurynas Biveinis (laurynas-biveinis)]

Will merge as-is and handle the minor issues in a follow-up.

review: Approve

[Alexey Kopytov (akopytov)]

Hi Laurynas,

On Fri, 24 May 2013 14:22:31 -0000, Laurynas Biveinis wrote:
> Review: Needs Fixing
>
> - The patch would be OK, but I did find one issue which IMHO
> requires recommitting (although the test cycle could be
> skipped) or follow-up addressing (I don't have a strong opinion
> on recomitting vs follow-up): trx_rw_is_active_low is a
> bool-returning function that returns NULL in one of the code
> paths.

Right, good catch! Thanks for fixing it as a followup.

>
> - If we are recommitting, then in_trx_serial_list should be bool,
> not ibool as well, and true/false used instead of 0/1 for
> setting it, spurious newline at diff line 278. The row0sel.cc
> change is spurious as well?
>

I deliberately made it ibool to be consistent with in_ro_trx_list /
in_rw_trx_list (which is also new 5.6 code BTW). But OK.

> Random remark:
>
> - trx_descr_cmp() should be defined in trx0trx.ic, not .c? So
> then compiler can resolve the function pointer to inlining. It
> is also possible to use std::binary_search() in the brave new
> C++ world.
>

bsearch() is a library function, so no inlining is possible. Is it
different with std::binary_search()?

> Last and least absolutely random remarks:
>
> - I don't fully understand the header comment for
> trx_rw_get_active_trx_by_id() stating that the returned pointer
> must not be dereferenced unless lock_sys->mutex is held. But
> the function itself dereferences the pointer in
> trx_state_eq()? I see that all callers hold the
> lock_sys->mutex, thus it does not seem to be a real issue
> though.
>

There's actually an upstream problem with that code, but it only applies
to debug builds. Will report it separately.

> - Upstream started making heavy use of __attribute__ function
> annotations to cause extra warnings on misuse, especially
> nonnull, warn_unused_result. Maybe not bad idea for us well
> where it applies.
>

Yes, that's good stuff.

/Alexey

[Laurynas Biveinis (laurynas-biveinis)]

Ah, indeed trx_descr_cmp() is just a wrapper around bsearch(), thus removing the indirection would not help there.

std::binary_search() 3rd optional arg is a C++ callable object for performing element comparisons. If a function pointer is passed there, then it's the same as with bsearch(), but if a template function object is passed instead, then it's all inlineable.

=== modified file 'Percona-Server/sql/handler.cc'
--- Percona-Server/sql/handler.cc	2013-05-12 06:24:46 +0000
+++ Percona-Server/sql/handler.cc	2013-05-24 12:02:59 +0000
@@ -2516,8 +2516,13 @@
       dup_ref=ref+ALIGN_SIZE(ref_length);
     cached_table_flags= table_flags();
   }
-  rows_read= rows_changed= 0;
-  memset(index_rows_read, 0, sizeof(index_rows_read));
+
+  if (unlikely(opt_userstat))
+  {
+    rows_read= rows_changed= 0;
+    memset(index_rows_read, 0, sizeof(index_rows_read));
+  }
+
   DBUG_RETURN(error);
 }
 
@@ -4667,12 +4672,6 @@
 // Updates the global table stats with the TABLE this handler represents.
 void handler::update_global_table_stats()
 {
-  if (!opt_userstat)
-  {
-    rows_read= rows_changed= 0;
-    return;
-  }
-
   if (!rows_read && !rows_changed)
     return;  // Nothing to update.
   // table_cache_key is db_name + '\0' + table_name + '\0'.
@@ -4730,15 +4729,6 @@
       !table->s->table_name.str)
     return;
 
-  if (!opt_userstat)
-  {
-    for (uint x= 0; x < table->s->keys; ++x)
-    {
-      index_rows_read[x]= 0;
-    }
-    return;
-  }
-
   for (uint x = 0; x < table->s->keys; ++x)
   {
     if (index_rows_read[x])
 
=== modified file 'Percona-Server/sql/sql_base.cc'
--- Percona-Server/sql/sql_base.cc	2013-05-13 04:25:56 +0000
+++ Percona-Server/sql/sql_base.cc	2013-05-24 12:02:59 +0000
@@ -1490,11 +1490,13 @@
   table->mdl_ticket= NULL;
 
   mysql_mutex_lock(&thd->LOCK_thd_data);
-  if(table->file)
+
+  if(unlikely(opt_userstat && table->file))
   {
     table->file->update_global_table_stats();
     table->file->update_global_index_stats();
   }
+
   *table_ptr=table->next;
   mysql_mutex_unlock(&thd->LOCK_thd_data);
 
@@ -2152,8 +2154,12 @@
   DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",
                           table->s->db.str, table->s->table_name.str));
 
-  table->file->update_global_table_stats();
-  table->file->update_global_index_stats();
+  if (unlikely(opt_userstat))
+  {
+    table->file->update_global_table_stats();
+    table->file->update_global_index_stats();
+  }
+
   free_io_cache(table);
   closefrm(table, 0);
   if (delete_table)
 
=== modified file 'Percona-Server/sql/sql_class.cc'
--- Percona-Server/sql/sql_class.cc	2013-05-22 10:51:07 +0000
+++ Percona-Server/sql/sql_class.cc	2013-05-24 12:02:59 +0000
@@ -1520,8 +1520,6 @@
 // Updates 'diff' stats of a THD.
 void THD::update_stats(bool ran_command)
 {
-  if (opt_userstat)
-  {
   diff_total_busy_time+=            busy_time;
   diff_total_cpu_time+=             cpu_time;
   diff_total_bytes_received+=       bytes_received;
@@ -1566,7 +1564,7 @@
   /* reset counters to zero to avoid double-counting since values
      are already store in diff_total_*.
   */
-  }
+
   busy_time=            0;
   cpu_time=             0;
   bytes_received=       0;
 
=== modified file 'Percona-Server/sql/sql_connect.cc'
--- Percona-Server/sql/sql_connect.cc	2013-05-22 10:51:07 +0000
+++ Percona-Server/sql/sql_connect.cc	2013-05-24 12:02:59 +0000
@@ -566,9 +566,6 @@
   const char* client_string= get_client_host(thd);
   int return_value=          0;
 
-  if (!opt_userstat)
-    return return_value;
-
   if (acl_is_utility_user(thd->security_ctx->user, thd->security_ctx->host,
       thd->security_ctx->ip))
     return return_value;
@@ -1383,8 +1380,9 @@
   my_net_set_write_timeout(net, thd->variables.net_write_timeout);
 
   thd->reset_stats();
+
   // Updates global user connection stats.
-  if (increment_connection_count(thd, true))
+  if (opt_userstat && increment_connection_count(thd, true))
     DBUG_RETURN(1);
 
   DBUG_RETURN(0);
@@ -1621,8 +1619,13 @@
 
 end_thread:
     close_connection(thd);
-    thd->update_stats(false);
-    update_global_user_stats(thd, create_user, time(NULL));
+
+    if (unlikely(opt_userstat))
+    {
+      thd->update_stats(false);
+      update_global_user_stats(thd, create_user, time(NULL));
+    }
+
     if (MYSQL_CALLBACK_ELSE(thd->scheduler, end_thread, (thd, 1), 0))
       return;                                 // Probably no-threads
 
 
=== modified file 'Percona-Server/sql/sql_parse.cc'
--- Percona-Server/sql/sql_parse.cc	2013-05-22 10:51:07 +0000
+++ Percona-Server/sql/sql_parse.cc	2013-05-24 12:02:59 +0000
@@ -6545,11 +6545,15 @@
     else
       thd->cpu_time = 0;
   }
+
   // Updates THD stats and the global user stats.
-  thd->update_stats(true);
+  if (unlikely(opt_userstat))
+  {
+    thd->update_stats(true);
 #ifndef EMBEDDED_LIBRARY
-  update_global_user_stats(thd, true, time(NULL));
+    update_global_user_stats(thd, true, time(NULL));
 #endif
+  }
 
   DBUG_VOID_RETURN;
 }
 
=== modified file 'Percona-Server/sql/sql_prepare.cc'
--- Percona-Server/sql/sql_prepare.cc	2013-05-12 06:24:46 +0000
+++ Percona-Server/sql/sql_prepare.cc	2013-05-24 12:02:59 +0000
@@ -2267,7 +2267,7 @@
   double start_cpu_nsecs= 0;
   double end_cpu_nsecs=   0;
 
-  if (opt_userstat)
+  if (unlikely(opt_userstat))
   {
 #ifdef HAVE_CLOCK_GETTIME
     /* get start cputime */
@@ -2309,7 +2309,7 @@
 
   /* check_prepared_statemnt sends the metadata packet in case of success */
 end:
-  if (opt_userstat)
+  if (unlikely(opt_userstat))
   {
     // Gets the end time.
     if (!(end_time_error= gettimeofday(&end_time, NULL)))
@@ -2351,11 +2351,15 @@
     else
       thd->cpu_time = 0;
   }
+
   // Updates THD stats and the global user stats.
-  thd->update_stats(true);
+  if (unlikely(opt_userstat))
+  {
+    thd->update_stats(true);
 #ifndef EMBEDDED_LIBRARY
-  update_global_user_stats(thd, true, time(NULL));
+    update_global_user_stats(thd, true, time(NULL));
 #endif
+  }
 
   DBUG_VOID_RETURN;
 }
@@ -2813,11 +2817,15 @@
     else
       thd->cpu_time = 0;
   }
+
   // Updates THD stats and the global user stats.
-  thd->update_stats(true);
+  if (unlikely(opt_userstat))
+  {
+    thd->update_stats(true);
 #ifndef EMBEDDED_LIBRARY
-  update_global_user_stats(thd, true, time(NULL));
+    update_global_user_stats(thd, true, time(NULL));
 #endif
+  }
 
   DBUG_VOID_RETURN;
 }
@@ -2990,11 +2998,15 @@
     } else
       thd->cpu_time= 0;
   }
+
   // Updates THD stats and the global user stats.
-  thd->update_stats(true);
+  if (unlikely(opt_userstat))
+  {
+    thd->update_stats(true);
 #ifndef EMBEDDED_LIBRARY
-  update_global_user_stats(thd, true, time(NULL));
+    update_global_user_stats(thd, true, time(NULL));
 #endif
+  }
 
   DBUG_VOID_RETURN;
 }
@@ -3118,11 +3130,15 @@
     else
       thd->cpu_time= 0;
   }
+
   // Updates THD stats and the global user stats.
-  thd->update_stats(true);
+  if (unlikely(opt_userstat))
+  {
+    thd->update_stats(true);
 #ifndef EMBEDDED_LIBRARY
-  update_global_user_stats(thd, true, time(NULL));
+    update_global_user_stats(thd, true, time(NULL));
 #endif
+  }
 
   DBUG_VOID_RETURN;
 }
 
=== modified file 'Percona-Server/storage/innobase/include/read0read.h'
--- Percona-Server/storage/innobase/include/read0read.h	2013-05-23 06:51:50 +0000
+++ Percona-Server/storage/innobase/include/read0read.h	2013-05-24 12:02:59 +0000
@@ -32,6 +32,7 @@
 #include "ut0byte.h"
 #include "ut0lst.h"
 #include "trx0trx.h"
+#include "trx0sys.h"
 #include "read0types.h"
 
 /*********************************************************************//**
@@ -46,6 +47,7 @@
 					transaction, or 0 used in purge */
 	read_view_t*&	view);		/*!< in,out: pre-allocated view array or
 					NULL if a new one needs to be created */
+
 /*********************************************************************//**
 Makes a copy of the oldest existing read view, or opens a new. The view
 must be closed with ..._close.
@@ -154,17 +156,18 @@
 				are strictly smaller (<) than this value.
 				In other words,
 				this is the "low water mark". */
-	ulint		n_trx_ids;
+	ulint		n_descr;
 				/*!< Number of cells in the trx_ids array */
-	ulint		max_trx_ids;
+	ulint		max_descr;
 				/*!< Maximum number of cells in the trx_ids
 				array */
-	trx_id_t*	trx_ids;/*!< Additional trx ids which the read should
+	trx_id_t*	descriptors;
+				/*!< Additional trx ids which the read should
 				not see: typically, these are the read-write
 				active transactions at the time when the read
 				is serialized, except the reading transaction
 				itself; the trx ids in this array are in a
-				descending order. These trx_ids should be
+				ascending order. These trx_ids should be
 				between the "low" and "high" water marks,
 				that is, up_limit_id and low_limit_id. */
 	trx_id_t	creator_trx_id;
 
=== modified file 'Percona-Server/storage/innobase/include/read0read.ic'
--- Percona-Server/storage/innobase/include/read0read.ic	2012-08-22 01:40:20 +0000
+++ Percona-Server/storage/innobase/include/read0read.ic	2013-05-24 12:02:59 +0000
@@ -35,11 +35,13 @@
 	const read_view_t*	view)	/*!< in: view to validate */
 {
 	ut_ad(mutex_own(&trx_sys->mutex));
-
-	/* Check that the view->trx_ids array is in descending order. */
-	for (ulint i = 1; i < view->n_trx_ids; ++i) {
-
-		ut_a(view->trx_ids[i] < view->trx_ids[i - 1]);
+	ut_ad(view->max_descr >= view->n_descr);
+	ut_ad(view->descriptors == NULL || view->max_descr > 0);
+
+	/* Check that the view->descriptors array is in ascending order. */
+	for (ulint i = 1; i < view->n_descr; ++i) {
+
+		ut_a(view->descriptors[i] > view->descriptors[i - 1]);
 	}
 
 	return(true);
@@ -92,31 +94,12 @@
 	} else if (trx_id >= view->low_limit_id) {
 
 		return(false);
-	} else {
-		ulint	lower = 0;
-		ulint	upper = view->n_trx_ids - 1;
-
-		ut_a(view->n_trx_ids > 0);
-
-		do {
-			ulint		mid	= (lower + upper) >> 1;
-			trx_id_t	mid_id	= view->trx_ids[mid];
-
-			if (mid_id == trx_id) {
-				return(FALSE);
-			} else if (mid_id < trx_id) {
-				if (mid > 0) {
-					upper = mid - 1;
-				} else {
-					break;
-				}
-			} else {
-				lower = mid + 1;
-			}
-		} while (lower <= upper);
 	}
 
-	return(true);
+	/* Do a binary search over this view's descriptors array */
+
+	return(trx_find_descriptor(view->descriptors, view->n_descr,
+				   trx_id) == NULL);
 }
 
 /*********************************************************************//**
 
=== modified file 'Percona-Server/storage/innobase/include/trx0sys.h'
--- Percona-Server/storage/innobase/include/trx0sys.h	2013-05-10 09:39:17 +0000
+++ Percona-Server/storage/innobase/include/trx0sys.h	2013-05-24 12:02:59 +0000
@@ -184,6 +184,17 @@
 trx_sys_get_max_trx_id(void);
 /*========================*/
 
+/*************************************************************//**
+Find a slot for a given trx ID in a descriptors array.
+@return: slot pointer */
+UNIV_INLINE
+trx_id_t*
+trx_find_descriptor(
+/*================*/
+	const trx_id_t*	descriptors,	/*!< in: descriptors array */
+	ulint		n_descr,	/*!< in: array size */
+	trx_id_t	trx_id);	/*!< in: trx pointer */
+
 #ifdef UNIV_DEBUG
 /* Flag to control TRX_RSEG_N_SLOTS behavior debugging. */
 extern uint			trx_rseg_n_slots_debug;
@@ -231,14 +242,26 @@
 trx_rw_min_trx_id(void);
 /*===================*/
 /****************************************************************//**
+Returns pointer to a transaction instance if a rw transaction with the given id
+is active. Caller must hold trx_sys->mutex. If the caller is not holding
+lock_sys->mutex, the transaction may already have been committed.
+@return transaction instance if active, or NULL;
+the pointer must not be dereferenced unless lock_sys->mutex was
+acquired before calling this function and is still being held */
+UNIV_INLINE
+trx_t*
+trx_rw_get_active_trx_by_id(
+/*========================*/
+	trx_id_t	trx_id,		/*!< in: trx id of the transaction */
+	ibool*		corrupt);	/*!< in: NULL or pointer to a flag
+					that will be set if corrupt */
+/****************************************************************//**
 Checks if a rw transaction with the given id is active. Caller must hold
-trx_sys->mutex in shared mode. If the caller is not holding
-lock_sys->mutex, the transaction may already have been committed.
-@return	transaction instance if active, or NULL;
-the pointer must not be dereferenced unless lock_sys->mutex was
-acquired before calling this function and is still being held */
+trx_sys->mutex. If the caller is not holding lock_sys->mutex, the
+transaction may already have been committed.
+@return	true if rw transaction it with a given id is active. */
 UNIV_INLINE
-trx_t*
+bool
 trx_rw_is_active_low(
 /*=================*/
 	trx_id_t	trx_id,		/*!< in: trx id of the transaction */
@@ -248,11 +271,9 @@
 Checks if a rw transaction with the given id is active. If the caller is
 not holding lock_sys->mutex, the transaction may already have been
 committed.
-@return	transaction instance if active, or NULL;
-the pointer must not be dereferenced unless lock_sys->mutex was
-acquired before calling this function and is still being held */
+@return	true if rw transaction it with a given id is active. */
 UNIV_INLINE
-trx_t*
+bool
 trx_rw_is_active(
 /*=============*/
 	trx_id_t	trx_id,		/*!< in: trx id of the transaction */
@@ -598,6 +619,8 @@
 	 | TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW)
 /* @} */
 
+#define TRX_DESCR_ARRAY_INITIAL_SIZE 	1000
+
 #ifndef UNIV_HOTBACKUP
 /** The transaction system central memory data structure. */
 struct trx_sys_t{
@@ -618,6 +641,18 @@
 	trx_id_t	max_trx_id;	/*!< The smallest number not yet
 					assigned as a transaction id or
 					transaction number */
+	char		pad1[64];	/*!< Ensure max_trx_id does not share
+					cache line with other fields. */
+	trx_id_t*	descriptors;	/*!< Array of trx descriptors */
+	ulint		descr_n_max;	/*!< The current size of the descriptors
+					array. */
+	char		pad2[64];	/*!< Ensure static descriptor fields
+					do not share cache lines with
+					descr_n_used */
+	ulint		descr_n_used;	/*!< Number of used elements in the
+					descriptors array. */
+	char		pad3[64];	/*!< Ensure descriptors do not share
+					cache line with other fields */
 #ifdef UNIV_DEBUG
 	trx_id_t	rw_max_trx_id;	/*!< Max trx id of read-write transactions
 					which exist or existed */
@@ -626,6 +661,8 @@
 					memory read-write transactions, sorted
 					on trx id, biggest first. Recovered
 					transactions are always on this list. */
+	char		pad4[64];	/*!< Ensure list base nodes do not
+					share cache line with other fields */
 	trx_list_t	ro_trx_list;	/*!< List of active and committed in
 					memory read-only transactions, sorted
 					on trx id, biggest first. NOTE:
@@ -633,6 +670,8 @@
 					is not necessary. We should exploit
 					this and increase concurrency during
 					add/remove. */
+	char		pad5[64];	/*!< Ensure list base nodes do not
+					share cache line with other fields */
 	trx_list_t	mysql_trx_list;	/*!< List of transactions created
 					for MySQL. All transactions on
 					ro_trx_list are on mysql_trx_list. The
@@ -645,6 +684,15 @@
 					mysql_trx_list may additionally contain
 					transactions that have not yet been
 					started in InnoDB. */
+	char		pad6[64];	/*!< Ensure list base nodes do not
+					share cache line with other fields */
+	trx_list_t	trx_serial_list;
+					/*!< trx->no ordered List of
+					transactions in either TRX_PREPARED or
+					TRX_ACTIVE which have already been
+					assigned a serialization number */
+	char		pad7[64];	/*!< Ensure list base nodes do not
+					share cache line with other fields */
 	trx_rseg_t*	const rseg_array[TRX_SYS_N_RSEGS];
 					/*!< Pointer array to rollback
 					segments; NULL if slot not in use;
 
=== modified file 'Percona-Server/storage/innobase/include/trx0sys.ic'
--- Percona-Server/storage/innobase/include/trx0sys.ic	2013-05-10 09:39:17 +0000
+++ Percona-Server/storage/innobase/include/trx0sys.ic	2013-05-24 12:02:59 +0000
@@ -368,16 +368,16 @@
 }
 
 /****************************************************************//**
-Checks if a rw transaction with the given id is active. Caller must hold
-trx_sys->mutex. If the caller is not holding lock_sys->mutex, the
-transaction may already have been committed.
-@return	transaction instance if active, or NULL;
+Returns pointer to a transaction instance if a rw transaction with the given id
+is active. Caller must hold trx_sys->mutex. If the caller is not holding
+lock_sys->mutex, the transaction may already have been committed.
+@return transaction instance if active, or NULL;
 the pointer must not be dereferenced unless lock_sys->mutex was
 acquired before calling this function and is still being held */
 UNIV_INLINE
 trx_t*
-trx_rw_is_active_low(
-/*=================*/
+trx_rw_get_active_trx_by_id(
+/*========================*/
 	trx_id_t	trx_id,		/*!< in: trx id of the transaction */
 	ibool*		corrupt)	/*!< in: NULL or pointer to a flag
 					that will be set if corrupt */
@@ -412,29 +412,58 @@
 }
 
 /****************************************************************//**
+Checks if a rw transaction with the given id is active. Caller must hold
+trx_sys->mutex. If the caller is not holding lock_sys->mutex, the
+transaction may already have been committed.
+@return	true if rw transaction it with a given id is active. */
+UNIV_INLINE
+bool
+trx_rw_is_active_low(
+/*=================*/
+	trx_id_t	trx_id,		/*!< in: trx id of the transaction */
+	ibool*		corrupt)	/*!< in: NULL or pointer to a flag
+					that will be set if corrupt */
+{
+	ut_ad(mutex_own(&trx_sys->mutex));
+
+	if (UNIV_UNLIKELY(trx_id >= trx_sys->max_trx_id)) {
+
+		/* There must be corruption: we let the caller handle the
+		diagnostic prints in this case. */
+
+		if (corrupt != NULL) {
+			*corrupt = TRUE;
+		}
+
+		return(NULL);
+	}
+
+	return(trx_find_descriptor(trx_sys->descriptors, trx_sys->descr_n_used,
+				   trx_id) != NULL);
+}
+
+/****************************************************************//**
 Checks if a rw transaction with the given id is active. If the caller is
 not holding lock_sys->mutex, the transaction may already have been
 committed.
-@return	transaction instance if active, or NULL;
-the pointer must not be dereferenced unless lock_sys->mutex was
-acquired before calling this function and is still being held */
+@return	true if rw transaction it with a given id is active. */
 UNIV_INLINE
-trx_t*
+bool
 trx_rw_is_active(
 /*=============*/
 	trx_id_t	trx_id,		/*!< in: trx id of the transaction */
 	ibool*		corrupt)	/*!< in: NULL or pointer to a flag
 					that will be set if corrupt */
 {
-	trx_t*		trx;
+	bool res;
 
 	mutex_enter(&trx_sys->mutex);
 
-	trx = trx_rw_is_active_low(trx_id, corrupt);
+	res = trx_rw_is_active_low(trx_id, corrupt);
 
 	mutex_exit(&trx_sys->mutex);
 
-	return(trx);
+	return(res);
 }
 
 /*****************************************************************//**
@@ -509,4 +538,28 @@
 
 	return(n_trx);
 }
+
+
+/*************************************************************//**
+Find a slot for a given trx ID in a descriptors array.
+@return: slot pointer */
+UNIV_INLINE
+trx_id_t*
+trx_find_descriptor(
+/*================*/
+	const trx_id_t*	descriptors,	/*!< in: descriptors array */
+	ulint		n_descr,	/*!< in: array size */
+	trx_id_t	trx_id)		/*!< in: trx id */
+{
+	ut_ad(descriptors != trx_sys->descriptors ||
+	      mutex_own(&trx_sys->mutex));
+
+	if (UNIV_UNLIKELY(n_descr == 0)) {
+
+		return(NULL);
+	}
+
+	return((trx_id_t *) bsearch(&trx_id, descriptors, n_descr,
+				    sizeof(trx_id_t), trx_descr_cmp));
+}
 #endif /* !UNIV_HOTBACKUP */
 
=== modified file 'Percona-Server/storage/innobase/include/trx0trx.h'
--- Percona-Server/storage/innobase/include/trx0trx.h	2013-05-23 06:51:50 +0000
+++ Percona-Server/storage/innobase/include/trx0trx.h	2013-05-24 12:02:59 +0000
@@ -459,6 +459,24 @@
 /*============*/
 	trx_t*		trx);		/*!< A read-only transaction that
 					needs to be assigned a RBS. */
+
+/*************************************************************//**
+Callback function for trx_find_descriptor() to compare trx IDs. */
+UNIV_INTERN
+int
+trx_descr_cmp(
+/*==========*/
+	const void *a,	/*!< in: pointer to first comparison argument */
+	const void *b);	/*!< in: pointer to second comparison argument */
+
+/*************************************************************//**
+Release a slot for a given trx in the global descriptors array. */
+UNIV_INTERN
+void
+trx_release_descriptor(
+/*===================*/
+	trx_t* trx);	/*!< in: trx pointer */
+
 /*******************************************************************//**
 Transactions that aren't started by the MySQL server don't set
 the trx_t::mysql_thd field. For such transactions we set the lock
@@ -892,6 +910,12 @@
 					/*!< TRUE if in
 					trx_sys->mysql_trx_list */
 #endif /* UNIV_DEBUG */
+	UT_LIST_NODE_T(trx_t)
+			trx_serial_list;/*!< list node for
+					trx_sys->trx_serial_list */
+	ibool		in_trx_serial_list;
+					/* Set when transaction is in the
+					trx_serial_list */
 	/*------------------------------*/
 	dberr_t		error_state;	/*!< 0 if no error, otherwise error
 					number; NOTE That ONLY the thread
 
=== modified file 'Percona-Server/storage/innobase/lock/lock0lock.cc'
--- Percona-Server/storage/innobase/lock/lock0lock.cc	2013-05-12 09:13:00 +0000
+++ Percona-Server/storage/innobase/lock/lock0lock.cc	2013-05-24 12:02:59 +0000
@@ -5556,7 +5556,7 @@
 		if the check and assertion are covered by the lock mutex. */
 
 		trx_id = lock_clust_rec_some_has_impl(rec, index, offsets);
-		impl_trx = trx_rw_is_active_low(trx_id, NULL);
+		impl_trx = trx_rw_get_active_trx_by_id(trx_id, NULL);
 
 		ut_ad(lock_mutex_own());
 		/* impl_trx cannot be committed until lock_mutex_exit()
@@ -6055,7 +6055,9 @@
 		/* If the transaction is still active and has no
 		explicit x-lock set on the record, set one for it */
 
-		impl_trx = trx_rw_is_active(trx_id, NULL);
+		mutex_enter(&trx_sys->mutex);
+		impl_trx = trx_rw_get_active_trx_by_id(trx_id, NULL);
+		mutex_exit(&trx_sys->mutex);
 
 		/* impl_trx cannot be committed until lock_mutex_exit()
 		because lock_trx_release_locks() acquires lock_sys->mutex */
@@ -6843,8 +6845,12 @@
 	}
 
 	/* The transition of trx->state to TRX_STATE_COMMITTED_IN_MEMORY
-	is protected by both the lock_sys->mutex and the trx->mutex. */
+	is protected by both the lock_sys->mutex and the trx->mutex.
+	We also lock trx_sys->mutex, because state transition to
+	TRX_STATE_COMMITTED_IN_MEMORY must be atomic with removing trx
+	from the descriptors array. */
 	lock_mutex_enter();
+	mutex_enter(&trx_sys->mutex);
 	trx_mutex_enter(trx);
 
 	/* The following assignment makes the transaction committed in memory
@@ -6863,6 +6869,8 @@
 
 	/*--------------------------------------*/
 	trx->state = TRX_STATE_COMMITTED_IN_MEMORY;
+	/* The following also removes trx from trx_serial_list */
+	trx_release_descriptor(trx);
 	/*--------------------------------------*/
 
 	/* If the background thread trx_rollback_or_clean_recovered()
@@ -6880,6 +6888,8 @@
 
 	trx_mutex_exit(trx);
 
+	mutex_exit(&trx_sys->mutex);
+
 	lock_release(trx);
 
 	lock_mutex_exit();
 
=== modified file 'Percona-Server/storage/innobase/read/read0read.cc'
--- Percona-Server/storage/innobase/read/read0read.cc	2013-05-23 06:51:50 +0000
+++ Percona-Server/storage/innobase/read/read0read.cc	2013-05-24 12:02:59 +0000
@@ -189,23 +189,23 @@
 	if (view == NULL) {
 		view = static_cast<read_view_t*>(
 			ut_malloc(sizeof(read_view_t)));
-		view->max_trx_ids = 0;
-		view->trx_ids = NULL;
+		view->max_descr = 0;
+		view->descriptors = NULL;
 	}
 
-	if (UNIV_UNLIKELY(view->max_trx_ids < n)) {
+	if (UNIV_UNLIKELY(view->max_descr < n)) {
 
-		/* avoid frequent reallocations by extending the array to the
+		/* avoid frequent re-allocations by extending the array to the
 		desired size + 10% */
 
-		view->max_trx_ids = n + n / 10;
-		view->trx_ids = static_cast<trx_id_t*>(
-			ut_realloc(view->trx_ids,
-				   view->max_trx_ids *
-				   sizeof *view->trx_ids));
+		view->max_descr = n + n / 10;
+		view->descriptors = static_cast<trx_id_t*>(
+			ut_realloc(view->descriptors,
+				   view->max_descr *
+				   sizeof *view->descriptors));
 	}
 
-	view->n_trx_ids = n;
+	view->n_descr = n;
 
 	return(view);
 }
@@ -225,24 +225,24 @@
 						NULL */
 {
 	read_view_t*	clone;
-	trx_id_t*	old_trx_ids;
-	ulint		old_max_trx_ids;
+	trx_id_t*	old_descriptors;
+	ulint		old_max_descr;
 
 	ut_ad(mutex_own(&trx_sys->mutex));
 
-	clone = read_view_create_low(view->n_trx_ids, prebuilt_clone);
+	clone = read_view_create_low(view->n_descr, prebuilt_clone);
 
-	old_trx_ids = clone->trx_ids;
-	old_max_trx_ids = clone->max_trx_ids;
+	old_descriptors = clone->descriptors;
+	old_max_descr = clone->max_descr;
 
 	memcpy(clone, view, sizeof(*view));
 
-	clone->trx_ids = old_trx_ids;
-	clone->max_trx_ids = old_max_trx_ids;
+	clone->descriptors = old_descriptors;
+	clone->max_descr = old_max_descr;
 
-	if (view->n_trx_ids) {
-		memcpy(clone->trx_ids, view->trx_ids,
-		       view->n_trx_ids * sizeof(trx_id_t));
+	if (view->n_descr) {
+		memcpy(clone->descriptors, view->descriptors,
+		       view->n_descr * sizeof(trx_id_t));
 	}
 
 	return(clone);
@@ -280,53 +280,6 @@
 	ut_ad(read_view_list_validate());
 }
 
-/** Functor to create thew view trx_ids array. */
-struct	CreateView {
-
-	CreateView(read_view_t*	view)
-		: m_view(view)
-	{
-		  m_n_trx = m_view->n_trx_ids;
-		  m_view->n_trx_ids = 0;
-	}
-
-	void	operator()(const trx_t* trx)
-	{
-		ut_ad(mutex_own(&trx_sys->mutex));
-		ut_ad(trx->in_rw_trx_list);
-
-		/* trx->state cannot change from or to NOT_STARTED
-		while we are holding the trx_sys->mutex. It may change
-		from ACTIVE to PREPARED or COMMITTED. */
-
-		if (trx->id != m_view->creator_trx_id
-		    && !trx_state_eq(trx, TRX_STATE_COMMITTED_IN_MEMORY)) {
-
-			ut_ad(m_n_trx > m_view->n_trx_ids);
-
-			m_view->trx_ids[m_view->n_trx_ids++] = trx->id;
-
-			/* NOTE that a transaction whose trx number is <
-			trx_sys->max_trx_id can still be active, if it is
-			in the middle of its commit! Note that when a
-			transaction starts, we initialize trx->no to
-			IB_ULONGLONG_MAX. */
-
-			/* trx->no is protected by trx_sys->mutex, which
-			we are holding. It is assigned by trx_commit()
-			before lock_trx_release_locks() assigns
-			trx->state = TRX_STATE_COMMITTED_IN_MEMORY. */
-
-			if (m_view->low_limit_no > trx->no) {
-				m_view->low_limit_no = trx->no;
-			}
-		}
-	}
-
-	read_view_t*	m_view;
-	ulint		m_n_trx;
-};
-
 /*********************************************************************//**
 Opens a read view where exactly the transactions serialized before this
 point in time are seen in the view.
@@ -340,11 +293,12 @@
 	read_view_t*&	view)		/*!< in,out: pre-allocated view array or
 					NULL if a new one needs to be created */
 {
-	ulint		n_trx = UT_LIST_GET_LEN(trx_sys->rw_trx_list);
+	trx_id_t*	descr;
+	ulint		i;
 
 	ut_ad(mutex_own(&trx_sys->mutex));
 
-	view = read_view_create_low(n_trx, view);
+	view = read_view_create_low(trx_sys->descr_n_used, view);
 
 	view->undo_no = 0;
 	view->type = VIEW_NORMAL;
@@ -355,13 +309,52 @@
 	view->low_limit_no = trx_sys->max_trx_id;
 	view->low_limit_id = view->low_limit_no;
 
-	/* No active transaction should be visible, except cr_trx */
-
-	ut_list_map(trx_sys->rw_trx_list, &trx_t::trx_list, CreateView(view));
-
-	if (view->n_trx_ids > 0) {
+	descr = trx_find_descriptor(trx_sys->descriptors,
+				    trx_sys->descr_n_used,
+				    cr_trx_id);
+	if (UNIV_LIKELY(descr != NULL)) {
+		ut_ad(trx_sys->descr_n_used > 0);
+		ut_ad(view->n_descr > 0);
+
+		view->n_descr--;
+
+		i = descr - trx_sys->descriptors;
+	} else {
+		i = trx_sys->descr_n_used;
+	}
+
+	if (UNIV_LIKELY(i > 0)) {
+		/* Copy the [0; i-1] range */
+		memcpy(view->descriptors, trx_sys->descriptors,
+		       i * sizeof(trx_id_t));
+	}
+
+	if (UNIV_UNLIKELY(i + 1 < trx_sys->descr_n_used)) {
+		/* Copy the [i+1; descr_n_used-1] range */
+		memcpy(view->descriptors + i,
+		       trx_sys->descriptors + i + 1,
+		       (trx_sys->descr_n_used - i - 1) *
+		       sizeof(trx_id_t));
+ 	}
+
+	/* NOTE that a transaction whose trx number is < trx_sys->max_trx_id can
+	still be active, if it is in the middle of its commit! Note that when a
+	transaction starts, we initialize trx->no to IB_ULONGLONG_MAX. */
+
+	if (UT_LIST_GET_LEN(trx_sys->trx_serial_list) > 0) {
+
+		trx_id_t	trx_no;
+
+		trx_no = UT_LIST_GET_FIRST(trx_sys->trx_serial_list)->no;
+
+		if (trx_no < view->low_limit_no) {
+			view->low_limit_no = trx_no;
+		}
+	}
+
+	if (UNIV_LIKELY(view->n_descr > 0)) {
 		/* The last active transaction has the smallest id: */
-		view->up_limit_id = view->trx_ids[view->n_trx_ids - 1];
+		view->up_limit_id = view->descriptors[0];
 	} else {
 		view->up_limit_id = view->low_limit_id;
 	}
@@ -442,29 +435,29 @@
 	ut_a(oldest_view->creator_trx_id > 0);
 	creator_trx_id = oldest_view->creator_trx_id;
 
-	view = read_view_create_low(oldest_view->n_trx_ids + 1, prebuilt_view);
+	view = read_view_create_low(oldest_view->n_descr + 1, prebuilt_view);
 
 	/* Add the creator transaction id in the trx_ids array in the
 	correct slot. */
 
-	for (i = 0; i < oldest_view->n_trx_ids; ++i) {
+	for (i = 0; i < oldest_view->n_descr; ++i) {
 		trx_id_t	id;
 
-		id = oldest_view->trx_ids[i - insert_done];
+		id = oldest_view->descriptors[i - insert_done];
 
-		if (insert_done == 0 && creator_trx_id > id) {
+		if (insert_done == 0 && creator_trx_id < id) {
 			id = creator_trx_id;
 			insert_done = 1;
 		}
 
-		view->trx_ids[i] = id;
+		view->descriptors[i] = id;
 	}
 
 	if (insert_done == 0) {
-		view->trx_ids[i] = creator_trx_id;
+		view->descriptors[i] = creator_trx_id;
 	} else {
 		ut_a(i > 0);
-		view->trx_ids[i] = oldest_view->trx_ids[i - 1];
+		view->descriptors[i] = oldest_view->descriptors[i - 1];
 	}
 
 	view->creator_trx_id = 0;
@@ -472,10 +465,10 @@
 	view->low_limit_no = oldest_view->low_limit_no;
 	view->low_limit_id = oldest_view->low_limit_id;
 
-	if (view->n_trx_ids > 0) {
+	if (view->n_descr > 0) {
 		/* The last active transaction has the smallest id: */
 
-		view->up_limit_id = view->trx_ids[view->n_trx_ids - 1];
+		view->up_limit_id = view->descriptors[0];
 	} else {
 		view->up_limit_id = oldest_view->up_limit_id;
 	}
@@ -531,11 +524,11 @@
 
 	fprintf(file, "Read view individually stored trx ids:\n");
 
-	n_ids = view->n_trx_ids;
+	n_ids = view->n_descr;
 
 	for (i = 0; i < n_ids; i++) {
 		fprintf(file, "Read view trx id " TRX_ID_FMT "\n",
-			view->trx_ids[i]);
+			view->descriptors[i]);
 	}
 }
 
@@ -582,8 +575,8 @@
 		return;
 	}
 
-	if (view->trx_ids != NULL) {
-		ut_free(view->trx_ids);
+	if (view->descriptors != NULL) {
+		ut_free(view->descriptors);
 	}
 
 	ut_free(view);
@@ -604,7 +597,6 @@
 {
 	read_view_t*	view;
 	mem_heap_t*	heap;
-	ulint		n_trx;
 	cursor_view_t*	curview;
 
 	/* Use larger heap than in trx_create when creating a read_view
@@ -625,36 +617,12 @@
 
 	mutex_enter(&trx_sys->mutex);
 
-	n_trx = UT_LIST_GET_LEN(trx_sys->rw_trx_list);
-
 	curview->read_view = NULL;
-	read_view_create_low(n_trx, curview->read_view);
+	read_view_open_now_low(UINT64_UNDEFINED, curview->read_view);
 
 	view = curview->read_view;
 	view->undo_no = cr_trx->undo_no;
 	view->type = VIEW_HIGH_GRANULARITY;
-	view->creator_trx_id = UINT64_UNDEFINED;
-
-	/* No future transactions should be visible in the view */
-
-	view->low_limit_no = trx_sys->max_trx_id;
-	view->low_limit_id = view->low_limit_no;
-
-	/* No active transaction should be visible */
-
-	ut_list_map(trx_sys->rw_trx_list, &trx_t::trx_list, CreateView(view));
-
-	view->creator_trx_id = cr_trx->id;
-
-	if (view->n_trx_ids > 0) {
-		/* The last active transaction has the smallest id: */
-
-		view->up_limit_id = view->trx_ids[view->n_trx_ids - 1];
-	} else {
-		view->up_limit_id = view->low_limit_id;
-	}
-
-	read_view_add(view);
 
 	mutex_exit(&trx_sys->mutex);
 
 
=== modified file 'Percona-Server/storage/innobase/row/row0sel.cc'
--- Percona-Server/storage/innobase/row/row0sel.cc	2013-05-23 06:51:50 +0000
+++ Percona-Server/storage/innobase/row/row0sel.cc	2013-05-24 12:02:59 +0000
@@ -5205,8 +5205,8 @@
 		if (trx->isolation_level >= TRX_ISO_REPEATABLE_READ
 		    && !trx->read_view) {
 
-			trx->read_view = read_view_open_now(
-				trx->id, trx->prebuilt_view);
+			trx->read_view = read_view_open_now(trx->id,
+							    trx->prebuilt_view);
 
 			trx->global_read_view = trx->read_view;
 		}
 
=== modified file 'Percona-Server/storage/innobase/row/row0vers.cc'
--- Percona-Server/storage/innobase/row/row0vers.cc	2013-05-10 09:39:17 +0000
+++ Percona-Server/storage/innobase/row/row0vers.cc	2013-05-24 12:02:59 +0000
@@ -646,7 +646,7 @@
 	version = rec;
 
 	for (;;) {
-		const trx_t*	version_trx;
+		trx_id_t*	version_trx_descr;
 		mem_heap_t*	heap2;
 		rec_t*		prev_version;
 		trx_id_t	version_trx_id;
@@ -657,19 +657,16 @@
 		}
 
 		mutex_enter(&trx_sys->mutex);
-		version_trx = trx_get_rw_trx_by_id(version_trx_id);
+		version_trx_descr = trx_find_descriptor(trx_sys->descriptors,
+							trx_sys->descr_n_used,
+							version_trx_id);
 		/* Because version_trx is a read-write transaction,
 		its state cannot change from or to NOT_STARTED while
 		we are holding the trx_sys->mutex.  It may change from
 		ACTIVE to PREPARED or COMMITTED. */
-		if (version_trx
-		    && trx_state_eq(version_trx,
-				    TRX_STATE_COMMITTED_IN_MEMORY)) {
-			version_trx = NULL;
-		}
 		mutex_exit(&trx_sys->mutex);
 
-		if (!version_trx) {
+		if (!version_trx_descr) {
 committed_version_trx:
 			/* We found a version that belongs to a
 			committed transaction: return it. */
 
=== modified file 'Percona-Server/storage/innobase/trx/trx0sys.cc'
--- Percona-Server/storage/innobase/trx/trx0sys.cc	2013-05-12 06:24:46 +0000
+++ Percona-Server/storage/innobase/trx/trx0sys.cc	2013-05-24 12:02:59 +0000
@@ -506,6 +506,13 @@
 
 	mtr_start(&mtr);
 
+	/* Allocate the trx descriptors array */
+	trx_sys->descriptors = static_cast<trx_id_t*>(
+		ut_malloc(sizeof(trx_id_t) *
+			  TRX_DESCR_ARRAY_INITIAL_SIZE));
+	trx_sys->descr_n_max = TRX_DESCR_ARRAY_INITIAL_SIZE;
+	trx_sys->descr_n_used = 0;
+
 	sys_header = trx_sysf_get(&mtr);
 
 	if (srv_force_recovery < SRV_FORCE_NO_UNDO_LOG_SCAN) {
@@ -1232,6 +1239,9 @@
 
 	mutex_free(&trx_sys->mutex);
 
+	ut_ad(trx_sys->descr_n_used == 0);
+	ut_free(trx_sys->descriptors);
+
 	mem_free(trx_sys);
 
 	trx_sys = NULL;
 
=== modified file 'Percona-Server/storage/innobase/trx/trx0trx.cc'
--- Percona-Server/storage/innobase/trx/trx0trx.cc	2013-05-23 06:51:50 +0000
+++ Percona-Server/storage/innobase/trx/trx0trx.cc	2013-05-24 12:02:59 +0000
@@ -83,6 +83,127 @@
 			    sizeof(trx->detailed_error));
 }
 
+/*************************************************************//**
+Callback function for trx_find_descriptor() to compare trx IDs. */
+UNIV_INTERN
+int
+trx_descr_cmp(
+/*==========*/
+	const void *a,	/*!< in: pointer to first comparison argument */
+	const void *b)	/*!< in: pointer to second comparison argument */
+{
+	const trx_id_t*	da = (const trx_id_t*) a;
+	const trx_id_t*	db = (const trx_id_t*) b;
+
+	if (*da < *db) {
+		return -1;
+	} else if (*da > *db) {
+		return 1;
+	}
+
+	return 0;
+}
+
+/*************************************************************//**
+Reserve a slot for a given trx in the global descriptors array. */
+UNIV_INLINE
+void
+trx_reserve_descriptor(
+/*===================*/
+	const trx_t* trx)	/*!< in: trx pointer */
+{
+	ulint		n_used;
+	ulint		n_max;
+	trx_id_t*	descr;
+
+	ut_ad(mutex_own(&trx_sys->mutex) || srv_is_being_started);
+	ut_ad(srv_is_being_started ||
+	      !trx_find_descriptor(trx_sys->descriptors,
+				   trx_sys->descr_n_used,
+				   trx->id));
+
+	n_used = trx_sys->descr_n_used + 1;
+	n_max = trx_sys->descr_n_max;
+
+	if (UNIV_UNLIKELY(n_used > n_max)) {
+
+		n_max = n_max * 2;
+
+		trx_sys->descriptors = static_cast<trx_id_t*>(
+			ut_realloc(trx_sys->descriptors,
+				   n_max * sizeof(trx_id_t)));
+
+		trx_sys->descr_n_max = n_max;
+	}
+
+	descr = trx_sys->descriptors + n_used - 1;
+
+	if (UNIV_UNLIKELY(n_used > 1 && trx->id < descr[-1])) {
+
+		/* Find the slot where it should be inserted. We could use a
+		binary search, but in reality linear search should be faster,
+		because the slot we are looking for is near the array end. */
+
+		trx_id_t*	tdescr;
+
+		for (tdescr = descr - 1;
+		     tdescr >= trx_sys->descriptors && *tdescr > trx->id;
+		     tdescr--) {
+		}
+
+		tdescr++;
+
+		ut_memmove(tdescr + 1, tdescr, (descr - tdescr) *
+			   sizeof(trx_id_t));
+
+		descr = tdescr;
+	}
+
+	*descr = trx->id;
+
+	trx_sys->descr_n_used = n_used;
+}
+
+/*************************************************************//**
+Release a slot for a given trx in the global descriptors array. */
+UNIV_INTERN
+void
+trx_release_descriptor(
+/*===================*/
+	trx_t* trx)	/*!< in: trx pointer */
+{
+	ulint		size;
+	trx_id_t*	descr;
+
+	ut_ad(mutex_own(&trx_sys->mutex));
+
+	if (UNIV_LIKELY(trx->in_trx_serial_list)) {
+
+		UT_LIST_REMOVE(trx_serial_list, trx_sys->trx_serial_list,
+			       trx);
+		trx->in_trx_serial_list = 0;
+	}
+
+	descr = trx_find_descriptor(trx_sys->descriptors,
+				    trx_sys->descr_n_used,
+				    trx->id);
+
+	if (UNIV_UNLIKELY(descr == NULL)) {
+
+		return;
+	}
+
+	size = (trx_sys->descriptors + trx_sys->descr_n_used - 1 - descr) *
+		sizeof(trx_id_t);
+
+	if (UNIV_LIKELY(size > 0)) {
+
+		ut_memmove(descr, descr + 1, size);
+	}
+
+	trx_sys->descr_n_used--;
+}
+
 /****************************************************************//**
 Creates and initializes a transaction object. It must be explicitly
 started with trx_start_if_not_started() before using it. The default
@@ -108,6 +229,7 @@
 	trx->isolation_level = TRX_ISO_REPEATABLE_READ;
 
 	trx->no = IB_ULONGLONG_MAX;
+	trx->in_trx_serial_list = 0;
 
 	trx->support_xa = TRUE;
 
@@ -207,11 +329,12 @@
 }
 
 /********************************************************************//**
-Frees a transaction object. */
+Frees a transaction object without releasing the corresponding descriptor.
+Should be used by callers that already own trx_sys->mutex. */
 static
 void
-trx_free(
-/*=====*/
+trx_free_low(
+/*=========*/
 	trx_t*	trx)	/*!< in, own: trx object */
 {
 	ut_a(trx->magic_n == TRX_MAGIC_N);
@@ -255,6 +378,21 @@
 }
 
 /********************************************************************//**
+Frees a transaction object. */
+static
+void
+trx_free(
+/*=========*/
+	trx_t*	trx)	/*!< in, own: trx object */
+{
+	mutex_enter(&trx_sys->mutex);
+	trx_release_descriptor(trx);
+	mutex_exit(&trx_sys->mutex);
+
+	trx_free_low(trx);
+}
+
+/********************************************************************//**
 Frees a transaction object of a background operation of the master thread. */
 UNIV_INTERN
 void
@@ -328,7 +466,11 @@
 	UT_LIST_REMOVE(trx_list, trx_sys->rw_trx_list, trx);
 	ut_d(trx->in_rw_trx_list = FALSE);
 
-	trx_free(trx);
+	trx_release_descriptor(trx);
+
+	trx_free_low(trx);
+
+	ut_ad(trx_sys->descr_n_used <= UT_LIST_GET_LEN(trx_sys->rw_trx_list));
 }
 
 /********************************************************************//**
@@ -595,6 +737,7 @@
 
 	UT_LIST_INIT(trx_sys->ro_trx_list);
 	UT_LIST_INIT(trx_sys->rw_trx_list);
+	UT_LIST_INIT(trx_sys->trx_serial_list);
 
 	/* Look from the rollback segments if there exist undo logs for
 	transactions */
@@ -617,6 +760,11 @@
 
 			trx = trx_resurrect_insert(undo, rseg);
 
+			if (trx->state == TRX_STATE_ACTIVE ||
+			    trx->state == TRX_STATE_PREPARED) {
+
+				trx_reserve_descriptor(trx);
+			}
 			trx_list_rw_insert_ordered(trx);
 		}
 
@@ -642,6 +790,11 @@
 			trx_resurrect_update(trx, undo, rseg);
 
 			if (trx_created) {
+				if (trx->state == TRX_STATE_ACTIVE ||
+				    trx->state == TRX_STATE_PREPARED) {
+
+					trx_reserve_descriptor(trx);
+				}
 				trx_list_rw_insert_ordered(trx);
 			}
 		}
@@ -791,6 +944,8 @@
 		UT_LIST_ADD_FIRST(trx_list, trx_sys->rw_trx_list, trx);
 		ut_d(trx->in_rw_trx_list = TRUE);
 		ut_d(trx_sys->rw_max_trx_id = trx->id);
+
+		trx_reserve_descriptor(trx);
 	}
 
 	ut_ad(trx_sys_validate_trx_list());
@@ -820,6 +975,14 @@
 
 	trx->no = trx_sys_get_new_trx_id();
 
+	if (UNIV_LIKELY(trx->in_trx_serial_list == 0)) {
+
+		UT_LIST_ADD_LAST(trx_serial_list, trx_sys->trx_serial_list,
+				 trx);
+
+		trx->in_trx_serial_list = 1;
+	}
+
 	/* If the rollack segment is not empty then the
 	new trx_t::no can't be less than any trx_t::no
 	already in the rollback segment. User threads only
@@ -1104,6 +1267,8 @@
 		} else {
 			UT_LIST_REMOVE(trx_list, trx_sys->rw_trx_list, trx);
 			ut_d(trx->in_rw_trx_list = FALSE);
+			ut_ad(trx_sys->descr_n_used <=
+			      UT_LIST_GET_LEN(trx_sys->rw_trx_list));
 			MONITOR_INC(MONITOR_TRX_RW_COMMIT);
 		}
 
@@ -1220,6 +1385,8 @@
 
 	trx->dict_operation = TRX_DICT_OP_NONE;
 
+	ut_ad(trx_sys->descr_n_used <= UT_LIST_GET_LEN(trx_sys->rw_trx_list));
+
 	trx->error_state = DB_SUCCESS;
 
 	/* trx->in_mysql_trx_list would hold between
@@ -1343,10 +1510,14 @@
 	ut_a(!trx->read_only);
 
 	UT_LIST_REMOVE(trx_list, trx_sys->rw_trx_list, trx);
+	ut_ad(trx_sys->descr_n_used <= UT_LIST_GET_LEN(trx_sys->rw_trx_list));
 
 	assert_trx_in_rw_list(trx);
 	ut_d(trx->in_rw_trx_list = FALSE);
 
+	trx->state = TRX_STATE_NOT_STARTED;
+	trx_release_descriptor(trx);
+
 	mutex_exit(&trx_sys->mutex);
 
 	/* Change the transaction state without mutex protection, now
@@ -1356,7 +1527,6 @@
 	ut_ad(!trx->in_ro_trx_list);
 	ut_ad(!trx->in_rw_trx_list);
 	ut_ad(!trx->in_mysql_trx_list);
-	trx->state = TRX_STATE_NOT_STARTED;
 }
 
 /********************************************************************//**
@@ -1376,11 +1546,8 @@
 		return(trx->read_view);
 	}
 
-	if (!trx->read_view) {
-		trx->read_view = read_view_open_now(trx->id,
-						    trx->prebuilt_view);
-		trx->global_read_view = trx->read_view;
-	}
+	trx->read_view = read_view_open_now(trx->id, trx->prebuilt_view);
+	trx->global_read_view = trx->read_view;
 
 	return(trx->read_view);
 }
 
=== added directory 'policy'
=== added directory 'policy/apparmor'
=== added file 'policy/apparmor/usr.sbin.mysqld'
--- policy/apparmor/usr.sbin.mysqld	1970-01-01 00:00:00 +0000
+++ policy/apparmor/usr.sbin.mysqld	2013-05-24 12:02:59 +0000
@@ -0,0 +1,61 @@
+# Last Modified: Thu Mar  7 21:58:51 2013
+# Based on usr.sbin.mysqld packaged in mysql-server in Ubuntu.
+# For Percona Server and Percona XtraDB Cluster
+
+#include <tunables/global>
+
+/usr/sbin/mysqld flags=(complain) {
+  #include <abstractions/base>
+  #include <abstractions/mysql>
+  #include <abstractions/nameservice>
+  #include <abstractions/user-tmp>
+  #include <abstractions/winbind>
+  #include <local/usr.sbin.mysqld>
+
+
+  capability chown,
+  capability dac_override,
+  capability setgid,
+  capability setuid,
+  capability sys_rawio,
+  capability sys_resource,
+
+  network tcp,
+
+
+  /dev/dm-0 r,
+  /etc/group r,
+  /etc/gai.conf r,
+  /etc/hosts.allow r,
+  /etc/hosts.deny r,
+  /etc/ld.so.cache r,
+  /etc/mtab r,
+  /etc/my.cnf r,
+  /etc/mysql/*.cnf r,
+  /etc/mysql/*.pem r,
+  /etc/mysql/conf.d/ r,
+  /etc/mysql/conf.d/* r,
+  /etc/nsswitch.conf r,
+  /etc/passwd r,
+  /etc/services r,
+  /run/mysqld/mysqld.pid w,
+  /run/mysqld/mysqld.sock w,
+  /sys/devices/system/cpu/ r,
+  owner /tmp/** lk,
+  /tmp/** rw,
+  /usr/lib/mysql/plugin/ r,
+  /usr/lib/mysql/plugin/*.so* mr,
+  /usr/sbin/mysqld mr,
+  /usr/share/mysql/** r,
+  /var/lib/mysql/ r,
+  /var/lib/mysql/** rwk,
+  /var/log/mysql.err rw,
+  /var/log/mysql.log rw,
+  /var/log/mysql/ r,
+  /var/log/mysql/* rw,
+  /var/run/mysqld/mysqld.pid w,
+  /var/run/mysqld/mysqld.sock w,
+
+  # Site-specific additions and overrides. See local/README for details.
+  #include <local/usr.sbin.mysqld>
+}
 
=== added file 'policy/apparmor/usr.sbin.mysqld.local'
--- policy/apparmor/usr.sbin.mysqld.local	1970-01-01 00:00:00 +0000
+++ policy/apparmor/usr.sbin.mysqld.local	2013-05-24 12:02:59 +0000
@@ -0,0 +1,2 @@
+# Site-specific additions and overrides for usr.sbin.mysqld..
+# For more details, please see /etc/apparmor.d/local/README.
 
=== added directory 'policy/selinux'
=== added file 'policy/selinux/percona-server.fc'
--- policy/selinux/percona-server.fc	1970-01-01 00:00:00 +0000
+++ policy/selinux/percona-server.fc	2013-05-24 12:02:59 +0000
@@ -0,0 +1,6 @@
+/etc/init\.d/rc\.d/mysql -- gen_context(system_u:object_r:mysqld_initrc_exec_t,s0)
+/var/lib/mysql/.*\.log --  gen_context(system_u:object_r:mysqld_log_t,s0)
+/var/lib/mysql/.*\.err --  gen_context(system_u:object_r:mysqld_log_t,s0)
+/var/lib/mysql/.*\.pid -- gen_context(system_u:object_r:mysqld_var_run_t,s0)
+/var/lib/mysql/.*\.cnf	--  gen_context(system_u:object_r:mysqld_etc_t,s0)
+/usr/bin/xtrabackup.* -- gen_context(system_u:object_r:mysqld_exec_t,s0)
 
=== added file 'policy/selinux/percona-server.te'
--- policy/selinux/percona-server.te	1970-01-01 00:00:00 +0000
+++ policy/selinux/percona-server.te	2013-05-24 12:02:59 +0000
@@ -0,0 +1,35 @@
+# This adds few more rules in addition to mysql.pp in selinux-policy-targeted
+module percona-server 1.0;
+
+require {
+        type user_tmp_t;
+        type mysqld_safe_t;
+        type tmp_t;
+        type fixed_disk_device_t;
+        type mysqld_t;
+        type tmpfs_t;
+        class sock_file { getattr unlink create };
+        class capability { sys_nice sys_resource };
+        class blk_file { read write open };
+        class file { write getattr read create unlink open };
+        class dir { search read write remove_name open add_name };
+}
+
+#============= mysqld_safe_t ==============
+allow mysqld_safe_t self:capability { sys_nice sys_resource };
+
+allow mysqld_safe_t tmp_t:dir { write remove_name };
+allow mysqld_safe_t tmp_t:sock_file { getattr unlink };
+allow mysqld_safe_t user_tmp_t:sock_file { getattr unlink };
+
+#============= mysqld_t ==============
+allow mysqld_t fixed_disk_device_t:blk_file { read write open };
+allow mysqld_t tmp_t:sock_file { create unlink };
+
+allow mysqld_t tmpfs_t:dir { write search read remove_name open add_name };
+allow mysqld_t tmpfs_t:file { write getattr read create unlink open };
+
+allow mysqld_t user_tmp_t:dir { write add_name };
+allow mysqld_t user_tmp_t:file create;
+
+allow mysqld_t tmp_t:file { append create read write open getattr unlink setattr };