merge with 4.0

BitKeeper/etc/logging_ok:
  auto-union
VC++Files/innobase/innobase.dsp:
  Auto merged
VC++Files/libmysql/libmysql.dsp:
  Auto merged
acinclude.m4:
  Auto merged
configure.in:
  Auto merged
BitKeeper/deleted/.del-com0shm.c~6a16f0c3d81de1f:
  Auto merged
BitKeeper/deleted/.del-mysql_fix_privilege_tables.sql:
  Auto merged
extra/replace.c:
  Auto merged
include/my_sys.h:
  Auto merged
innobase/btr/btr0btr.c:
  Auto merged
innobase/btr/btr0cur.c:
  Auto merged
innobase/btr/btr0pcur.c:
  Auto merged
innobase/btr/btr0sea.c:
  Auto merged
innobase/configure.in:
  Auto merged
innobase/data/data0data.c:
  Auto merged
innobase/dict/dict0boot.c:
  Auto merged
innobase/dict/dict0crea.c:
  Auto merged
innobase/dict/dict0dict.c:
  Auto merged
innobase/dict/dict0load.c:
  Auto merged
innobase/dict/dict0mem.c:
  Auto merged
innobase/ha/ha0ha.c:
  Auto merged
innobase/ha/hash0hash.c:
  Auto merged
innobase/include/btr0btr.ic:
  Auto merged
innobase/include/data0type.ic:
  Auto merged
innobase/include/dict0mem.h:
  Auto merged
innobase/include/log0log.ic:
  Auto merged
innobase/include/mach0data.ic:
  Auto merged
innobase/include/mtr0log.h:
  Auto merged
innobase/include/mtr0mtr.h:
  Auto merged
innobase/include/os0file.h:
  Auto merged
innobase/include/row0upd.ic:
  Auto merged
innobase/include/srv0srv.h:
  Auto merged
innobase/include/sync0sync.h:
  Auto merged
innobase/include/trx0rseg.ic:
  Auto merged
innobase/lock/lock0lock.c:
  Auto merged
innobase/log/log0recv.c:
  Auto merged
innobase/mem/mem0dbg.c:
  Auto merged
innobase/mtr/mtr0log.c:
  Auto merged
innobase/mtr/mtr0mtr.c:
  Auto merged
innobase/os/os0file.c:
  Auto merged
innobase/page/page0cur.c:
  Auto merged
innobase/page/page0page.c:
  Auto merged
innobase/pars/lexyy.c:
  Auto merged
innobase/read/read0read.c:
  Auto merged
innobase/rem/rem0cmp.c:
  Auto merged
innobase/rem/rem0rec.c:
  Auto merged
innobase/row/row0ins.c:
  Auto merged
innobase/row/row0mysql.c:
  Auto merged
innobase/row/row0purge.c:
  Auto merged
innobase/row/row0sel.c:
  Auto merged
innobase/row/row0undo.c:
  Auto merged
innobase/row/row0upd.c:
  Auto merged
innobase/srv/srv0srv.c:
  Auto merged
innobase/srv/srv0start.c:
  Auto merged
innobase/sync/sync0rw.c:
  Auto merged
innobase/thr/thr0loc.c:
  Auto merged
innobase/trx/trx0purge.c:
  Auto merged
innobase/trx/trx0rec.c:
  Auto merged
innobase/trx/trx0roll.c:
  Auto merged
innobase/trx/trx0trx.c:
  Auto merged
innobase/trx/trx0undo.c:
  Auto merged
myisam/mi_check.c:
  Auto merged
myisam/myisamchk.c:
  Auto merged
mysql-test/r/multi_update.result:
  Auto merged
mysql-test/r/mysqlbinlog.result:
  Auto merged
mysql-test/r/rpl_error_ignored_table.result:
  Auto merged
mysql-test/t/multi_update.test:
  Auto merged
mysql-test/t/rpl_error_ignored_table.test:
  Auto merged
mysys/mf_iocache.c:
  Auto merged
mysys/mf_pack.c:
  Auto merged
mysys/my_getopt.c:
  Auto merged
sql/ha_berkeley.cc:
  Auto merged
sql/ha_myisam.cc:
  Auto merged
sql/lock.cc:
  Auto merged
sql/log.cc:
  Auto merged
sql/opt_range.cc:
  Auto merged
sql/set_var.h:
  Auto merged
sql/sql_cache.cc:
  Auto merged
sql/sql_cache.h:
  Auto merged
sql/sql_delete.cc:
  Auto merged
sql/sql_handler.cc:
  Auto merged
sql/sql_insert.cc:
  Auto merged
sql/sql_list.h:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/sql_show.cc:
  Auto merged
sql/sql_table.cc:
  Auto merged
sql/sql_update.cc:
  Auto merged
tests/thread_test.c:
  Auto merged
client/mysqldump.c:
  Keep original indentation
mysql-test/r/merge.result:
  keep old file
scripts/mysql_fix_privilege_tables.sh:
  Keep old structure in merge with 4.0
sql/table.cc:
  merge with 4.0 + simple optimizations

110 files changed, 1225 insertions, 3725 deletions

diff --git a/innobase/Makefile.am b/innobase/Makefile.am
index 17d7130f3e0..8ff90d16a2c 100644
--- a/innobase/Makefile.am
+++ b/innobase/Makefile.am
@@ -22,7 +22,7 @@ TAR =			gtar
 
 noinst_HEADERS = ib_config.h
 
-SUBDIRS =		os ut btr buf com data dict dyn eval fil fsp fut \
+SUBDIRS =		os ut btr buf data dict dyn eval fil fsp fut \
 			ha ibuf include lock log mach mem mtr page \
 			pars que read rem row srv sync thr trx usr
 
diff --git a/innobase/btr/btr0btr.c b/innobase/btr/btr0btr.c
index eb18fecb368..ee27a171fa5 100644
--- a/innobase/btr/btr0btr.c
+++ b/innobase/btr/btr0btr.c
@@ -299,7 +299,9 @@ btr_page_alloc_for_ibuf(
 
 	new_page = buf_page_get(dict_tree_get_space(tree), node_addr.page,
 							RW_X_LATCH, mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(new_page, SYNC_TREE_NODE_NEW);
+#endif /* UNIV_SYNC_DEBUG */
 
 	flst_remove(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
 		    new_page + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST_NODE,
@@ -357,7 +359,9 @@ btr_page_alloc(
 
 	new_page = buf_page_get(dict_tree_get_space(tree), new_page_no,
 							RW_X_LATCH, mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(new_page, SYNC_TREE_NODE_NEW);
+#endif /* UNIV_SYNC_DEBUG */
 							
 	return(new_page);
 }	
@@ -398,7 +402,7 @@ btr_get_size(
 		
 		n += fseg_n_reserved_pages(seg_header, &dummy, &mtr);		
 	} else {
-		ut_a(0);
+		ut_error;
 	}
 
 	mtr_commit(&mtr);
@@ -664,8 +668,9 @@ btr_create(
 		ibuf_hdr_frame = fseg_create(space, 0,
 				IBUF_HEADER + IBUF_TREE_SEG_HEADER, mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(ibuf_hdr_frame, SYNC_TREE_NODE_NEW);
-
+#endif /* UNIV_SYNC_DEBUG */
 		ut_ad(buf_frame_get_page_no(ibuf_hdr_frame)
  						== IBUF_HEADER_PAGE_NO);
 		/* Allocate then the next page to the segment: it will be the
@@ -690,7 +695,9 @@ btr_create(
 
 	page_no = buf_frame_get_page_no(frame);
 	
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(frame, SYNC_TREE_NODE_NEW);
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (type & DICT_IBUF) {
 		/* It is an insert buffer tree: initialize the free list */
@@ -705,7 +712,9 @@ btr_create(
 									mtr);
 		/* The fseg create acquires a second latch on the page,
 		therefore we must declare it: */
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(frame, SYNC_TREE_NODE_NEW);
+#endif /* UNIV_SYNC_DEBUG */
 	}
 	
 	/* Create a new index page on the the allocated segment page */
@@ -1520,7 +1529,9 @@ func_start:
 	
 	ut_ad(mtr_memo_contains(mtr, dict_tree_get_lock(tree),
 							MTR_MEMO_X_LOCK));
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(dict_tree_get_lock(tree), RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	page = btr_cur_get_page(cursor);
 
diff --git a/innobase/btr/btr0cur.c b/innobase/btr/btr0cur.c
index 4e11407ba54..af3a61041cb 100644
--- a/innobase/btr/btr0cur.c
+++ b/innobase/btr/btr0cur.c
@@ -3157,8 +3157,10 @@ btr_store_big_rec_extern_fields(
 						prev_page_no,
 						RW_X_LATCH, &mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 				buf_page_dbg_add_level(prev_page,
 							SYNC_EXTERN_STORAGE);
+#endif /* UNIV_SYNC_DEBUG */
 							
 				mlog_write_ulint(prev_page + FIL_PAGE_DATA
 						+ BTR_BLOB_HDR_NEXT_PAGE_NO,
@@ -3193,9 +3195,9 @@ btr_store_big_rec_extern_fields(
 			rec_page = buf_page_get(space_id,
 						buf_frame_get_page_no(data),
 							RW_X_LATCH, &mtr);
-
+#ifdef UNIV_SYNC_DEBUG
 			buf_page_dbg_add_level(rec_page, SYNC_NO_ORDER_CHECK);
-
+#endif /* UNIV_SYNC_DEBUG */
 			mlog_write_ulint(data + local_len + BTR_EXTERN_LEN, 0,
 						MLOG_4BYTES, &mtr);
 			mlog_write_ulint(data + local_len + BTR_EXTERN_LEN + 4,
@@ -3287,9 +3289,9 @@ btr_free_externally_stored_field(
 
 		rec_page = buf_page_get(buf_frame_get_space_id(data),
 				buf_frame_get_page_no(data), RW_X_LATCH, &mtr);
-
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(rec_page, SYNC_NO_ORDER_CHECK);
-
+#endif /* UNIV_SYNC_DEBUG */
 		space_id = mach_read_from_4(data + local_len
 						+ BTR_EXTERN_SPACE_ID);
 
@@ -3332,9 +3334,9 @@ btr_free_externally_stored_field(
 		}
 		
 		page = buf_page_get(space_id, page_no, RW_X_LATCH, &mtr);
-		
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(page, SYNC_EXTERN_STORAGE);
-
+#endif /* UNIV_SYNC_DEBUG */
 		next_page_no = mach_read_from_4(page + FIL_PAGE_DATA
 						+ BTR_BLOB_HDR_NEXT_PAGE_NO);
 
@@ -3512,9 +3514,9 @@ btr_copy_externally_stored_field(
 		mtr_start(&mtr);
 
 		page = buf_page_get(space_id, page_no, RW_S_LATCH, &mtr);
-	
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(page, SYNC_EXTERN_STORAGE);
-
+#endif /* UNIV_SYNC_DEBUG */
 		blob_header = page + offset;
 
 		part_len = btr_blob_get_part_len(blob_header);
diff --git a/innobase/btr/btr0pcur.c b/innobase/btr/btr0pcur.c
index 39e70d91be8..cf8a612ef28 100644
--- a/innobase/btr/btr0pcur.c
+++ b/innobase/btr/btr0pcur.c
@@ -238,9 +238,9 @@ btr_pcur_restore_position(
 					    cursor->block_when_stored, page,
 					    cursor->modify_clock, mtr)) {
 			cursor->pos_state = BTR_PCUR_IS_POSITIONED;
-
+#ifdef UNIV_SYNC_DEBUG
 			buf_page_dbg_add_level(page, SYNC_TREE_NODE);
-			
+#endif /* UNIV_SYNC_DEBUG */
 			if (cursor->rel_pos == BTR_PCUR_ON) {
 
 				cursor->latch_mode = latch_mode;
diff --git a/innobase/btr/btr0sea.c b/innobase/btr/btr0sea.c
index 8a59be12a32..238f118e260 100644
--- a/innobase/btr/btr0sea.c
+++ b/innobase/btr/btr0sea.c
@@ -93,8 +93,10 @@ btr_search_check_free_space_in_heap(void)
 	hash_table_t*	table;
 	mem_heap_t*	heap;
 
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)
-			&& !rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	table = btr_search_sys->hash_index;
 
@@ -194,8 +196,10 @@ btr_search_info_update_hash(
 	ulint		n_unique;
 	int		cmp;
 
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)
-			&& !rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	index = cursor->index;
 
@@ -317,10 +321,12 @@ btr_search_update_block_hash_info(
 	buf_block_t*	block,	/* in: buffer block */
 	btr_cur_t*	cursor)	/* in: cursor */
 {
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)
-			&& !rw_lock_own(&btr_search_latch, RW_LOCK_EX));
-	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
-				|| rw_lock_own(&(block->lock), RW_LOCK_EX));
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(rw_lock_own(&((buf_block_t*) block)->lock, RW_LOCK_SHARED)
+		|| rw_lock_own(&((buf_block_t*) block)->lock, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(cursor);
 
 	info->last_hash_succ = FALSE;
@@ -398,9 +404,11 @@ btr_search_update_hash_ref(
 	dulint	tree_id;
 
 	ut_ad(cursor->flag == BTR_CUR_HASH_FAIL);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
 				|| rw_lock_own(&(block->lock), RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 	if (block->is_hashed
 	    && (info->n_hash_potential > 0)
 	    && (block->curr_n_fields == info->n_fields)
@@ -419,7 +427,9 @@ btr_search_update_hash_ref(
 		fold = rec_fold(rec, block->curr_n_fields,
 						block->curr_n_bytes, tree_id);
 
+#ifdef UNIV_SYNC_DEBUG
 		ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 		ha_insert_for_fold(btr_search_sys->hash_index, fold, rec);
 	}
@@ -439,8 +449,10 @@ btr_search_info_update_slow(
 	ulint*		params;
 	ulint*		params2;
 	
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)
-			&& !rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	block = buf_block_align(btr_cur_get_rec(cursor));
 
@@ -762,7 +774,9 @@ btr_search_guess_on_hash(
 
 		can_only_compare_to_cursor_rec = FALSE;
 
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(page, SYNC_TREE_NODE_FROM_HASH);
+#endif /* UNIV_SYNC_DEBUG */
 	}
 
 	block = buf_block_align(page);
@@ -910,10 +924,12 @@ btr_search_drop_page_hash_index(
 	ulint		n_recs;
 	ulint*		folds;
 	ulint		i;
-	
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)
-			&& !rw_lock_own(&btr_search_latch, RW_LOCK_EX));
-		
+
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
+
 	rw_lock_s_lock(&btr_search_latch);
 
 	block = buf_block_align(page);
@@ -927,9 +943,11 @@ btr_search_drop_page_hash_index(
 
 	table = btr_search_sys->hash_index;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
 	      			|| rw_lock_own(&(block->lock), RW_LOCK_EX)
 	      			|| (block->buf_fix_count == 0));
+#endif /* UNIV_SYNC_DEBUG */
 
 	n_fields = block->curr_n_fields;
 	n_bytes = block->curr_n_bytes;
@@ -1031,8 +1049,10 @@ btr_search_drop_page_hash_when_freed(
 				BUF_GET_IF_IN_POOL, IB__FILE__, __LINE__,
 				&mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_TREE_NODE_FROM_HASH);
-	
+#endif /* UNIV_SYNC_DEBUG */
+
 	btr_search_drop_page_hash_index(page);
 
 	mtr_commit(&mtr);
@@ -1072,9 +1092,11 @@ btr_search_build_page_hash_index(
 	block = buf_block_align(page);
 	table = btr_search_sys->hash_index;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
 				|| rw_lock_own(&(block->lock), RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	rw_lock_s_lock(&btr_search_latch);
 				
@@ -1237,8 +1259,10 @@ btr_search_move_or_delete_hash_entries(
 	block = buf_block_align(page);
 	new_block = buf_block_align(new_page);
 
-	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX)
-			&& rw_lock_own(&(new_block->lock), RW_LOCK_EX));
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX));
+	ut_ad(rw_lock_own(&(new_block->lock), RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	rw_lock_s_lock(&btr_search_latch);
 			
@@ -1298,7 +1322,9 @@ btr_search_update_hash_on_delete(
 
 	block = buf_block_align(rec);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (!block->is_hashed) {
 
@@ -1339,7 +1365,9 @@ btr_search_update_hash_node_on_insert(
 
 	block = buf_block_align(rec);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (!block->is_hashed) {
 
@@ -1400,7 +1428,9 @@ btr_search_update_hash_on_insert(
 
 	block = buf_block_align(rec);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	if (!block->is_hashed) {
 
diff --git a/innobase/buf/buf0buf.c b/innobase/buf/buf0buf.c
index 2af971d38fd..844880238fa 100644
--- a/innobase/buf/buf0buf.c
+++ b/innobase/buf/buf0buf.c
@@ -476,11 +476,11 @@ buf_block_init(
 
 	rw_lock_create(&(block->lock));
 	ut_ad(rw_lock_validate(&(block->lock)));
-	
+
 #ifdef UNIV_SYNC_DEBUG
 	rw_lock_create(&(block->debug_latch));
 	rw_lock_set_level(&(block->debug_latch), SYNC_NO_ORDER_CHECK);
-#endif
+#endif /* UNIV_SYNC_DEBUG */
 }
 
 /************************************************************************
@@ -1325,9 +1325,9 @@ buf_page_optimistic_get_func(
 	}
 
 	if (!UT_DULINT_EQ(modify_clock, block->modify_clock)) {
-
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(block->frame, SYNC_NO_ORDER_CHECK);
-	
+#endif /* UNIV_SYNC_DEBUG */
 		if (rw_latch == RW_S_LATCH) {
 			rw_lock_s_unlock(&(block->lock));
 		} else {
@@ -1527,7 +1527,9 @@ buf_page_init(
 				in units of a page */
 	buf_block_t*	block)	/* in: block to init */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(block->state != BUF_BLOCK_FILE_PAGE);
 
 	/* Set the state of the block */
diff --git a/innobase/buf/buf0flu.c b/innobase/buf/buf0flu.c
index cdea764971e..c568d5925fa 100644
--- a/innobase/buf/buf0flu.c
+++ b/innobase/buf/buf0flu.c
@@ -48,7 +48,9 @@ buf_flush_insert_into_flush_list(
 /*=============================*/
 	buf_block_t*	block)	/* in: block which is modified */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	ut_a(block->state == BUF_BLOCK_FILE_PAGE);
 
@@ -76,7 +78,9 @@ buf_flush_insert_sorted_into_flush_list(
 	buf_block_t*	prev_b;
 	buf_block_t*	b;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	prev_b = NULL;
 	b = UT_LIST_GET_FIRST(buf_pool->flush_list);
@@ -108,7 +112,9 @@ buf_flush_ready_for_replace(
 	buf_block_t*	block)	/* in: buffer control block, must be in state
 				BUF_BLOCK_FILE_PAGE and in the LRU list */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(block->state == BUF_BLOCK_FILE_PAGE);
 
 	if ((ut_dulint_cmp(block->oldest_modification, ut_dulint_zero) > 0)
@@ -132,7 +138,9 @@ buf_flush_ready_for_flush(
 				BUF_BLOCK_FILE_PAGE */
 	ulint		flush_type)/* in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(block->state == BUF_BLOCK_FILE_PAGE);
 
 	if ((ut_dulint_cmp(block->oldest_modification, ut_dulint_zero) > 0)
@@ -163,8 +171,9 @@ buf_flush_write_complete(
 	buf_block_t*	block)	/* in: pointer to the block in question */
 {
 	ut_ad(block);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
-
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(block->state == BUF_BLOCK_FILE_PAGE);
 
 	block->oldest_modification = ut_dulint_zero;
@@ -248,7 +257,7 @@ buf_flush_buffered_writes(void)
 	"InnoDB: files.\n",
 			(ulong) block->offset, (ulong) block->space);
 
-			ut_a(0);
+			ut_error;
 		}
 	}
 
diff --git a/innobase/buf/buf0lru.c b/innobase/buf/buf0lru.c
index db876c416cc..c5faec17890 100644
--- a/innobase/buf/buf0lru.c
+++ b/innobase/buf/buf0lru.c
@@ -310,11 +310,15 @@ loop:
 
 	   	fprintf(stderr,
 "  InnoDB: ERROR: over 9 / 10 of the buffer pool is occupied by\n"
-"InnoDB: lock heaps or the adaptive hash index!\n"
+"InnoDB: lock heaps or the adaptive hash index! Check that your\n"
+"InnoDB: transactions do not set too many row locks.\n"
+"InnoDB: Your buffer pool size is %lu MB. Maybe you should make\n"
+"InnoDB: the buffer pool bigger?\n"
 "InnoDB: We intentionally generate a seg fault to print a stack trace\n"
-"InnoDB: on Linux!\n");
+"InnoDB: on Linux!\n",
+		(ulong)(buf_pool->curr_size / (1024 * 1024 / UNIV_PAGE_SIZE)));
 
-		ut_a(0);
+		ut_error;
 	   
 	} else if (!recv_recovery_on && UT_LIST_GET_LEN(buf_pool->free)
 	   + UT_LIST_GET_LEN(buf_pool->LRU) < buf_pool->max_size / 5) {
@@ -471,7 +475,9 @@ buf_LRU_old_adjust_len(void)
 	ulint	new_len;
 
 	ut_a(buf_pool->LRU_old);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(3 * (BUF_LRU_OLD_MIN_LEN / 8) > BUF_LRU_OLD_TOLERANCE + 5);
 
 	for (;;) {
@@ -544,7 +550,9 @@ buf_LRU_remove_block(
 {
 	ut_ad(buf_pool);
 	ut_ad(block);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 		
 	ut_a(block->state == BUF_BLOCK_FILE_PAGE);
 	ut_a(block->in_LRU_list);
@@ -608,7 +616,9 @@ buf_LRU_add_block_to_end_low(
 	
 	ut_ad(buf_pool);
 	ut_ad(block);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	ut_a(block->state == BUF_BLOCK_FILE_PAGE);
 
@@ -671,7 +681,9 @@ buf_LRU_add_block_low(
 	
 	ut_ad(buf_pool);
 	ut_ad(block);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	ut_a(block->state == BUF_BLOCK_FILE_PAGE);
 	ut_a(!block->in_LRU_list);
@@ -772,7 +784,9 @@ buf_LRU_block_free_non_file_page(
 /*=============================*/
 	buf_block_t*	block)	/* in: block, must not contain a file page */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(block);
 	
 	ut_a((block->state == BUF_BLOCK_MEMORY)
@@ -809,7 +823,9 @@ buf_LRU_block_remove_hashed_page(
 				be in a state where it can be freed; there
 				may or may not be a hash index to the page */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(block);
 	
 	ut_a(block->state == BUF_BLOCK_FILE_PAGE);
@@ -863,7 +879,9 @@ buf_LRU_block_free_hashed_page(
 	buf_block_t*	block)	/* in: block, must contain a file page and
 				be in a state where it can be freed */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(block->state == BUF_BLOCK_REMOVE_HASH);
 
 	block->state = BUF_BLOCK_MEMORY;
diff --git a/innobase/com/Makefile.am b/innobase/com/Makefile.am
deleted file mode 100644
index a3d2f8a76c6..00000000000
--- a/innobase/com/Makefile.am
+++ /dev/null
@@ -1,24 +0,0 @@
-# Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
-# & Innobase Oy
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-include ../include/Makefile.i
-
-noinst_LIBRARIES =	libcom.a
-
-libcom_a_SOURCES =	com0com.c com0shm.c
-
-EXTRA_PROGRAMS =	
diff --git a/innobase/com/com0com.c b/innobase/com/com0com.c
deleted file mode 100644
index 94585d9f269..00000000000
--- a/innobase/com/com0com.c
+++ /dev/null
@@ -1,345 +0,0 @@
-/******************************************************
-The communication primitives
-
-(c) 1995 Innobase Oy
-
-Created 9/23/1995 Heikki Tuuri
-*******************************************************/
-
-#include "com0com.h"
-#ifdef UNIV_NONINL
-#include "com0com.ic"
-#endif
-
-#include "mem0mem.h"
-#include "com0shm.h"
-
-/*
-	IMPLEMENTATION OF COMMUNICATION PRIMITIVES
-	==========================================
-
-The primitives provide a uniform function interface for
-use in communication. The primitives have been modeled
-after the Windows Sockets interface. Below this uniform
-API, the precise methods of communication, for example,
-shared memory or Berkeley sockets, can be implemented
-as subroutines.
-*/
-
-struct com_endpoint_struct{
-	ulint	type;		/* endpoint type */
-	void*	par;		/* type-specific data structures */
-	ibool	bound;		/* TRUE if the endpoint has been
-				bound to an address */
-};
-
-/*************************************************************************
-Accessor functions for an endpoint */
-UNIV_INLINE
-ulint
-com_endpoint_get_type(
-/*==================*/
-	com_endpoint_t*	ep)
-{
-	ut_ad(ep);
-	return(ep->type);
-}
-
-UNIV_INLINE
-void
-com_endpoint_set_type(
-/*==================*/
-	com_endpoint_t*	ep,
-	ulint		type)
-{
-	ut_ad(ep);
-	ut_ad(type == COM_SHM);
-
-	ep->type = type;
-}
-
-UNIV_INLINE
-void*
-com_endpoint_get_par(
-/*=================*/
-	com_endpoint_t*	ep)
-{
-	ut_ad(ep);
-	return(ep->par);
-}
-
-UNIV_INLINE
-void
-com_endpoint_set_par(
-/*=================*/
-	com_endpoint_t*	ep,
-	void*		par)
-{
-	ut_ad(ep);
-	ut_ad(par);
-
-	ep->par = par;
-}
-
-UNIV_INLINE
-ibool
-com_endpoint_get_bound(
-/*===================*/
-	com_endpoint_t*	ep)
-{
-	ut_ad(ep);
-	return(ep->bound);
-}
-
-UNIV_INLINE
-void
-com_endpoint_set_bound(
-/*===================*/
-	com_endpoint_t*	ep,
-	ibool		bound)
-{
-	ut_ad(ep);
-
-	ep->bound = bound;
-}
-
-
-/*************************************************************************
-Creates a communications endpoint. */
-
-com_endpoint_t*
-com_endpoint_create(
-/*================*/
-			/* out, own: communications endpoint, NULL if
-			did not succeed */
-	ulint	type)	/* in: communication type of endpoint:
-			only COM_SHM supported */
-{
-	com_endpoint_t*	ep;
-	void*		par;
-
-	ep = mem_alloc(sizeof(com_endpoint_t));
-	
-	com_endpoint_set_type(ep, type);
-	com_endpoint_set_bound(ep, FALSE);
-	
-	if (type == COM_SHM) {
-		par = com_shm_endpoint_create();
-		com_endpoint_set_par(ep, par);
-	} else {
-		par = NULL;
-		ut_error;
-	}
-
-	if (par != NULL) {
-		return(ep);
-	} else {
-		mem_free(ep);
-		return(NULL);
-	}
-}
-
-/*************************************************************************
-Frees a communications endpoint. */
-
-ulint
-com_endpoint_free(
-/*==============*/
-				/* out: O if succeed, else error number */
-	com_endpoint_t*	ep)	/* in, own: communications endpoint */
-{
-	ulint	type;
-	ulint	ret;
-	void*	par;
-
-	type = com_endpoint_get_type(ep);
-	par  = com_endpoint_get_par(ep);
-
-	if (type == COM_SHM) {
-		ret = com_shm_endpoint_free((com_shm_endpoint_t*)par);
-	} else {
-		ret = 0;
-		ut_error;
-	}
-
-	if (ret) {
-		return(ret);
-	} else {
-		mem_free(ep);
-		return(0);
-	}
-}
-
-/*************************************************************************
-Sets an option, like the maximum datagram size for an endpoint.
-The options may vary depending on the endpoint type. */
-
-ulint
-com_endpoint_set_option(
-/*====================*/
-				/* out: 0 if succeed, else error number */
-	com_endpoint_t*	ep,	/* in: endpoint */
-	ulint		optno,	/* in: option number, only
-				COM_OPT_MAX_DGRAM_SIZE currently supported */
-	byte*		optval,	/* in: pointer to a buffer containing the
-				option value to set */
-	ulint		optlen)	/* in: option value buffer length */
-{
-	ulint	type;
-	ulint	ret;
-	void*	par;
-
-	type = com_endpoint_get_type(ep);
-	par  = com_endpoint_get_par(ep);
-
-	if (type == COM_SHM) {
-		ret = com_shm_endpoint_set_option((com_shm_endpoint_t*)par,
-						  optno, optval, optlen);
-	} else {
-		ret = 0;
-		ut_error;
-	}
-
-	return(ret);
-}
-	
-/*************************************************************************
-Binds a communications endpoint to the specified address. */
-
-ulint
-com_bind(
-/*=====*/
-				/* out: 0 if succeed, else error number */
-	com_endpoint_t*	ep,	/* in: communications endpoint */
-	char*		name,	/* in: address name */
-	ulint		len)	/* in: name length */
-{
-	ulint	type;
-	ulint	ret;
-	void*	par;
-
-	ut_ad(len <= COM_MAX_ADDR_LEN);
-
-	if (com_endpoint_get_bound(ep)) {
-		return(COM_ERR_ALREADY_BOUND);
-	}
-
-	type = com_endpoint_get_type(ep);
-	par  = com_endpoint_get_par(ep);
-
-	if (type == COM_SHM) {
-		ret = com_shm_bind((com_shm_endpoint_t*)par, name, len);
-	} else {
-		ret = 0;
-		ut_error;
-	}
-
-	if (ret == 0) {
-		com_endpoint_set_bound(ep, TRUE);
-	}		
-	
-	return(ret);
-}
-
-/*************************************************************************
-Waits for a datagram to arrive at an endpoint. */
-
-ulint
-com_recvfrom(
-/*=========*/
-				/* out: 0 if succeed, else error number */
-	com_endpoint_t*	ep,	/* in: communications endpoint */
-	byte*		buf,	/* out: datagram buffer; the buffer is
-				supplied by the caller */
-	ulint		buf_len,/* in: datagram buffer length */
-	ulint*		len,	/* out: datagram length */
-	char*		from,	/* out: address name buffer; the buffer is
-				supplied by the caller */
-	ulint		from_len,/* in: address name buffer length */
-	ulint*		addr_len)/* out: address name length */
-{
-	ulint	type;
-	ulint	ret;
-	void*	par;
-
-	if (!com_endpoint_get_bound(ep)) {
-
-		return(COM_ERR_NOT_BOUND);
-	}
-
-	type = com_endpoint_get_type(ep);
-	par  = com_endpoint_get_par(ep);
-
-	if (type == COM_SHM) {
-		ret = com_shm_recvfrom((com_shm_endpoint_t*)par,
-					buf, buf_len, len, from, from_len,
-					addr_len);
-	} else {
-		ret = 0;
-
-		ut_error;
-	}
-
-	return(ret);
-}
-
-/*************************************************************************
-Sends a datagram to the specified destination. */
-
-ulint
-com_sendto(
-/*=======*/
-				/* out: 0 if succeed, else error number */
-	com_endpoint_t*	ep,	/* in: communications endpoint */
-	byte*		buf,	/* in: datagram buffer */
-	ulint		len,	/* in: datagram length */
-	char*		to,	/* in: address name buffer */
-	ulint		tolen)	/* in: address name length */
-{
-	ulint	type;
-	ulint	ret;
-	void*	par;
-
-	if (!com_endpoint_get_bound(ep)) {
-		return(COM_ERR_NOT_BOUND);
-	}
-
-	type = com_endpoint_get_type(ep);
-	par  = com_endpoint_get_par(ep);
-
-	if (type == COM_SHM) {
-		ret = com_shm_sendto((com_shm_endpoint_t*)par, buf, len,
-								to, tolen);
-	} else {
-		ret = 0;
-		ut_error;
-	}
-
-	return(ret);
-}
-
-/*************************************************************************
-Gets the maximum datagram size for an endpoint. */
-
-ulint
-com_endpoint_get_max_size(
-/*======================*/
-				/* out: maximum size */
-	com_endpoint_t*	ep)	/* in: endpoint */
-{
-	ulint	type;
-	ulint	ret;
-	void*	par;
-
-	type = com_endpoint_get_type(ep);
-	par  = com_endpoint_get_par(ep);
-
-	if (type == COM_SHM) {
-		ret = com_shm_endpoint_get_size((com_shm_endpoint_t*)par);
-	} else {
-		ret = 0;
-		ut_error;
-	}
-
-	return(ret);
-}
diff --git a/innobase/com/com0shm.c b/innobase/com/com0shm.c
deleted file mode 100644
index 09876e6e8b5..00000000000
--- a/innobase/com/com0shm.c
+++ /dev/null
@@ -1,1130 +0,0 @@
-/******************************************************
-The communication through shared memory
-
-(c) 1995 Innobase Oy
-
-Created 9/25/1995 Heikki Tuuri
-*******************************************************/
-
-#include "com0shm.h"
-#ifdef UNIV_NONINL
-#include "com0shm.ic"
-#endif
-
-#include "mem0mem.h"
-#include "ut0mem.h"
-#include "com0com.h"
-#include "os0shm.h"
-#include "sync0sync.h"
-#include "sync0ipm.h"
-#include "hash0hash.h"
-
-/*
-	IMPLEMENTATION OF COMMUNICATION PRIMITIVES
-	==========================================
-
-When bind is called for an endpoint, a shared memory area of
-a size specified by com_shm_set_option is created with the
-name of the address given concatenated to "_IBSHM".
-Also a mutex is created for controlling the access to the
-shared memory area. The name of the mutex is address + "_IBSHM_MTX".
-An event with name address + "_IBSHM_EV_NE" is created. This event
-is in signaled state when the shared memory area is not empty, i.e.,
-there is a datagram to read. An event address + "_IBSHM_EV_EM"
-is signaled, when the area is empty, i.e., a datagram can be
-written to it.
-
-The shared memory area consists of an info struct
-at the beginning, containing fields telling:
-if the area is valid, i.e., is anybody going to
-read it, whether it currently contains a datagram, the
-length of the address from which the datagram was received,
-the length of the datagram, and the maximum allowed length of
-a datagram.
-After the info struct, there is a string of bytes
-containing the sender address and the data
-of the datagram.
-*/
-
-/* The following is set TRUE when the first endpoint is created. */
-
-ibool	com_shm_initialized	= FALSE;
-
-/* When a datagram is sent, the shared memory area
-corresponding to the destination address is mapped
-to the address space of this (sender) process.
-We preserve it and keep the relevant info in the
-following list. We can save a lot of CPU time
-if the destination can be found on the list. The list is
-protected by the mutex below. */
-
-mutex_t			com_shm_destination_mutex;
-hash_table_t*		com_shm_destination_cache;
-UT_LIST_BASE_NODE_T(com_shm_endpoint_t)
-			com_shm_destination_list;
-
-/* The number of successfully bound endpoints in this process. When this
-number drops to 0, the destination cache is freed. This variable is protected
-by com_shm_destination_mutex above. */
-
-ulint			com_shm_bind_count	= 0;
-
-/* The performance of communication in NT depends on how
-many times a system call is made (excluding os_thread_yield,
-as that is the fastest way to switch thread).
-The following variable counts such events. */
-
-ulint	com_shm_system_call_count = 0;
-
-/* The info struct at the beginning of a shared memory area */
-
-typedef struct com_shm_info_struct	com_shm_info_t;
-
-/* An area of shared memory consists of an info struct followed
-by a string of bytes. */
-
-typedef com_shm_info_t	com_shm_t;
-
-struct com_shm_endpoint_struct{
-	ibool		owns_shm; /* This is true if the shared memory
-				area is owned by this endpoint structure
-				(it may also be opened for this endpoint,
-				not created, in which case does not own it) */
-	char*		addr;	/* pointer to address the endpoint is bound
-				to, NULL if not bound */
-	ulint		addr_len; /* address length */
-	ulint		size;	/* maximum allowed datagram size, initialized
-				to 0 at creation */
-	os_shm_t	shm;	/* operating system handle of the shared
-				memory area */
-	com_shm_t*	map;	/* pointer to the start address of the shared
-				memory area */
-	os_event_t	not_empty; /* this is in the signaled state if
-				the area currently may contain a datagram;
-				NOTE: automatic event */
-	os_event_t	empty; 	/* this is in the signaled state if the area
-				currently may be empty; NOTE: automatic
-				event */
-	ip_mutex_hdl_t*	ip_mutex; /* handle to the interprocess mutex
-				protecting the shared memory */
-	UT_LIST_NODE_T(com_shm_endpoint_t) list; /* If the endpoint struct
-				is inserted into a list, this contains
-				pointers to next and prev */
-	com_shm_endpoint_t* addr_hash;
-				/* hash table link */
-};
-
-struct com_shm_info_struct{
-	ulint		valid;	/* This is COM_SHM_VALID if the creator
-				of the shared memory area has it still
-				mapped to its address space. Otherwise,
-				we may conclude that the datagram cannot
-				be delivered. */
-	ibool		not_empty; /* TRUE if the area currently contains
-				a datagram */
-	ulint		empty_waiters; /* Count of (writer) threads which are
-				waiting for the empty-event */
-	ulint		max_len;/* maximum allowed length for a datagram */
-	ulint		addr_len;/* address length for the sender address */
-	ulint		data_len;/* datagram length */
-	ip_mutex_t	ip_mutex;/* fast interprocess mutex protecting
-				the shared memory area */
-};
-
-#define COM_SHM_VALID	76640
-
-/*************************************************************************
-Accessor functions for a shared memory endpoint */
-
-UNIV_INLINE
-ibool
-com_shm_endpoint_get_owns_shm(
-/*==========================*/
-	com_shm_endpoint_t*	ep)
-{
-	ut_ad(ep);
-	return(ep->owns_shm);
-}
-
-UNIV_INLINE
-void
-com_shm_endpoint_set_owns_shm(
-/*==========================*/
-	com_shm_endpoint_t*	ep,
-	ibool			flag)
-{
-	ut_ad(ep);
-
-	ep->owns_shm = flag;
-}
-
-UNIV_INLINE
-char*
-com_shm_endpoint_get_addr(
-/*======================*/
-	com_shm_endpoint_t*	ep)
-{
-	ut_ad(ep);
-	return(ep->addr);
-}
-
-UNIV_INLINE
-void
-com_shm_endpoint_set_addr(
-/*======================*/
-	com_shm_endpoint_t*	ep,
-	char*			addr)
-{
-	ut_ad(ep);
-
-	ep->addr = addr;
-}
-
-UNIV_INLINE
-ulint
-com_shm_endpoint_get_addr_len(
-/*==========================*/
-	com_shm_endpoint_t*	ep)
-{
-	return(ep->addr_len);
-}
-
-UNIV_INLINE
-void
-com_shm_endpoint_set_addr_len(
-/*==========================*/
-	com_shm_endpoint_t*	ep,
-	ulint			len)
-{
-	ut_ad(ep);
-	ut_ad(len > 0);
-
-	ep->addr_len = len;
-}
-
-ulint
-com_shm_endpoint_get_size(
-/*======================*/
-	com_shm_endpoint_t*	ep)
-{
-	return(ep->size);
-}
-
-UNIV_INLINE
-void
-com_shm_endpoint_set_size(
-/*======================*/
-	com_shm_endpoint_t*	ep,
-	ulint			size)
-{
-	ut_ad(ep);
-
-	ep->size = size;
-}
-
-UNIV_INLINE
-os_shm_t
-com_shm_endpoint_get_shm(
-/*=====================*/
-	com_shm_endpoint_t*	ep)
-{
-	return(ep->shm);
-}
-
-UNIV_INLINE
-void
-com_shm_endpoint_set_shm(
-/*=====================*/
-	com_shm_endpoint_t*	ep,
-	os_shm_t		shm)
-{
-	ut_ad(ep);
-	ut_ad(shm);
-
-	ep->shm = shm;
-}
-
-UNIV_INLINE
-com_shm_t*
-com_shm_endpoint_get_map(
-/*=====================*/
-	com_shm_endpoint_t*	ep)
-{
-	return(ep->map);
-}
-
-UNIV_INLINE
-void
-com_shm_endpoint_set_map(
-/*=====================*/
-	com_shm_endpoint_t*	ep,
-	com_shm_t*		map)
-{
-	ut_ad(ep);
-	ut_ad(map);
-
-	ep->map = map;
-}
-
-UNIV_INLINE
-os_event_t
-com_shm_endpoint_get_empty(
-/*=======================*/
-	com_shm_endpoint_t*	ep)
-{
-	return(ep->empty);
-}
-
-UNIV_INLINE
-void
-com_shm_endpoint_set_empty(
-/*=======================*/
-	com_shm_endpoint_t*	ep,
-	os_event_t		event)
-{
-	ut_ad(ep);
-	ut_ad(event);
-
-	ep->empty = event;
-}
-
-UNIV_INLINE
-os_event_t
-com_shm_endpoint_get_not_empty(
-/*===========================*/
-	com_shm_endpoint_t*	ep)
-{
-	return(ep->not_empty);
-}
-
-UNIV_INLINE
-void
-com_shm_endpoint_set_not_empty(
-/*===========================*/
-	com_shm_endpoint_t*	ep,
-	os_event_t		event)
-{
-	ut_ad(ep);
-	ut_ad(event);
-
-	ep->not_empty = event;
-}
-
-/************************************************************************
-Accessor functions for the shared memory area info struct. */
-UNIV_INLINE
-ulint
-com_shm_get_valid(
-/*==============*/
-	com_shm_info_t*	info)
-{
-	return(info->valid);
-}
-
-UNIV_INLINE
-void
-com_shm_set_valid(
-/*==============*/
-	com_shm_info_t*		info,
-	ulint			flag)
-{
-	ut_ad(info);
-
-	info->valid = flag;
-}
-
-UNIV_INLINE
-ibool
-com_shm_get_not_empty(
-/*==================*/
-	com_shm_info_t*	info)
-{
-	return(info->not_empty);
-}
-
-UNIV_INLINE
-void
-com_shm_set_not_empty(
-/*==================*/
-	com_shm_info_t*		info,
-	ibool			flag)
-{
-	ut_ad(info);
-
-	info->not_empty = flag;
-}
-
-UNIV_INLINE
-ulint
-com_shm_get_empty_waiters(
-/*======================*/
-	com_shm_info_t*	info)
-{
-	ut_ad(info->empty_waiters < 1000);
-
-	return(info->empty_waiters);
-}
-
-UNIV_INLINE
-void
-com_shm_set_empty_waiters(
-/*======================*/
-	com_shm_info_t*	info,
-	ulint		count)
-{
-	ut_ad(info);
-	ut_ad(count < 1000);
-
-	info->empty_waiters = count;
-}
-
-UNIV_INLINE
-ulint
-com_shm_get_max_len(
-/*================*/
-	com_shm_info_t*	info)
-{
-	return(info->max_len);
-}
-
-UNIV_INLINE
-void
-com_shm_set_max_len(
-/*================*/
-	com_shm_info_t*		info,
-	ulint			len)
-{
-	ut_ad(info);
-	ut_ad(len > 0);
-
-	info->max_len = len;
-}
-
-UNIV_INLINE
-ulint
-com_shm_get_addr_len(
-/*=================*/
-	com_shm_info_t*	info)
-{
-	return(info->addr_len);
-}
-
-UNIV_INLINE
-void
-com_shm_set_addr_len(
-/*=================*/
-	com_shm_info_t*		info,
-	ulint			len)
-{
-	ut_ad(info);
-	ut_ad(len > 0);
-
-	info->addr_len = len;
-}
-
-UNIV_INLINE
-ulint
-com_shm_get_data_len(
-/*=================*/
-	com_shm_info_t*	info)
-{
-	return(info->data_len);
-}
-
-UNIV_INLINE
-void
-com_shm_set_data_len(
-/*=================*/
-	com_shm_info_t*		info,
-	ulint			len)
-{
-	ut_ad(info);
-	ut_ad(len > 0);
-
-	info->data_len = len;
-}
-
-UNIV_INLINE
-ip_mutex_t*
-com_shm_get_ip_mutex(
-/*=================*/
-	com_shm_info_t*	info)
-{
-	return(&(info->ip_mutex));
-}
-
-/*************************************************************************
-Accessor functions for the address and datagram fields inside a
-shared memory area. */
-
-UNIV_INLINE
-char*
-com_shm_get_addr(
-/*=============*/
-	com_shm_t*	area)
-{
-	return((char*)area + sizeof(com_shm_info_t));
-}
-
-UNIV_INLINE
-byte*
-com_shm_get_data(
-/*=============*/
-	com_shm_t*	area)
-{
-	return((byte*)com_shm_get_addr(area) + com_shm_get_addr_len(area));
-}
-
-/*************************************************************************
-Initializes the shared memory communication system for this
-process. */
-UNIV_INLINE
-void
-com_shm_init(void)
-/*==============*/
-{
-	mutex_create(&com_shm_destination_mutex);
-
-	mutex_set_level(&com_shm_destination_mutex, SYNC_ANY_LATCH);
-
-	com_shm_destination_cache = hash_create(1000);
-
-	UT_LIST_INIT(com_shm_destination_list);
-
-	com_shm_initialized = TRUE;
-}
-
-/*************************************************************************
-Reserves the ip mutex of the shared memory area of an endpoint. */
-UNIV_INLINE
-void
-com_shm_enter(
-/*==========*/
-	com_shm_endpoint_t*	ep)
-{
-	ulint	ret;
-
-	ret = ip_mutex_enter(ep->ip_mutex, 10000000);
-
-	if (ret != 0) {
-		mutex_list_print_info();
-
-		ut_error;
-	}
-}
-
-/*************************************************************************
-Releases the ip mutex of the shared memory area of an endpoint. */
-UNIV_INLINE
-void
-com_shm_exit(
-/*=========*/
-	com_shm_endpoint_t*	ep)
-{
-	ip_mutex_exit(ep->ip_mutex);
-}
-
-/*************************************************************************
-Looks for the given address in the cached destination addresses. */
-UNIV_INLINE
-com_shm_endpoint_t*
-com_shm_destination_cache_search(
-/*=============================*/
-			/* out: cached endpoint structure if found, else NULL */
-	char*	addr,	/* in: destination address */
-	ulint	len)	/* in: address length */
-{
-	com_shm_endpoint_t*	ep;
-	ulint			fold;
-
-	fold = ut_fold_binary((byte*)addr, len);
-/*	
-	printf("Searching dest. cache %s %lu fold %lu\n", addr, len, fold);
-*/
-	mutex_enter(&com_shm_destination_mutex);
-
-	HASH_SEARCH(addr_hash, com_shm_destination_cache, fold, ep,
-			((ep->addr_len == len)
-		 		&& (0 == ut_memcmp(addr, ep->addr, len))));
-
-	mutex_exit(&com_shm_destination_mutex);
-
-	return(ep);
-}
-
-/*************************************************************************
-Inserts the given endpoint structure in the cached destination addresses. */
-static
-void
-com_shm_destination_cache_insert(
-/*=============================*/
-	com_shm_endpoint_t*	ep)	/* in: endpoint struct to insert */
-{
-	ulint	fold;
-
-	fold = ut_fold_binary((byte*)(ep->addr), ep->addr_len);
-	
-	mutex_enter(&com_shm_destination_mutex);
-
-	/* Add to hash table */
-	HASH_INSERT(com_shm_endpoint_t,
-			addr_hash, com_shm_destination_cache, fold, ep);
-
-	UT_LIST_ADD_LAST(list, com_shm_destination_list, ep);
-
-/*	printf("Inserting to dest. cache %s %lu fold %lu\n", ep->addr,
-					ep->addr_len, fold);
-*/
-	mutex_exit(&com_shm_destination_mutex);
-}
-
-/*************************************************************************
-Frees the endpoint structs in the destination cache if the bind count is zero.
-If it is not, some send operation may just be using a cached endpoint and it
-cannot be freed. */
-static
-void
-com_shm_destination_cache_no_binds(void)
-/*====================================*/
-{
-	com_shm_endpoint_t*	ep;
-	ulint			fold;
-
-	mutex_enter(&com_shm_destination_mutex);
-
-	if (com_shm_bind_count != 0) {
-		mutex_exit(&com_shm_destination_mutex);
-
-		return;
-	}
-
-	while (UT_LIST_GET_LEN(com_shm_destination_list) != 0) {
-
-		ep = UT_LIST_GET_FIRST(com_shm_destination_list);
-
-		UT_LIST_REMOVE(list, com_shm_destination_list, ep);
-
-		fold = ut_fold_binary((byte*)ep->addr, ep->addr_len);
-/*	
-		printf("Deleting from dest. cache %s %lu fold %lu\n",
-					ep->addr,
-					ep->addr_len, fold);
-*/
-		HASH_DELETE(com_shm_endpoint_t, addr_hash,
-					com_shm_destination_cache, fold, ep);
-
-		com_shm_endpoint_free(ep);
-	}	
-
-	mutex_exit(&com_shm_destination_mutex);
-}
-
-/***********************************************************************
-Unbinds an endpoint at the time of freeing. */
-static
-void
-com_shm_unbind(
-/*===========*/
-	com_shm_endpoint_t*	ep)	/* in: endpoint */
-{
-	com_shm_t*	map;
-
-	map = com_shm_endpoint_get_map(ep);
-
-	/* Mark the shared memory area invalid */
-
-	com_shm_set_valid(map, 0);
-
-	/* Decrement the count of bindings */
-
-	mutex_enter(&com_shm_destination_mutex);
-
-	com_shm_bind_count--;
-
-	mutex_exit(&com_shm_destination_mutex);
-
-	/* If there are no binds left, free the cached endpoints */
-
-	com_shm_destination_cache_no_binds();
-}
-
-/*************************************************************************
-Creates a communications endpoint. */
-
-com_shm_endpoint_t*
-com_shm_endpoint_create(void)
-/*=========================*/
-			/* out, own: communications endpoint, NULL if
-			did not succeed */
-{
-	com_shm_endpoint_t*	ep;
-
-	if (!com_shm_initialized) {
-
-		com_shm_init();
-	}
-	
-	ep = mem_alloc(sizeof(com_shm_endpoint_t));
-	
-	com_shm_endpoint_set_owns_shm(ep, FALSE);
-	com_shm_endpoint_set_addr(ep, NULL);
-	com_shm_endpoint_set_size(ep, 0);
-	
-	return(ep);	
-}
-
-/*************************************************************************
-Frees a communications endpoint. */
-
-ulint
-com_shm_endpoint_free(
-/*==================*/
-				/* out: O if succeed, else error number */
-	com_shm_endpoint_t* ep)	/* in, own: communications endpoint */
-{
-	com_shm_t*	map;	
-	
-	ut_ad(ep);
-
-	if (com_shm_endpoint_get_addr(ep) != NULL) {
-		
-		map = com_shm_endpoint_get_map(ep);
-		
-		if (com_shm_endpoint_get_owns_shm(ep)) {
-
-			com_shm_unbind(ep);
-		}
-		
-		/* We do not destroy the data structures in the shared memory
-		area, because we cannot be sure that there is currently no
-		process accessing it. Therefore we just close the ip_mutex
-		residing in the area. */
-
-		ip_mutex_close(ep->ip_mutex);
-
-		os_event_free(com_shm_endpoint_get_not_empty(ep));
-		os_event_free(com_shm_endpoint_get_empty(ep));
-		
-		os_shm_unmap(map);
-		os_shm_free(com_shm_endpoint_get_shm(ep));
-
-		mem_free(com_shm_endpoint_get_addr(ep));
-	}
-
-	mem_free(ep);
-
-	return(0);
-}
-
-/*************************************************************************
-Sets an option, like the maximum datagram size for an endpoint.
-The options may vary depending on the endpoint type. */
-
-ulint
-com_shm_endpoint_set_option(
-/*========================*/
-				/* out: 0 if succeed, else error number */
-	com_shm_endpoint_t* ep,	/* in: endpoint */
-	ulint		optno,	/* in: option number, only
-				COM_OPT_MAX_DGRAM_SIZE currently supported */
-	byte*		optval,	/* in: pointer to a buffer containing the
-				option value to set */
-	ulint		optlen)	/* in: option value buffer length */
-{
-	ulint	size;
-
-	UT_NOT_USED(optlen);
-
-	ut_ad(ep);
-	ut_a(optno == COM_OPT_MAX_DGRAM_SIZE);
-	ut_ad(NULL == com_shm_endpoint_get_addr(ep));
- 
-	size = *((ulint*)optval);
-
-	ut_ad(size > 0);
-
-	com_shm_endpoint_set_size(ep, size);
-
-	return(0);
-}
-	
-/*************************************************************************
-This function is used either to create a new shared memory area or open an
-existing one, but this does not do the operations necessary with the ip mutex.
-They are performed in com_shm_bind or com_shm_open which call this function. */
-static
-ulint
-com_shm_create_or_open(
-/*===================*/
-				/* out: 0 if succeed, else error number */
-	com_shm_endpoint_t* ep,	/* in: communications endpoint */
-	char*		name,	/* in: address name */
-	ulint		len)	/* in: address name length */
-{
-	os_shm_t	shm;
-	com_shm_t*	map;
-	os_event_t	event_ne;
-	os_event_t	event_em;
-	char*		buf;
-	
-	ut_ad(ep);
-	ut_ad(name);
-	ut_ad(len > 0);
-
-	buf = mem_alloc(COM_MAX_ADDR_LEN + 20);
-
-	ut_memcpy(buf, name, len);
-
-	ut_strcpy(buf + len, (char*)"_IBSHM");
-
-	shm = os_shm_create(sizeof(com_shm_info_t) + COM_MAX_ADDR_LEN +
-			    		com_shm_endpoint_get_size(ep), buf);
-	if (shm == NULL) {
-
-		return(COM_ERR_NOT_SPECIFIED);
-	}
-
-	map = os_shm_map(shm);
-
-	if (map == NULL) {
-		os_shm_free(shm);
-
-		return(COM_ERR_NOT_SPECIFIED);
-	}
-
-	ut_strcpy(buf + len, (char*)"_IBSHM_EV_NE"),
-
-	event_ne = os_event_create(buf);
-
-	ut_ad(event_ne);
-
-	ut_strcpy(buf + len, (char*)"_IBSHM_EV_EM"),
-
-	event_em = os_event_create(buf);
-
-	ut_ad(event_em);
-
-	ut_a(0); /* event_ne and event_em should be auto events! */
-
-	com_shm_endpoint_set_shm(ep, shm);
-	com_shm_endpoint_set_map(ep, map);
-
-	com_shm_endpoint_set_not_empty(ep, event_ne);
-	com_shm_endpoint_set_empty(ep, event_em);
-
-	com_shm_endpoint_set_addr(ep, buf);
-	com_shm_endpoint_set_addr_len(ep, len);
-
-	return(0);
-}
-
-/*************************************************************************
-Opens a shared memory area for communication. */
-static
-ulint
-com_shm_open(
-/*=========*/
-				/* out: 0 if succeed, else error number */
-	com_shm_endpoint_t* ep,	/* in: communications endpoint */
-	char*		name,	/* in: address name */
-	ulint		len)	/* in: address name length */
-{
-	ip_mutex_hdl_t*	ip_hdl;
-	com_shm_t*	map;
-	ulint		ret;
-	char		buf[COM_MAX_ADDR_LEN + 20];
-	
-	ret = com_shm_create_or_open(ep, name, len);	
-
-	if (ret != 0) {
-
-		return(ret);
-	}
-
-	map = com_shm_endpoint_get_map(ep);
-
-	/* Open the interprocess mutex to protect the shared memory area */
-
-	ut_memcpy(buf, name, len);
-	ut_strcpy(buf + len, (char*)"_IBSHM_MTX");
-	
-	ret = ip_mutex_open(com_shm_get_ip_mutex(map), buf, &ip_hdl);
-	
-	if (ret != 0) {
-
-		return(COM_ERR_NOT_SPECIFIED);
-	}
-	
-	ep->ip_mutex = ip_hdl;
-
-	return(0);
-}
-
-/*************************************************************************
-Creates a shared memory area for communication. */
-
-ulint
-com_shm_bind(
-/*=========*/
-				/* out: 0 if succeed, else error number */
-	com_shm_endpoint_t* ep,	/* in: communications endpoint */
-	char*		name,	/* in: address name */
-	ulint		len)	/* in: address name length */
-{
-	com_shm_t*	map;
-	ulint		ret;
-	char		buf[COM_MAX_ADDR_LEN + 20];
-	ip_mutex_hdl_t*	ip_hdl;
-	
-	if (com_shm_endpoint_get_size(ep) == 0) {
-
-		return(COM_ERR_MAX_DATAGRAM_SIZE_NOT_SET);
-	}
-	
-	ret = com_shm_create_or_open(ep, name, len);	
-
-	if (ret != 0) {
-
-		return(ret);
-	}
-
-	map = com_shm_endpoint_get_map(ep);
-
-	/* Create the interprocess mutex to protect the shared memory area */
-
-	ut_memcpy(buf, name, len);
-	ut_strcpy(buf + len, (char*)"_IBSHM_MTX");
-	
-	ret = ip_mutex_create(com_shm_get_ip_mutex(map), buf, &ip_hdl);
-	
-	if (ret != 0) {
-
-		return(COM_ERR_NOT_SPECIFIED);
-	}
-	
-	/* This endpoint structure owns the shared memory area */
-
-	com_shm_endpoint_set_owns_shm(ep, TRUE);
-	ep->ip_mutex = ip_hdl;
-
-	mutex_enter(&com_shm_destination_mutex);
-
-	/* Increment the count of successful bindings */
-
-	com_shm_bind_count++;
-
-	mutex_exit(&com_shm_destination_mutex);
-
-	com_shm_set_not_empty(map, FALSE);
-	com_shm_set_empty_waiters(map, 0);
-	com_shm_set_max_len(map, com_shm_endpoint_get_size(ep));
-
-	com_shm_set_valid(map, COM_SHM_VALID);
-
-	os_event_set(com_shm_endpoint_get_empty(ep));
-
-	return(0);
-}	
-
-/*************************************************************************
-Waits for a datagram to arrive at an endpoint. */
-
-ulint
-com_shm_recvfrom(
-/*=============*/
-				/* out: 0 if succeed, else error number */
-	com_shm_endpoint_t* ep,	/* in: communications endpoint */
-	byte*		buf,	/* out: datagram buffer; the buffer is
-				supplied by the caller */
-	ulint		buf_len,/* in: datagram buffer length */
-	ulint*		len,	/* out: datagram length */
-	char*		from,	/* out: address name buffer; the buffer is
-				supplied by the caller */
-	ulint		from_len,/* in: address name buffer length */
-	ulint*		addr_len)/* out: address name length */
-{
-	com_shm_t*	map;
-	ulint		loop_count;
-
-	map = com_shm_endpoint_get_map(ep);
-
-	loop_count = 0;
-loop:
-	com_shm_system_call_count++;
-
-	/* NOTE: automatic event */
-	
-	os_event_wait(com_shm_endpoint_get_not_empty(ep));
-
-	loop_count++;
-
-	if (loop_count > 1) {
-		printf("!!!!!!!!COM_SHM loop count %lu\n", (ulong) loop_count);
-	}
-
-	ut_ad(loop_count < 2);
-
-	com_shm_enter(ep);
-
-	if (!com_shm_get_not_empty(map)) {
-		/* There was no datagram, wait for the event */
-
-		com_shm_exit(ep);
-
-		goto loop;
-	}
-		
-	if (com_shm_get_data_len(map) > buf_len) {
-
-		com_shm_exit(ep);
-
-		return(COM_ERR_DATA_BUFFER_TOO_SMALL);
-	}
-
-	if (com_shm_get_addr_len(map) > from_len) {
-
-		com_shm_exit(ep);
-
-		return(COM_ERR_ADDR_BUFFER_TOO_SMALL);
-	}
-
-	*len = com_shm_get_data_len(map);
-	*addr_len = com_shm_get_addr_len(map);
-
-	ut_memcpy(buf, com_shm_get_data(map), *len);
-	ut_memcpy(from, com_shm_get_addr(map), *addr_len);
-
-	com_shm_set_not_empty(map, FALSE);
-
-	/* If there may be writers queuing to insert the datagram, signal the
-	empty-event */
-
-	if (com_shm_get_empty_waiters(map) != 0) {
-
-		com_shm_system_call_count++;
-
-		os_event_set(com_shm_endpoint_get_empty(ep));
-	}
-	
-	com_shm_exit(ep);
-
-	return(0);
-}
-
-/*************************************************************************
-Sends a datagram to the specified destination. */
-
-ulint
-com_shm_sendto(
-/*===========*/
-				/* out: 0 if succeed, else error number */
-	com_shm_endpoint_t* ep,	/* in: communications endpoint */
-	byte*		buf,	/* in: datagram buffer */
-	ulint		len,	/* in: datagram length */
-	char*		to,	/* in: address name buffer */
-	ulint		tolen)	/* in: address name length */
-{
-	com_shm_endpoint_t*	ep2;
-	com_shm_t*		map;
-	ulint			sender_len;
-	ulint			ret;
-	ulint			loop_count;
-	
-	/* Try first to find from the cached destination addresses */
-
-	ep2 = com_shm_destination_cache_search(to, tolen);
-
-	if (ep2 == NULL) {
-		/* Did not find it in the cache */
-		ep2 = com_shm_endpoint_create();
-
-		ret = com_shm_open(ep2, to, tolen);
-
-		if (ret != 0) {
-			com_shm_endpoint_free(ep2);
-
-			return(ret);
-		}
-
-		/* Insert into the cached destination addresses */
-
-		com_shm_destination_cache_insert(ep2);
-	}
-
-	map = com_shm_endpoint_get_map(ep2);
-
-	if (com_shm_get_valid(map) != COM_SHM_VALID) {
-
-		com_shm_exit(ep2);
-
-		return(COM_ERR_DGRAM_NOT_DELIVERED);
-	}
-
-	if (com_shm_get_max_len(map) < len) {
-
-		com_shm_exit(ep2);
-
-		return(COM_ERR_DATA_TOO_LONG);
-	}
-
-	/* Optimistically, we first go to see if the datagram area is empty,
-	without waiting for the empty-event */
-
-	loop_count = 0;
-loop:
-	loop_count++;
-
-	if (loop_count > 5) {
-		printf("!!!!!!COM_SHM Notempty loop count %lu\n",
-		       (ulong) loop_count);
-	}
-
-	ut_ad(loop_count < 100);
-
-	com_shm_enter(ep2);
-
-	if (com_shm_get_not_empty(map)) {
-
-		/* Not empty, we cannot insert a datagram */
-
-		com_shm_set_empty_waiters(map,
-					1 + com_shm_get_empty_waiters(map));
-		com_shm_exit(ep2);
-
-		com_shm_system_call_count++;
-
-		/* Wait for the area to become empty */
-		/* NOTE: automatic event */
-
-		ret = os_event_wait_time(com_shm_endpoint_get_empty(ep2),
-								10000000);
-		ut_a(ret == 0);
-
-		com_shm_enter(ep2);
-
-		com_shm_set_empty_waiters(map,
-					com_shm_get_empty_waiters(map) - 1);
-		com_shm_exit(ep2);
-
-		goto loop;
-	}
-		
-	sender_len = com_shm_endpoint_get_addr_len(ep);
-	
-	com_shm_set_data_len(map, len);
-	com_shm_set_addr_len(map, sender_len);
-
-	ut_memcpy(com_shm_get_data(map), buf, len);
-	ut_memcpy(com_shm_get_addr(map), com_shm_endpoint_get_addr(ep),
-					 			sender_len);
-	com_shm_set_not_empty(map, TRUE);
-	com_shm_system_call_count++;
-
-	com_shm_exit(ep2);
-
-	/* Signal the event */
-
-	os_event_set(com_shm_endpoint_get_not_empty(ep2));
-
-	return(0);
-}
diff --git a/innobase/com/makefilewin b/innobase/com/makefilewin
deleted file mode 100644
index 0d2d6d45952..00000000000
--- a/innobase/com/makefilewin
+++ /dev/null
@@ -1,12 +0,0 @@
-include ..\include\makefile.i
-
-com.lib: com0com.obj com0shm.obj
-	lib -out:..\libs\com.lib com0com.obj com0shm.obj
-
-com0com.obj: com0com.c
-	$(CCOM) $(CFL) -c com0com.c
-
-com0shm.obj: com0shm.c
-	$(CCOM) $(CFL) -c com0shm.c
-
-
diff --git a/innobase/configure.in b/innobase/configure.in
index 7c86dc9fc58..652291f1f38 100644
--- a/innobase/configure.in
+++ b/innobase/configure.in
@@ -113,7 +113,7 @@ case "$target" in
 esac
 
 AC_OUTPUT(Makefile os/Makefile ut/Makefile btr/Makefile dnl
-		buf/Makefile com/Makefile data/Makefile dnl
+		buf/Makefile data/Makefile dnl
 		dict/Makefile dyn/Makefile dnl
 		eval/Makefile fil/Makefile fsp/Makefile fut/Makefile dnl
 		ha/Makefile ibuf/Makefile include/Makefile dnl
diff --git a/innobase/data/data0data.c b/innobase/data/data0data.c
index 9df933c0ac6..0ed0efeb160 100644
--- a/innobase/data/data0data.c
+++ b/innobase/data/data0data.c
@@ -114,8 +114,8 @@ dtuple_datas_are_ordering_equal(
 	ulint		i;
 
 	ut_ad(tuple1 && tuple2);
-	ut_ad(tuple1->magic_n = DATA_TUPLE_MAGIC_N);
-	ut_ad(tuple2->magic_n = DATA_TUPLE_MAGIC_N);
+	ut_ad(tuple1->magic_n == DATA_TUPLE_MAGIC_N);
+	ut_ad(tuple2->magic_n == DATA_TUPLE_MAGIC_N);
 	ut_ad(dtuple_check_typed(tuple1));
 	ut_ad(dtuple_check_typed(tuple2));
 
@@ -263,7 +263,7 @@ dfield_check_typed(
 			(ulong) dfield_get_type(field)->mtype,
 			(ulong) dfield_get_len(field));
 
-		ut_a(0);
+		ut_error;
 	}
 
 	return(TRUE);
@@ -308,7 +308,7 @@ dtuple_validate(
 	ulint	 	i;
 	ulint	 	j;
 
-	ut_a(tuple->magic_n = DATA_TUPLE_MAGIC_N);
+	ut_ad(tuple->magic_n == DATA_TUPLE_MAGIC_N);
 
 	n_fields = dtuple_get_n_fields(tuple);
 
diff --git a/innobase/dict/dict0boot.c b/innobase/dict/dict0boot.c
index 76c94d1a918..46cf6c7788d 100644
--- a/innobase/dict/dict0boot.c
+++ b/innobase/dict/dict0boot.c
@@ -39,8 +39,9 @@ dict_hdr_get(
 	
 	header = DICT_HDR + buf_page_get(DICT_HDR_SPACE, DICT_HDR_PAGE_NO,
 							RW_X_LATCH, mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(header, SYNC_DICT_HEADER);
-
+#endif /* UNIV_SYNC_DEBUG */
 	return(header);
 }
 
@@ -64,7 +65,7 @@ dict_hdr_get_new_id(
 
 	dict_hdr = dict_hdr_get(&mtr);
 
-	id = mtr_read_dulint(dict_hdr + type, MLOG_8BYTES, &mtr); 
+	id = mtr_read_dulint(dict_hdr + type, &mtr); 
 
 	/* Add some dummy code here because otherwise pgcc seems to
 	compile wrong */
@@ -75,7 +76,7 @@ dict_hdr_get_new_id(
 
 	id = ut_dulint_add(id, 1);
 	
-	mlog_write_dulint(dict_hdr + type, id, MLOG_8BYTES, &mtr); 
+	mlog_write_dulint(dict_hdr + type, id, &mtr); 
 
 	mtr_commit(&mtr);
 
@@ -94,7 +95,9 @@ dict_hdr_flush_row_id(void)
 	dulint		id;
 	mtr_t		mtr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	id = dict_sys->row_id;
 
@@ -102,7 +105,7 @@ dict_hdr_flush_row_id(void)
 
 	dict_hdr = dict_hdr_get(&mtr);
 	
-	mlog_write_dulint(dict_hdr + DICT_HDR_ROW_ID, id, MLOG_8BYTES, &mtr); 
+	mlog_write_dulint(dict_hdr + DICT_HDR_ROW_ID, id, &mtr); 
 
 	mtr_commit(&mtr);
 }				
@@ -138,20 +141,16 @@ dict_hdr_create(
 	/* Start counting row, table, index, and tree ids from
 	DICT_HDR_FIRST_ID */
 	mlog_write_dulint(dict_header + DICT_HDR_ROW_ID,
-				ut_dulint_create(0, DICT_HDR_FIRST_ID),
-				MLOG_8BYTES, mtr);
+				ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr);
 
 	mlog_write_dulint(dict_header + DICT_HDR_TABLE_ID,
-				ut_dulint_create(0, DICT_HDR_FIRST_ID),
-				MLOG_8BYTES, mtr);
+				ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr);
 
 	mlog_write_dulint(dict_header + DICT_HDR_INDEX_ID,
-				ut_dulint_create(0, DICT_HDR_FIRST_ID),
-				MLOG_8BYTES, mtr);
+				ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr);
 
 	mlog_write_dulint(dict_header + DICT_HDR_MIX_ID,
-				ut_dulint_create(0, DICT_HDR_FIRST_ID),
-				MLOG_8BYTES, mtr);
+				ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr);
 
 	/* Create the B-tree roots for the clustered indexes of the basic
 	system tables */
@@ -247,7 +246,7 @@ dict_boot(void)
 	dict_sys->row_id = ut_dulint_add(
 			     ut_dulint_align_up(
 				mtr_read_dulint(dict_hdr + DICT_HDR_ROW_ID,
-							MLOG_8BYTES, &mtr),
+							&mtr),
 				DICT_HDR_ROW_ID_WRITE_MARGIN),
 			     DICT_HDR_ROW_ID_WRITE_MARGIN);
 
diff --git a/innobase/dict/dict0crea.c b/innobase/dict/dict0crea.c
index ec54bb2d712..6a951317d47 100644
--- a/innobase/dict/dict0crea.c
+++ b/innobase/dict/dict0crea.c
@@ -158,7 +158,7 @@ dict_create_sys_tables_tuple(
  	if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
 		dfield_set_data(dfield, table->cluster_name,
 				ut_strlen(table->cluster_name));
-		ut_a(0); /* Oracle-style clusters are not supported yet */
+		ut_error; /* Oracle-style clusters are not supported yet */
 	} else {
 		dfield_set_data(dfield, NULL, UNIV_SQL_NULL);
 	}
@@ -272,9 +272,10 @@ dict_build_table_def_step(
 	ulint		error;
 	mtr_t		mtr;
 
-	UT_NOT_USED(thr);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
-	
+#endif /* UNIV_SYNC_DEBUG */
+
 	table = node->table;
 
 	table->id = dict_hdr_get_new_id(DICT_HDR_TABLE_ID);
@@ -369,7 +370,9 @@ dict_create_sys_indexes_tuple(
 	byte*		ptr;
 
 	UT_NOT_USED(trx);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(index && heap);
 
 	sys_indexes = dict_sys->sys_indexes;
@@ -562,8 +565,9 @@ dict_build_index_def_step(
 	dict_index_t*	index;
 	dtuple_t*	row;
 
-	UT_NOT_USED(thr);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	index = node->index;
 
@@ -635,8 +639,10 @@ dict_create_index_tree_step(
 	dtuple_t*	search_tuple;
 	btr_pcur_t	pcur;
 	mtr_t		mtr;
-	
+
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	UT_NOT_USED(thr);
 
 	index = node->index;	
@@ -701,7 +707,9 @@ dict_drop_index_tree(
 	byte*	ptr;
 	ulint	len;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	ptr = rec_get_nth_field(rec, DICT_SYS_INDEXES_PAGE_NO_FIELD, &len);
 
@@ -831,8 +839,10 @@ dict_create_table_step(
 	trx_t*		trx;
 
 	ut_ad(thr);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
-	
+#endif /* UNIV_SYNC_DEBUG */
+
 	trx = thr_get_trx(thr);
 	
 	node = thr->run_node;
@@ -939,7 +949,9 @@ dict_create_index_step(
 	trx_t*		trx;
 
 	ut_ad(thr);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	trx = thr_get_trx(thr);
 	
@@ -1128,7 +1140,7 @@ dict_create_or_check_foreign_constraint_tables(void)
 
 	graph->fork_type = QUE_FORK_MYSQL_INTERFACE;
 
-	ut_a(thr = que_fork_start_command(graph, SESS_COMM_EXECUTE, 0));
+	ut_a(thr = que_fork_start_command(graph));
 
 	que_run_threads(thr);
 
@@ -1201,7 +1213,9 @@ dict_create_add_foreigns_to_dictionary(
 	ulint		i;
 	char		buf[10000];
 
-	ut_ad(mutex_own(&(dict_sys->mutex)));	
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (NULL == dict_table_get_low((char *) "SYS_FOREIGN")) {
 		fprintf(stderr,
@@ -1262,7 +1276,7 @@ loop:
 					foreign->referenced_col_names[i]);
 	}
 
-	ut_a(len < (sizeof buf) - 19)
+	ut_a(len < (sizeof buf) - 19);
 	len += sprintf(buf + len,"COMMIT WORK;\nEND;\n");
 
 	graph = pars_sql(buf);
@@ -1274,7 +1288,7 @@ loop:
 
 	graph->fork_type = QUE_FORK_MYSQL_INTERFACE;
 
-	ut_a(thr = que_fork_start_command(graph, SESS_COMM_EXECUTE, 0));
+	ut_a(thr = que_fork_start_command(graph));
 
 	que_run_threads(thr);
 
diff --git a/innobase/dict/dict0dict.c b/innobase/dict/dict0dict.c
index 13ed5bd9af1..bf60567ceaa 100644
--- a/innobase/dict/dict0dict.c
+++ b/innobase/dict/dict0dict.c
@@ -209,7 +209,7 @@ dict_tables_have_same_db(
 		}
 	}
 
-	ut_a(0);
+	ut_error;
 
 	return(FALSE);
 }
@@ -232,7 +232,7 @@ dict_remove_db_name(
 		}
 	}
 
-	ut_a(0);
+	ut_error;
 
 	return(NULL);
 }
@@ -255,7 +255,7 @@ dict_get_db_name_len(
 		}
 	}
 
-	ut_a(0);
+	ut_error;
 
 	return(0);
 }
@@ -616,7 +616,9 @@ dict_table_get_on_id(
 		if we are doing a rollback to handle an error in TABLE
 		CREATE, for example, we already have the mutex! */
 
+#ifdef UNIV_SYNC_DEBUG
 		ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 		return(dict_table_get_on_id_low(table_id, trx));
 	}
@@ -762,7 +764,9 @@ dict_table_add_to_cache(
 	ulint	i;
 	
 	ut_ad(table);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(table->n_def == table->n_cols - DATA_N_SYS_COLS);
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 	ut_ad(table->cached == FALSE);
@@ -898,8 +902,10 @@ dict_table_rename_in_cache(
 	ulint		i;
 	
 	ut_ad(table);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
-	
+#endif /* UNIV_SYNC_DEBUG */
+
 	old_size = mem_heap_get_size(table->heap);
 	
 	fold = ut_fold_string(new_name);
@@ -1136,7 +1142,9 @@ dict_table_remove_from_cache(
 	ulint		i;
 	
 	ut_ad(table);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
 	/* printf("Removing table %s from dictionary cache\n", table->name); */
@@ -1205,9 +1213,11 @@ dict_table_LRU_trim(void)
 	dict_table_t*	table;
 	dict_table_t*	prev_table;
 
-	ut_a(0);
+	ut_error;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	table = UT_LIST_GET_LAST(dict_sys->table_LRU);
 
@@ -1236,7 +1246,9 @@ dict_col_add_to_cache(
 	ulint	fold;
 
 	ut_ad(table && col);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 	
 	fold = ut_fold_ulint_pair(ut_fold_string(table->name),
@@ -1267,7 +1279,9 @@ dict_col_remove_from_cache(
 	ulint		fold;
 
 	ut_ad(table && col);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 	
 	fold = ut_fold_ulint_pair(ut_fold_string(table->name),
@@ -1290,7 +1304,9 @@ dict_col_reposition_in_cache(
 	ulint		fold;
 
 	ut_ad(table && col);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 	
 	fold = ut_fold_ulint_pair(ut_fold_string(table->name),
@@ -1324,7 +1340,9 @@ dict_index_add_to_cache(
 	ulint		i;
 	
 	ut_ad(index);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(index->n_def == index->n_fields);
 	ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 	
@@ -1450,7 +1468,9 @@ dict_index_remove_from_cache(
 	ut_ad(table && index);
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 	ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	ut_ad(UT_LIST_GET_LEN((index->tree)->tree_indexes) == 1);
 	dict_tree_free(index->tree);
@@ -1494,7 +1514,9 @@ dict_index_find_cols(
 	
 	ut_ad(table && index);
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	for (i = 0; i < index->n_fields; i++) {
 		field = dict_index_get_nth_field(index, i);
@@ -1635,7 +1657,9 @@ dict_index_build_internal_clust(
 
 	ut_ad(table && index);
 	ut_ad(index->type & DICT_CLUSTERED);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
 	/* Create a new index object with certainly enough fields */
@@ -1804,7 +1828,9 @@ dict_index_build_internal_non_clust(
 
 	ut_ad(table && index);
 	ut_ad(0 == (index->type & DICT_CLUSTERED));
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
 	/* The clustered index should be the first in the list of indexes */
@@ -1923,7 +1949,9 @@ dict_foreign_remove_from_cache(
 /*===========================*/
 	dict_foreign_t*	foreign)	/* in, own: foreign constraint */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(foreign);
 	
 	if (foreign->referenced_table) {
@@ -1952,7 +1980,9 @@ dict_foreign_find(
 {
 	dict_foreign_t*	foreign;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	foreign = UT_LIST_GET_FIRST(table->foreign_list);
 
@@ -2061,7 +2091,9 @@ dict_foreign_add_to_cache(
 	ibool		added_to_referenced_list	= FALSE;
 	char*		buf 				= dict_foreign_err_buf;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	for_table = dict_table_check_if_in_cache_low(
 					foreign->foreign_table_name);
@@ -2732,7 +2764,9 @@ dict_create_foreign_constraints_low(
 	ulint		column_name_lens[500];
 	char		referenced_table_name[2500];
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	table = dict_table_get_low(name);
 
@@ -3312,7 +3346,9 @@ dict_foreign_parse_drop_constraints(
 	str = dict_strip_comments(*(trx->mysql_query_str));
 	ptr = str;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 loop:
 	ptr = dict_scan_to(ptr, (char *) "DROP");
 
@@ -3452,7 +3488,9 @@ dict_procedure_reserve_parsed_copy(
 	que_t*		graph;
 	proc_node_t*	proc_node;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mutex_enter(&(dict_sys->mutex));
 
@@ -3500,7 +3538,9 @@ dict_procedure_release_parsed_copy(
 {
 	proc_node_t*	proc_node;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mutex_enter(&(dict_sys->mutex));
 
@@ -3577,9 +3617,9 @@ dict_tree_create(
 	tree->id = index->id;
 	
 	UT_LIST_INIT(tree->tree_indexes);
-
+#ifdef UNIV_DEBUG
 	tree->magic_n = DICT_TREE_MAGIC_N;
-
+#endif /* UNIV_DEBUG */
 	rw_lock_create(&(tree->lock));
 
 	rw_lock_set_level(&(tree->lock), SYNC_INDEX_TREE);
@@ -3990,7 +4030,9 @@ dict_foreign_print_low(
 {
 	ulint	i;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	printf("  FOREIGN KEY CONSTRAINT %s: %s (", foreign->id,
 					foreign->foreign_table_name);
@@ -4055,7 +4097,9 @@ dict_table_print_low(
 	dict_foreign_t*	foreign;
 	ulint		i;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	dict_update_statistics_low(table, TRUE);
 	
@@ -4109,7 +4153,9 @@ dict_col_print_low(
 {
 	dtype_t*	type;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	type = dict_col_get_type(col);
 	printf("%s: ", col->name);
@@ -4129,7 +4175,9 @@ dict_index_print_low(
 	ib_longlong	n_vals;
 	ulint		i;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	tree = index->tree;
 
@@ -4175,7 +4223,9 @@ dict_field_print_low(
 /*=================*/
 	dict_field_t*	field)	/* in: field */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	printf(" %s", field->name);
 
diff --git a/innobase/dict/dict0load.c b/innobase/dict/dict0load.c
index 07c4ef3c683..c6a8ebc4b55 100644
--- a/innobase/dict/dict0load.c
+++ b/innobase/dict/dict0load.c
@@ -43,7 +43,9 @@ dict_get_first_table_name_in_db(
 	char*		table_name;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	heap = mem_heap_create(1000);
 	
@@ -307,7 +309,9 @@ dict_load_columns(
 	ulint		i;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mtr_start(&mtr);
 
@@ -414,7 +418,9 @@ dict_load_fields(
 	ulint		i;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	UT_NOT_USED(table);
 
@@ -526,7 +532,9 @@ dict_load_indexes(
 	dulint		id;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if ((ut_dulint_get_high(table->id) == 0)
 	    && (ut_dulint_get_low(table->id) < DICT_HDR_FIRST_ID)) {
@@ -700,7 +708,9 @@ dict_load_table(
 	ulint		err;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	heap = mem_heap_create(1000);
 	
@@ -791,7 +801,7 @@ dict_load_table(
 	table->type = mach_read_from_4(field);
 
 	if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
-		ut_a(0);
+		ut_error;
 	
 		field = rec_get_nth_field(rec, 6, &len);
 		table->mix_id = mach_read_from_8(field);
@@ -872,7 +882,9 @@ dict_load_table_on_id(
 	char*		name;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* NOTE that the operation of this function is protected by
 	the dictionary mutex, and therefore no deadlocks can occur
@@ -957,7 +969,9 @@ dict_load_sys_table(
 {
 	mem_heap_t*	heap;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	heap = mem_heap_create(1000);
 
@@ -988,7 +1002,9 @@ dict_load_foreign_cols(
 	ulint		i;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	foreign->foreign_col_names = mem_heap_alloc(foreign->heap,
 					foreign->n_fields * sizeof(void*));
@@ -1069,7 +1085,9 @@ dict_load_foreign(
 	ulint		err;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	heap2 = mem_heap_create(1000);
 	
@@ -1201,7 +1219,9 @@ dict_load_foreigns(
 	ulint		err;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	sys_foreign = dict_table_get_low((char *) "SYS_FOREIGN");
 
diff --git a/innobase/dict/dict0mem.c b/innobase/dict/dict0mem.c
index aed44eb246c..c49738a0960 100644
--- a/innobase/dict/dict0mem.c
+++ b/innobase/dict/dict0mem.c
@@ -92,9 +92,9 @@ dict_mem_table_create(
 	mutex_set_level(&(table->autoinc_mutex), SYNC_DICT_AUTOINC_MUTEX);
 
 	table->autoinc_inited = FALSE;
-
+#ifdef UNIV_DEBUG
 	table->magic_n = DICT_TABLE_MAGIC_N;
-	
+#endif /* UNIV_DEBUG */
 	return(table);
 }
 
@@ -219,7 +219,9 @@ dict_mem_index_create(
 	index->stat_n_diff_key_vals = NULL;
 
 	index->cached = FALSE;
+#ifdef UNIV_DEBUG
 	index->magic_n = DICT_INDEX_MAGIC_N;
+#endif /* UNIV_DEBUG */
 
 	return(index);
 }
diff --git a/innobase/fil/fil0fil.c b/innobase/fil/fil0fil.c
index ee63df08744..768dda4eedc 100644
--- a/innobase/fil/fil0fil.c
+++ b/innobase/fil/fil0fil.c
@@ -534,7 +534,9 @@ fil_node_close_file(
 	ibool	ret;
 
 	ut_ad(node && system);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(system->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(node->open);
 	ut_a(node->n_pending == 0);
 	ut_a(node->n_pending_flushes == 0);
@@ -742,7 +744,9 @@ fil_node_free(
 	fil_space_t*	space)	/* in: space where the file node is chained */
 {
 	ut_ad(node && system && space);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(system->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(node->magic_n == FIL_NODE_MAGIC_N);
 	ut_a(node->n_pending == 0);
 
@@ -3383,7 +3387,9 @@ fil_node_prepare_for_io(
 	fil_space_t*	space)	/* in: space */
 {
 	ut_ad(node && system && space);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(system->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	if (system->n_open > system->max_n_open + 5) {
 		ut_print_timestamp(stderr);
@@ -3427,7 +3433,9 @@ fil_node_complete_io(
 {
 	ut_ad(node);
 	ut_ad(system);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(system->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	ut_a(node->n_pending > 0);
 	
@@ -3561,7 +3569,7 @@ fil_io(
 			space->name, (ulong) byte_offset, (ulong) len,
 			(ulong) type);
  			
-			ut_a(0);
+			ut_error;
 		}
 
 		if (node->size > block_offset) {
@@ -3726,7 +3734,7 @@ fil_aio_wait(
 		ret = os_aio_posix_handle(segment, &fil_node, &message);
 #else
 		ret = 0; /* Eliminate compiler warning */
-		ut_a(0);
+		ut_error;
 #endif
 	} else {
 		srv_io_thread_op_info[segment] =(char *)"handle simulated aio";
diff --git a/innobase/fsp/fsp0fsp.c b/innobase/fsp/fsp0fsp.c
index 0781da3e223..9be6e1a6e50 100644
--- a/innobase/fsp/fsp0fsp.c
+++ b/innobase/fsp/fsp0fsp.c
@@ -327,9 +327,9 @@ fsp_get_space_header(
 	ut_ad(mtr);
 
 	header = FSP_HEADER_OFFSET + buf_page_get(id, 0, RW_X_LATCH, mtr);
-	
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(header, SYNC_FSP_PAGE);
-
+#endif /* UNIV_SYNC_DEBUG */
 	return(header);
 }
 
@@ -684,7 +684,9 @@ xdes_get_descriptor_with_space_hdr(
 	} else {
 		descr_page = buf_page_get(space, descr_page_no, RW_X_LATCH,
 									mtr);
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(descr_page, SYNC_FSP_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 	}	
 
 	return(descr_page + XDES_ARR_OFFSET
@@ -714,8 +716,9 @@ xdes_get_descriptor(
 
 	sp_header = FSP_HEADER_OFFSET
 				+ buf_page_get(space, 0, RW_X_LATCH, mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(sp_header, SYNC_FSP_PAGE);
-	
+#endif /* UNIV_SYNC_DEBUG */	
 	return(xdes_get_descriptor_with_space_hdr(sp_header, space, offset,
 									mtr));
 }
@@ -879,9 +882,10 @@ fsp_header_init(
 	mtr_x_lock(fil_space_get_latch(space), mtr);
 
 	page = buf_page_create(space, 0, mtr);
-	
 	buf_page_get(space, 0, RW_X_LATCH, mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_FSP_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* The prior contents of the file page should be ignored */
 
@@ -902,8 +906,7 @@ fsp_header_init(
 	flst_init(header + FSP_SEG_INODES_FULL, mtr);
 	flst_init(header + FSP_SEG_INODES_FREE, mtr);
 
-	mlog_write_dulint(header + FSP_SEG_ID, ut_dulint_create(0, 1),
-							MLOG_8BYTES, mtr); 
+	mlog_write_dulint(header + FSP_SEG_ID, ut_dulint_create(0, 1), mtr); 
 	if (space == 0) {
 		fsp_fill_free_list(FALSE, space, header, mtr);
 		btr_create(DICT_CLUSTERED | DICT_UNIVERSAL | DICT_IBUF, space,
@@ -1244,8 +1247,10 @@ fsp_fill_free_list(
 			if (i > 0) {
 				descr_page = buf_page_create(space, i, mtr);
 				buf_page_get(space, i, RW_X_LATCH, mtr);
+#ifdef UNIV_SYNC_DEBUG
 				buf_page_dbg_add_level(descr_page,
 								SYNC_FSP_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 				fsp_init_file_page(descr_page, mtr);
 			}
 
@@ -1258,11 +1263,11 @@ fsp_fill_free_list(
 
 			ibuf_page = buf_page_create(space,
 					i + FSP_IBUF_BITMAP_OFFSET, &ibuf_mtr);
-
 			buf_page_get(space, i + FSP_IBUF_BITMAP_OFFSET,
 							RW_X_LATCH, &ibuf_mtr);
+#ifdef UNIV_SYNC_DEBUG
 			buf_page_dbg_add_level(ibuf_page, SYNC_FSP_PAGE);
-
+#endif /* UNIV_SYNC_DEBUG */
 			fsp_init_file_page(ibuf_page, &ibuf_mtr);
 
 			ibuf_bitmap_page_init(ibuf_page, &ibuf_mtr);
@@ -1423,7 +1428,7 @@ fsp_alloc_free_page(
 
 		ut_print_buf(((byte*)descr) - 500, 1000);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	page_no = xdes_get_offset(descr) + free;
@@ -1478,8 +1483,9 @@ fsp_alloc_free_page(
 	buf_page_create(space, page_no, mtr);
 
 	page = buf_page_get(space, page_no, RW_X_LATCH, mtr);	
-
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_FSP_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* Prior contents of the page should be ignored */
 	fsp_init_file_page(page, mtr);
@@ -1529,7 +1535,7 @@ fsp_free_page(
 			return;
 		}
 
-		ut_a(0);
+		ut_error;
 	}
 
 	if (xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)
@@ -1599,7 +1605,7 @@ fsp_free_extent(
 
 		ut_print_buf(((byte*)descr) - 500, 1000);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	xdes_init(descr, mtr);
@@ -1714,15 +1720,15 @@ fsp_alloc_seg_inode_page(
 	buf_block_align(page)->check_index_page_at_flush = FALSE;
 
 	fil_page_set_type(page, FIL_PAGE_INODE);
-	
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_FSP_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	for (i = 0; i < FSP_SEG_INODES_PER_PAGE; i++) {
 
 		inode = fsp_seg_inode_page_get_nth_inode(page, i, mtr);
 
-		mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero,
-							MLOG_8BYTES, mtr);
+		mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr);
 	}
 
 	flst_add_last(space_header + FSP_SEG_INODES_FREE,
@@ -1762,7 +1768,9 @@ fsp_alloc_seg_inode(
 
 	page = buf_page_get(buf_frame_get_space_id(space_header), page_no,
 							RW_X_LATCH, mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_FSP_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	n = fsp_seg_inode_page_find_free(page, 0, mtr);
 
@@ -1815,7 +1823,7 @@ fsp_free_seg_inode(
 				page + FSEG_INODE_PAGE_NODE, mtr);
 	}
 
-	mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, MLOG_8BYTES, mtr); 
+	mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr); 
 	mlog_write_ulint(inode + FSEG_MAGIC_N, 0, MLOG_4BYTES, mtr); 
 	
 	if (ULINT_UNDEFINED == fsp_seg_inode_page_find_used(page, mtr)) {
@@ -2014,9 +2022,11 @@ fseg_create_general(
 									mtr);
 	}	
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex)
 	      || mtr_memo_contains(mtr, fil_space_get_latch(space),
 							MTR_MEMO_X_LOCK));
+#endif /* UNIV_SYNC_DEBUG */
 	latch = fil_space_get_latch(space);
 
 	mtr_x_lock(latch, mtr);	
@@ -2050,12 +2060,12 @@ fseg_create_general(
 	/* Read the next segment id from space header and increment the
 	value in space header */
 
-	seg_id = mtr_read_dulint(space_header + FSP_SEG_ID, MLOG_8BYTES, mtr);
+	seg_id = mtr_read_dulint(space_header + FSP_SEG_ID, mtr);
 
 	mlog_write_dulint(space_header + FSP_SEG_ID, ut_dulint_add(seg_id, 1),
-							MLOG_8BYTES, mtr);
+							mtr);
 
-	mlog_write_dulint(inode + FSEG_ID, seg_id, MLOG_8BYTES, mtr); 
+	mlog_write_dulint(inode + FSEG_ID, seg_id, mtr); 
 	mlog_write_ulint(inode + FSEG_NOT_FULL_N_USED, 0, MLOG_4BYTES, mtr); 
 
 	flst_init(inode + FSEG_FREE, mtr);
@@ -2170,9 +2180,11 @@ fseg_n_reserved_pages(
 
 	space = buf_frame_get_space_id(header);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex)
 	      || mtr_memo_contains(mtr, fil_space_get_latch(space),
 							MTR_MEMO_X_LOCK));
+#endif /* UNIV_SYNC_DEBUG */
 	mtr_x_lock(fil_space_get_latch(space), mtr);	
 
 	inode = fseg_inode_get(header, mtr);
@@ -2235,8 +2247,8 @@ fseg_fill_free_list(
 		
 		xdes_set_state(descr, XDES_FSEG, mtr);
 		
-		seg_id = mtr_read_dulint(inode + FSEG_ID, MLOG_8BYTES, mtr);
-		mlog_write_dulint(descr + XDES_ID, seg_id, MLOG_8BYTES, mtr);
+		seg_id = mtr_read_dulint(inode + FSEG_ID, mtr);
+		mlog_write_dulint(descr + XDES_ID, seg_id, mtr);
 
 		flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr);
 		hint += FSP_EXTENT_SIZE;
@@ -2277,10 +2289,10 @@ fseg_alloc_free_extent(
 			return(NULL);
 		}
 
-		seg_id = mtr_read_dulint(inode + FSEG_ID, MLOG_8BYTES, mtr);
+		seg_id = mtr_read_dulint(inode + FSEG_ID, mtr);
 		
 		xdes_set_state(descr, XDES_FSEG, mtr);
-		mlog_write_dulint(descr + XDES_ID, seg_id, MLOG_8BYTES, mtr);
+		mlog_write_dulint(descr + XDES_ID, seg_id, mtr);
 		flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr);
 		
 		/* Try to fill the segment free list */
@@ -2330,7 +2342,7 @@ fseg_alloc_free_page_low(
 	ut_ad((direction >= FSP_UP) && (direction <= FSP_NO_DIR));
 	ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N) ==
 							FSEG_MAGIC_N_VALUE);
-	seg_id = mtr_read_dulint(seg_inode + FSEG_ID, MLOG_8BYTES, mtr);
+	seg_id = mtr_read_dulint(seg_inode + FSEG_ID, mtr);
 
 	ut_ad(ut_dulint_cmp(seg_id, ut_dulint_zero) > 0);
 	
@@ -2351,8 +2363,7 @@ fseg_alloc_free_page_low(
 	/*-------------------------------------------------------------*/ 
 	if ((xdes_get_state(descr, mtr) == XDES_FSEG)
 	           && (0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID,
-							MLOG_8BYTES, mtr),
-							seg_id))
+							mtr), seg_id))
 	           && (xdes_get_bit(descr, XDES_FREE_BIT,
 				hint % FSP_EXTENT_SIZE, mtr) == TRUE)) {
 
@@ -2374,8 +2385,7 @@ fseg_alloc_free_page_low(
 		ut_a(ret_descr == descr);
 		
 		xdes_set_state(ret_descr, XDES_FSEG, mtr);
-		mlog_write_dulint(ret_descr + XDES_ID, seg_id, MLOG_8BYTES,
-									mtr);
+		mlog_write_dulint(ret_descr + XDES_ID, seg_id, mtr);
 		flst_add_last(seg_inode + FSEG_FREE,
 					ret_descr + XDES_FLST_NODE, mtr);
 
@@ -2404,8 +2414,7 @@ fseg_alloc_free_page_low(
 	/*-------------------------------------------------------------*/ 
 	} else if ((xdes_get_state(descr, mtr) == XDES_FSEG)
 	           && (0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID,
-							MLOG_8BYTES, mtr),
-						seg_id))
+							mtr), seg_id))
 	           && (!xdes_is_full(descr, mtr))) {
 
 		/* 4. We can take the page from the same extent as the
@@ -2506,7 +2515,9 @@ fseg_alloc_free_page_low(
 
 		ut_a(page == buf_page_get(space, ret_page, RW_X_LATCH, mtr));
 
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(page, SYNC_FSP_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 
 		/* The prior contents of the page should be ignored */
 		fsp_init_file_page(page, mtr);
@@ -2560,9 +2571,11 @@ fseg_alloc_free_page_general(
 
 	space = buf_frame_get_space_id(seg_header);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex)
 	      || mtr_memo_contains(mtr, fil_space_get_latch(space),
 							MTR_MEMO_X_LOCK));
+#endif /* UNIV_SYNC_DEBUG */
 	latch = fil_space_get_latch(space);
 
 	mtr_x_lock(latch, mtr);	
@@ -2708,9 +2721,11 @@ fsp_reserve_free_extents(
 	ulint		n_pages_added;
 
 	ut_ad(mtr);	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex)
 	      || mtr_memo_contains(mtr, fil_space_get_latch(space),
 							MTR_MEMO_X_LOCK));
+#endif /* UNIV_SYNC_DEBUG */
 	*n_reserved = n_ext;
 
 	latch = fil_space_get_latch(space);
@@ -2808,8 +2823,9 @@ fsp_get_available_space_in_free_extents(
 	rw_lock_t*	latch;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex));
-
+#endif /* UNIV_SYNC_DEBUG */
 	mtr_start(&mtr);
 	
 	latch = fil_space_get_latch(space);
@@ -2963,7 +2979,7 @@ fseg_free_page_low(
 		fprintf(stderr,
 "InnoDB: If the InnoDB recovery crashes here, see section 6.1\n"
 "InnoDB: of http://www.innodb.com/ibman.html about forcing recovery.\n");
-		ut_a(0);
+		ut_error;
 	}
 		
 	state = xdes_get_state(descr, mtr);
@@ -3022,7 +3038,7 @@ fseg_free_page_low(
 		fprintf(stderr,
 "InnoDB: If the InnoDB recovery crashes here, see section 6.1\n"
 "InnoDB: of http://www.innodb.com/ibman.html about forcing recovery.\n");
-		   ut_a(0);
+		   ut_error;
 	}
 
 	not_full_n_used = mtr_read_ulint(seg_inode + FSEG_NOT_FULL_N_USED,
@@ -3066,9 +3082,11 @@ fseg_free_page(
 {
 	fseg_inode_t*	seg_inode;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex)
 	      || mtr_memo_contains(mtr, fil_space_get_latch(space),
 							MTR_MEMO_X_LOCK));
+#endif /* UNIV_SYNC_DEBUG */
 	mtr_x_lock(fil_space_get_latch(space), mtr);	
 
 	seg_inode = fseg_inode_get(seg_header, mtr);
@@ -3103,8 +3121,8 @@ fseg_free_extent(
 
 	ut_a(xdes_get_state(descr, mtr) == XDES_FSEG);
 	ut_a(0 == ut_dulint_cmp(
-		mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, mtr),
-	     	mtr_read_dulint(seg_inode + FSEG_ID, MLOG_8BYTES, mtr)));
+		mtr_read_dulint(descr + XDES_ID, mtr),
+	     	mtr_read_dulint(seg_inode + FSEG_ID, mtr)));
 
 	first_page_in_extent = page - (page % FSP_EXTENT_SIZE);
 	     	
@@ -3175,9 +3193,11 @@ fseg_free_step(
 
 	space = buf_frame_get_space_id(header);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex)
 	      || mtr_memo_contains(mtr, fil_space_get_latch(space),
 							MTR_MEMO_X_LOCK));
+#endif /* UNIV_SYNC_DEBUG */
 	mtr_x_lock(fil_space_get_latch(space), mtr);	
 
 	descr = xdes_get_descriptor(space, buf_frame_get_page_no(header), mtr);
@@ -3248,9 +3268,11 @@ fseg_free_step_not_header(
 
 	space = buf_frame_get_space_id(header);
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex)
 	      || mtr_memo_contains(mtr, fil_space_get_latch(space),
 							MTR_MEMO_X_LOCK));
+#endif /* UNIV_SYNC_DEBUG */
 	mtr_x_lock(fil_space_get_latch(space), mtr);	
 
 	inode = fseg_inode_get(header, mtr);
@@ -3392,7 +3414,7 @@ fseg_validate_low(
 
 	space = buf_frame_get_space_id(inode);
 	
-	seg_id = mtr_read_dulint(inode + FSEG_ID, MLOG_8BYTES, mtr2); 
+	seg_id = mtr_read_dulint(inode + FSEG_ID, mtr2); 
 	n_used = mtr_read_ulint(inode + FSEG_NOT_FULL_N_USED,
 							MLOG_4BYTES, mtr2); 
 	flst_validate(inode + FSEG_FREE, mtr2);
@@ -3411,8 +3433,7 @@ fseg_validate_low(
 		ut_a(xdes_get_n_used(descr, &mtr) == 0);
 		ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
 		ut_a(0 == ut_dulint_cmp(
-			mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES,
-					&mtr), seg_id));
+			mtr_read_dulint(descr + XDES_ID, &mtr), seg_id));
 
 		node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
 		mtr_commit(&mtr);
@@ -3432,8 +3453,7 @@ fseg_validate_low(
 		ut_a(xdes_get_n_used(descr, &mtr) < FSP_EXTENT_SIZE);
 		ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
 		ut_a(0 == ut_dulint_cmp(
-			mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES,
-					&mtr), seg_id));
+			mtr_read_dulint(descr + XDES_ID, &mtr), seg_id));
 
 		n_used2 += xdes_get_n_used(descr, &mtr);
 
@@ -3454,8 +3474,7 @@ fseg_validate_low(
 		ut_a(xdes_get_n_used(descr, &mtr) == FSP_EXTENT_SIZE);
 		ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
 		ut_a(0 == ut_dulint_cmp(
-			mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES,
-					&mtr), seg_id));
+			mtr_read_dulint(descr + XDES_ID, &mtr), seg_id));
 
 		node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
 		mtr_commit(&mtr);
@@ -3520,7 +3539,7 @@ fseg_print_low(
 
 	reserved = fseg_n_reserved_pages_low(inode, &used, mtr);
 
-	d_var = mtr_read_dulint(inode + FSEG_ID, MLOG_8BYTES, mtr);	
+	d_var = mtr_read_dulint(inode + FSEG_ID, mtr);	
 
 	seg_id_low = ut_dulint_get_low(d_var);
 	seg_id_high = ut_dulint_get_high(d_var);
@@ -3838,7 +3857,7 @@ fsp_print(
 	n_free_frag = flst_get_len(header + FSP_FREE_FRAG, &mtr);
 	n_full_frag = flst_get_len(header + FSP_FULL_FRAG, &mtr);
 
-	d_var = mtr_read_dulint(header + FSP_SEG_ID, MLOG_8BYTES, &mtr);
+	d_var = mtr_read_dulint(header + FSP_SEG_ID, &mtr);
 
 	seg_id_low = ut_dulint_get_low(d_var);
 	seg_id_high = ut_dulint_get_high(d_var);
diff --git a/innobase/ha/ha0ha.c b/innobase/ha/ha0ha.c
index 32d50b5546e..5e807406ce0 100644
--- a/innobase/ha/ha0ha.c
+++ b/innobase/ha/ha0ha.c
@@ -89,8 +89,9 @@ ha_insert_for_fold(
 	ulint		hash;
 
 	ut_ad(table && data);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
-	
+#endif /* UNIV_SYNC_DEBUG */
 	hash = hash_calc_hash(fold, table);
 
 	cell = hash_get_nth_cell(table, hash);
@@ -186,8 +187,9 @@ ha_delete(
 {
 	ha_node_t*	node;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
-
+#endif /* UNIV_SYNC_DEBUG */
 	node = ha_search_with_data(table, fold, data);
 
 	ut_a(node);
@@ -237,8 +239,9 @@ ha_remove_all_nodes_to_page(
 {
 	ha_node_t*	node;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
-
+#endif /* UNIV_SYNC_DEBUG */
 	node = ha_chain_get_first(table, fold);
 
 	while (node) {
diff --git a/innobase/ha/hash0hash.c b/innobase/ha/hash0hash.c
index facdea66198..372104e54b3 100644
--- a/innobase/ha/hash0hash.c
+++ b/innobase/ha/hash0hash.c
@@ -22,6 +22,7 @@ hash_mutex_enter(
 	hash_table_t* 	table,	/* in: hash table */
 	ulint 		fold)	/* in: fold */
 {
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 	mutex_enter(hash_get_mutex(table, fold));
 }
 
@@ -34,41 +35,10 @@ hash_mutex_exit(
 	hash_table_t* 	table,	/* in: hash table */
 	ulint 		fold)	/* in: fold */
 {
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 	mutex_exit(hash_get_mutex(table, fold));
 }
 
-/****************************************************************
-Reserves all the mutexes of a hash table, in an ascending order. */
-
-void
-hash_mutex_enter_all(
-/*=================*/
-	hash_table_t* 	table)	/* in: hash table */
-{
-	ulint	i;
-
-	for (i = 0; i < table->n_mutexes; i++) {
-
-		mutex_enter(table->mutexes + i);
-	}
-}
-
-/****************************************************************
-Releases all the mutexes of a hash table. */
-
-void
-hash_mutex_exit_all(
-/*================*/
-	hash_table_t* 	table)	/* in: hash table */
-{
-	ulint	i;
-
-	for (i = 0; i < table->n_mutexes; i++) {
-
-		mutex_exit(table->mutexes + i);
-	}
-}
-
 /*****************************************************************
 Creates a hash table with >= n array cells. The actual number of cells is
 chosen to be a prime number slightly bigger than n. */
@@ -98,7 +68,9 @@ hash_create(
 	table->mutexes = NULL;
 	table->heaps = NULL;
 	table->heap = NULL;
+#ifdef UNIV_DEBUG
 	table->magic_n = HASH_TABLE_MAGIC_N;
+#endif /* UNIV_DEBUG */
 	
 	/* Initialize the cell array */
 
@@ -119,6 +91,7 @@ hash_table_free(
 /*============*/
 	hash_table_t*	table)	/* in, own: hash table */
 {
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 	ut_a(table->mutexes == NULL);
 
 	ut_free(table->array);
@@ -140,6 +113,7 @@ hash_create_mutexes(
 	ulint	i;
 
 	ut_a(n_mutexes == ut_2_power_up(n_mutexes));
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 
 	table->mutexes = mem_alloc(n_mutexes * sizeof(mutex_t));
 
diff --git a/innobase/ibuf/ibuf0ibuf.c b/innobase/ibuf/ibuf0ibuf.c
index 805f08af361..42ca34e7f10 100644
--- a/innobase/ibuf/ibuf0ibuf.c
+++ b/innobase/ibuf/ibuf0ibuf.c
@@ -270,7 +270,9 @@ ibuf_header_page_get(
 
 	page = buf_page_get(space, FSP_IBUF_HEADER_PAGE_NO, RW_X_LATCH, mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_IBUF_HEADER);
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(page);
 }
@@ -295,7 +297,9 @@ ibuf_tree_root_get(
 
 	page = buf_page_get(space, FSP_IBUF_TREE_ROOT_PAGE_NO, RW_X_LATCH,
 									mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_TREE_NODE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(page);
 }
@@ -407,7 +411,9 @@ ibuf_data_sizes_update(
 {
 	ulint	old_size;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&ibuf_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	old_size = data->size;
 	
@@ -489,7 +495,9 @@ ibuf_data_init_for_space(
 	
 	root = buf_page_get(space, FSP_IBUF_TREE_ROOT_PAGE_NO, RW_X_LATCH,
 								&mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(root, SYNC_TREE_NODE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	data->size = 0;
 	data->n_inserts = 0;
@@ -721,7 +729,9 @@ ibuf_bitmap_get_map_page(
 
 	page = buf_page_get(space, ibuf_bitmap_page_no_calc(page_no),
 							RW_X_LATCH, mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_IBUF_BITMAP);
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(page);
 }
@@ -1446,7 +1456,9 @@ ibuf_data_enough_free_for_insert(
 				/* out: TRUE if enough free pages in list */
 	ibuf_data_t*	data)	/* in: ibuf data for the space */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&ibuf_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* We want a big margin of free pages, because a B-tree can sometimes
 	grow in size also if records are deleted from it, as the node pointers
@@ -1472,7 +1484,9 @@ ibuf_data_too_much_free(
 				/* out: TRUE if enough free pages in list */
 	ibuf_data_t*	data)	/* in: ibuf data for the space */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&ibuf_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (data->free_list_len >= 3 + data->size / 2 + 3 * data->height) {
 
@@ -1532,7 +1546,9 @@ ibuf_add_free_page(
 
 	page = buf_page_get(space, page_no, RW_X_LATCH, &mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_TREE_NODE_NEW);
+#endif /* UNIV_SYNC_DEBUG */
 
 	ibuf_enter();
 
@@ -1653,7 +1669,9 @@ ibuf_remove_free_page(
 
 	page = buf_page_get(space, page_no, RW_X_LATCH, &mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_TREE_NODE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* Remove the page from the free list and update the ibuf size data */
 	
@@ -1694,14 +1712,16 @@ ibuf_free_excess_pages(
 {
 	ibuf_data_t*	ibuf_data;
 	ulint		i;
-	
+
 	if (space != 0) {
 	        fprintf(stderr,
 "InnoDB: Error: calling ibuf_free_excess_pages for space %lu\n", (ulong) space);
 		return;
 	}
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(fil_space_get_latch(space), RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(rw_lock_get_x_lock_count(fil_space_get_latch(space)) == 1);
 	ut_ad(!ibuf_inside());
 	
@@ -2208,7 +2228,9 @@ ibuf_get_volume_buffered(
 
 	prev_page = buf_page_get(0, prev_page_no, RW_X_LATCH, mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(prev_page, SYNC_TREE_NODE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	rec = page_get_supremum_rec(prev_page);
 	rec = page_rec_get_prev(rec);
@@ -2269,7 +2291,9 @@ count_later:
 
 	next_page = buf_page_get(0, next_page_no, RW_X_LATCH, mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(next_page, SYNC_TREE_NODE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	rec = page_get_infimum_rec(next_page);
 	rec = page_rec_get_next(rec);
@@ -3018,7 +3042,9 @@ loop:
 					IB__FILE__, __LINE__,
 					&mtr);
 		ut_a(success);
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(page, SYNC_TREE_NODE);
+#endif /* UNIV_SYNC_DEBUG */
 	}
 		
 	/* Position pcur in the insert buffer at the first entry for this
@@ -3261,7 +3287,9 @@ ibuf_validate_low(void)
 	ibuf_data_t*	data;
 	ulint		sum_sizes;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&ibuf_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	sum_sizes = 0;
 	
diff --git a/innobase/include/Makefile.am b/innobase/include/Makefile.am
index ab1f14d0770..2584357e24a 100644
--- a/innobase/include/Makefile.am
+++ b/innobase/include/Makefile.am
@@ -18,21 +18,20 @@
 noinst_HEADERS = btr0btr.h btr0btr.ic btr0cur.h btr0cur.ic \
         btr0pcur.h btr0pcur.ic btr0sea.h btr0sea.ic btr0types.h \
         buf0buf.h buf0buf.ic buf0flu.h buf0flu.ic buf0lru.h \
-        buf0lru.ic buf0rea.h buf0types.h com0com.h com0com.ic \
-        com0shm.h com0shm.ic data0data.h data0data.ic data0type.h \
+        buf0lru.ic buf0rea.h buf0types.h data0data.h data0data.ic data0type.h \
         data0type.ic data0types.h db0err.h dict0boot.h \
         dict0boot.ic dict0crea.h dict0crea.ic dict0dict.h \
         dict0dict.ic dict0load.h dict0load.ic dict0mem.h \
         dict0mem.ic dict0types.h dyn0dyn.h dyn0dyn.ic eval0eval.h \
         eval0eval.ic eval0proc.h eval0proc.ic fil0fil.h fsp0fsp.h \
         fsp0fsp.ic fut0fut.h fut0fut.ic fut0lst.h fut0lst.ic \
-        ha0ha.h ha0ha.ic hash0hash.h hash0hash.ic ib_odbc.h \
+        ha0ha.h ha0ha.ic hash0hash.h hash0hash.ic \
         ibuf0ibuf.h ibuf0ibuf.ic ibuf0types.h lock0lock.h \
         lock0lock.ic lock0types.h log0log.h log0log.ic log0recv.h \
         log0recv.ic mach0data.h mach0data.ic makefilewin.i \
         mem0dbg.h mem0dbg.ic mem0mem.h mem0mem.ic mem0pool.h \
         mem0pool.ic mtr0log.h mtr0log.ic mtr0mtr.h mtr0mtr.ic \
-        mtr0types.h odbc0odbc.h os0file.h os0proc.h os0proc.ic \
+        mtr0types.h os0file.h os0proc.h os0proc.ic \
         os0shm.h os0shm.ic os0sync.h os0sync.ic os0thread.h \
         os0thread.ic page0cur.h page0cur.ic page0page.h \
         page0page.ic page0types.h pars0grm.h pars0opt.h \
diff --git a/innobase/include/btr0btr.ic b/innobase/include/btr0btr.ic
index 301a73b3444..b0aa0756307 100644
--- a/innobase/include/btr0btr.ic
+++ b/innobase/include/btr0btr.ic
@@ -45,8 +45,7 @@ btr_page_set_index_id(
 	dulint		id,	/* in: index id */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	mlog_write_dulint(page + PAGE_HEADER + PAGE_INDEX_ID, id,
-							MLOG_8BYTES, mtr);
+	mlog_write_dulint(page + PAGE_HEADER + PAGE_INDEX_ID, id, mtr);
 }
 
 /******************************************************************
diff --git a/innobase/include/btr0sea.ic b/innobase/include/btr0sea.ic
index 63a3a658cf4..8a41042f713 100644
--- a/innobase/include/btr0sea.ic
+++ b/innobase/include/btr0sea.ic
@@ -44,8 +44,10 @@ btr_search_info_update(
 {
 	btr_search_t*	info;
 
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED)
-			&& !rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	info = btr_search_get_info(index);
 
diff --git a/innobase/include/buf0buf.h b/innobase/include/buf0buf.h
index 3f2fd5bbbe0..3cab717546a 100644
--- a/innobase/include/buf0buf.h
+++ b/innobase/include/buf0buf.h
@@ -562,11 +562,11 @@ buf_awe_map_page_to_frame(
 					we need to map the page should also
 					add the block to the
 					awe_LRU_free_mapped list */
+#ifdef UNIV_SYNC_DEBUG
 /*************************************************************************
 Adds latch level info for the rw-lock protecting the buffer frame. This
 should be called in the debug version after a successful latching of a
-page if we know the latching order level of the acquired latch. If
-UNIV_SYNC_DEBUG is not defined, compiles to an empty function. */
+page if we know the latching order level of the acquired latch. */
 UNIV_INLINE
 void
 buf_page_dbg_add_level(
@@ -574,6 +574,7 @@ buf_page_dbg_add_level(
 	buf_frame_t*	frame,	/* in: buffer page where we have acquired
 				a latch */
 	ulint		level);	/* in: latching order level */
+#endif /* UNIV_SYNC_DEBUG */
 /*************************************************************************
 Gets a pointer to the memory frame of a block. */
 UNIV_INLINE
diff --git a/innobase/include/buf0buf.ic b/innobase/include/buf0buf.ic
index 0df8570e4e2..cb54785128f 100644
--- a/innobase/include/buf0buf.ic
+++ b/innobase/include/buf0buf.ic
@@ -130,7 +130,9 @@ buf_pool_clock_tic(void)
 /*====================*/
 			/* out: new clock value */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	buf_pool->ulint_clock++;
 
@@ -221,7 +223,7 @@ buf_block_align(
 "InnoDB: how to force recovery.\n",
  			(long)ptr, (long)frame_zero,
 					(long)(buf_pool->high_end));
-		ut_a(0);
+		ut_error;
 	}
 	
 	block = *(buf_pool->blocks_of_frames + (((ulint)(ptr - frame_zero))
@@ -257,7 +259,7 @@ buf_frame_align(
 "InnoDB: how to force recovery.\n",
  			(long)ptr, (long)(buf_pool->frame_zero),
 					(long)(buf_pool->high_end));
-		ut_a(0);
+		ut_error;
 	}
 
 	return(frame);
@@ -447,8 +449,10 @@ buf_frame_modify_clock_inc(
 
 	block = buf_block_align(frame);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad((mutex_own(&(buf_pool->mutex)) && (block->buf_fix_count == 0))
 	      || rw_lock_own(&(block->lock), RW_LOCK_EXCLUSIVE));
+#endif /*UNIV_SYNC_DEBUG */
 
 	UT_DULINT_INC(block->modify_clock);
 
@@ -466,8 +470,10 @@ buf_block_modify_clock_inc(
 				/* out: new value */
 	buf_block_t*	block)	/* in: block */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad((mutex_own(&(buf_pool->mutex)) && (block->buf_fix_count == 0))
 	      || rw_lock_own(&(block->lock), RW_LOCK_EXCLUSIVE));
+#endif /* UNIV_SYNC_DEBUG */
 
 	UT_DULINT_INC(block->modify_clock);
 
@@ -490,8 +496,10 @@ buf_frame_get_modify_clock(
 
 	block = buf_block_align(frame);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
 	      || rw_lock_own(&(block->lock), RW_LOCK_EXCLUSIVE));
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(block->modify_clock);
 }
@@ -542,7 +550,9 @@ buf_page_hash_get(
 	ulint		fold;
 	
 	ut_ad(buf_pool);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* Look for the page in the hash table */
 
@@ -642,6 +652,7 @@ buf_page_release(
 	}
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /*************************************************************************
 Adds latch level info for the rw-lock protecting the buffer frame. This
 should be called in the debug version after a successful latching of a
@@ -656,7 +667,6 @@ buf_page_dbg_add_level(
 	ulint		level __attribute__((unused))) /* in: latching order
                                 level */
 {
-#ifdef UNIV_SYNC_DEBUG
 	sync_thread_add_level(&(buf_block_align(frame)->lock), level);
-#endif
 }
+#endif /* UNIV_SYNC_DEBUG */
diff --git a/innobase/include/buf0flu.ic b/innobase/include/buf0flu.ic
index e2faf773cab..d6dbdcc0865 100644
--- a/innobase/include/buf0flu.ic
+++ b/innobase/include/buf0flu.ic
@@ -40,8 +40,10 @@ buf_flush_note_modification(
 	ut_ad(block);
 	ut_ad(block->state == BUF_BLOCK_FILE_PAGE);
 	ut_ad(block->buf_fix_count > 0);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX));
 	ut_ad(mutex_own(&(buf_pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	ut_ad(ut_dulint_cmp(mtr->start_lsn, ut_dulint_zero) != 0);
 	ut_ad(mtr->modifications);
@@ -76,7 +78,9 @@ buf_flush_recv_note_modification(
 	ut_ad(block);
 	ut_ad(block->state == BUF_BLOCK_FILE_PAGE);
 	ut_ad(block->buf_fix_count > 0);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mutex_enter(&(buf_pool->mutex));
 	
diff --git a/innobase/include/com0com.h b/innobase/include/com0com.h
deleted file mode 100644
index 6f04b6a3f11..00000000000
--- a/innobase/include/com0com.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/******************************************************
-The communication primitives
-
-(c) 1995 Innobase Oy
-
-Created 9/23/1995 Heikki Tuuri
-*******************************************************/
-
-/* This module defines a standard datagram communication
-function interface for use in the database. We assume that
-the communication medium is reliable. */
-
-#ifndef com0com_h
-#define com0com_h
-
-#include "univ.i"
-
-/* The communications endpoint type definition */
-typedef struct com_endpoint_struct	com_endpoint_t;
-
-/* Possible endpoint communication types */
-#define	COM_SHM		1	/* communication through shared memory */
-
-/* Option numbers for endpoint */
-#define COM_OPT_MAX_DGRAM_SIZE	1
-
-/* Error numbers */
-#define COM_ERR_NOT_SPECIFIED			1
-#define COM_ERR_NOT_BOUND			2
-#define COM_ERR_ALREADY_BOUND			3
-#define COM_ERR_MAX_DATAGRAM_SIZE_NOT_SET	4
-#define COM_ERR_DATA_BUFFER_TOO_SMALL		5
-#define COM_ERR_ADDR_BUFFER_TOO_SMALL		6
-#define COM_ERR_DATA_TOO_LONG			7
-#define COM_ERR_ADDR_TOO_LONG			8
-#define COM_ERR_DGRAM_NOT_DELIVERED		9
-
-/* Maximum allowed address length in bytes */
-#define COM_MAX_ADDR_LEN	100
-
-/*************************************************************************
-Creates a communications endpoint. */
-
-com_endpoint_t*
-com_endpoint_create(
-/*================*/
-			/* out, own: communications endpoint, NULL if
-			did not succeed */
-	ulint	type);	/* in: communication type of endpoint:
-			only COM_SHM supported */
-/*************************************************************************
-Frees a communications endpoint. */
-
-ulint
-com_endpoint_free(
-/*==============*/
-				/* out: O if succeed, else error number */
-	com_endpoint_t*	ep);	/* in, own: communications endpoint */
-/*************************************************************************
-Sets an option, like the maximum datagram size for an endpoint.
-The options may vary depending on the endpoint type. */
-
-ulint
-com_endpoint_set_option(
-/*====================*/
-				/* out: 0 if succeed, else error number */
-	com_endpoint_t*	ep,	/* in: endpoint */
-	ulint		optno,	/* in: option number, only
-				COM_OPT_MAX_DGRAM_SIZE currently supported */
-	byte*		optval,	/* in: pointer to a buffer containing the
-				option value to set */
-	ulint		optlen);/* in: option value buffer length */
-/*************************************************************************
-Binds a communications endpoint to a specified address. */
-
-ulint
-com_bind(
-/*=====*/
-				/* out: 0 if succeed, else error number */
-	com_endpoint_t*	ep,	/* in: communications endpoint */
-	char*		name,	/* in: address name */
-	ulint		len);	/* in: name length */
-/*************************************************************************
-Waits for a datagram to arrive at an endpoint. */
-
-ulint
-com_recvfrom(
-/*=========*/
-				/* out: 0 if succeed, else error number */
-	com_endpoint_t*	ep,	/* in: communications endpoint */
-	byte*		buf,	/* out: datagram buffer; the buffer must be
-				supplied by the caller */
-	ulint		buf_len,/* in: datagram buffer length */
-	ulint*		len,	/* out: datagram length */
-	char*		from,	/* out: address name buffer; the buffer must be
-				supplied by the caller */
-	ulint		from_len,/* in: address name buffer length */
-	ulint*		addr_len);/* out: address name length */
-/*************************************************************************
-Sends a datagram to a specified destination. */
-
-ulint
-com_sendto(
-/*=======*/
-				/* out: 0 if succeed, else error number */
-	com_endpoint_t*	ep,	/* in: communications endpoint */
-	byte*		buf,	/* in: datagram buffer */
-	ulint		len,	/* in: datagram length */
-	char*		to,	/* in: address name buffer */
-	ulint		tolen);	/* in: address name length */
-/*************************************************************************
-Gets the maximum datagram size for an endpoint. */
-
-ulint
-com_endpoint_get_max_size(
-/*======================*/
-				/* out: maximum size */
-	com_endpoint_t*	ep);	/* in: endpoint */
-
-
-#ifndef UNIV_NONINL
-#include "com0com.ic"
-#endif
-
-#endif
diff --git a/innobase/include/com0com.ic b/innobase/include/com0com.ic
deleted file mode 100644
index cec1cb190cc..00000000000
--- a/innobase/include/com0com.ic
+++ /dev/null
@@ -1,7 +0,0 @@
-/******************************************************
-The communication primitives
-
-(c) 1995 Innobase Oy
-
-Created 9/23/1995 Heikki Tuuri
-*******************************************************/
diff --git a/innobase/include/com0shm.h b/innobase/include/com0shm.h
deleted file mode 100644
index 7de9c4ac2de..00000000000
--- a/innobase/include/com0shm.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/******************************************************
-The communication through shared memory
-
-(c) 1995 Innobase Oy
-
-Created 9/23/1995 Heikki Tuuri
-*******************************************************/
-
-#ifndef com0shm_h
-#define com0shm_h
-
-#include "univ.i"
-
-typedef struct com_shm_endpoint_struct	com_shm_endpoint_t;
-
-/* The performance of communication in NT depends on how
-many times a system call is made (excluding os_thread_yield,
-as that is the fastest way to switch thread).
-The following variable counts such events. */
-
-extern ulint	com_shm_system_call_count;
-
-
-/*************************************************************************
-Creates a communications endpoint. */
-
-com_shm_endpoint_t*
-com_shm_endpoint_create(void);
-/*=========================*/
-			/* out, own: communications endpoint, NULL if
-			did not succeed */
-/*************************************************************************
-Frees a communications endpoint. */
-
-ulint
-com_shm_endpoint_free(
-/*==================*/
-				/* out: O if succeed, else error number */
-	com_shm_endpoint_t* ep);/* in, own: communications endpoint */
-/*************************************************************************
-Sets an option, like the maximum datagram size for an endpoint.
-The options may vary depending on the endpoint type. */
-
-ulint
-com_shm_endpoint_set_option(
-/*========================*/
-				/* out: 0 if succeed, else error number */
-	com_shm_endpoint_t* 	ep,	/* in: endpoint */
-	ulint		optno,	/* in: option number, only
-				COM_OPT_MAX_DGRAM_SIZE currently supported */
-	byte*		optval,	/* in: pointer to a buffer containing the
-				option value to set */
-	ulint		optlen);/* in: option value buffer length */
-/*************************************************************************
-Bind a communications endpoint to a specified address. */
-
-ulint
-com_shm_bind(
-/*=========*/
-				/* out: 0 if succeed, else error number */
-	com_shm_endpoint_t* ep,	/* in: communications endpoint */
-	char*		name,	/* in: address name */
-	ulint		len);	/* in: address name length */
-/*************************************************************************
-Waits for a datagram to arrive at an endpoint. */
-
-ulint
-com_shm_recvfrom(
-/*=============*/
-				/* out: 0 if succeed, else error number */
-	com_shm_endpoint_t* ep,	/* in: communications endpoint */
-	byte*		buf,	/* out: datagram buffer; the buffer is
-				supplied by the caller */
-	ulint		buf_len,/* in: datagram buffer length */
-	ulint*		len,	/* out: datagram length */
-	char*		from,	/* out: address name buffer; the buffer is
-				supplied by the caller */
-	ulint		from_len,/* in: address name buffer length */
-	ulint*		addr_len);/* out: address name length */
-/*************************************************************************
-Sends a datagram to the specified destination. */
-
-ulint
-com_shm_sendto(
-/*===========*/
-				/* out: 0 if succeed, else error number */
-	com_shm_endpoint_t* ep,	/* in: communications endpoint */
-	byte*		buf,	/* in: datagram buffer */
-	ulint		len,	/* in: datagram length */
-	char*		to,	/* in: address name buffer */
-	ulint		tolen);	/* in: address name length */
-
-ulint
-com_shm_endpoint_get_size(
-/*======================*/
-	com_shm_endpoint_t*	ep);
-
-
-#ifndef UNIV_NONINL
-#include "com0shm.ic"
-#endif
-
-#endif
diff --git a/innobase/include/com0shm.ic b/innobase/include/com0shm.ic
deleted file mode 100644
index e0d3cb26f69..00000000000
--- a/innobase/include/com0shm.ic
+++ /dev/null
@@ -1,7 +0,0 @@
-/******************************************************
-Communication through shared memory
-
-(c) 1995 Innobase Oy
-
-Created 9/23/1995 Heikki Tuuri
-*******************************************************/
diff --git a/innobase/include/data0data.h b/innobase/include/data0data.h
index 2501d2b809f..c4e93bec738 100644
--- a/innobase/include/data0data.h
+++ b/innobase/include/data0data.h
@@ -402,9 +402,11 @@ struct dtuple_struct {
 	UT_LIST_NODE_T(dtuple_t) tuple_list;
 					/* data tuples can be linked into a
 					list using this field */
-	ulint		magic_n;	
-};
+#ifdef UNIV_DEBUG
+	ulint		magic_n;
 #define	DATA_TUPLE_MAGIC_N	65478679
+#endif /* UNIV_DEBUG */
+};
 
 /* A slot for a field in a big rec vector */
 
diff --git a/innobase/include/data0type.ic b/innobase/include/data0type.ic
index 21f617c7590..946b646ffbf 100644
--- a/innobase/include/data0type.ic
+++ b/innobase/include/data0type.ic
@@ -280,7 +280,7 @@ dtype_get_fixed_size(
 	case DATA_VARMYSQL:
 	case DATA_BLOB:
 			return(0); 
-	default:	ut_a(0);
+	default:	ut_error;
 	}
 
 	return(0);
diff --git a/innobase/include/dict0dict.ic b/innobase/include/dict0dict.ic
index c5982c162a7..b70822e331f 100644
--- a/innobase/include/dict0dict.ic
+++ b/innobase/include/dict0dict.ic
@@ -543,8 +543,10 @@ dict_table_check_if_in_cache_low(
 	ulint		table_fold;
 	
 	ut_ad(table_name);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
-	
+#endif /* UNIV_SYNC_DEBUG */
+
 	/* Look for the table name in the hash table */
 	table_fold = ut_fold_string(table_name);
 
@@ -566,8 +568,10 @@ dict_table_get_low(
 	dict_table_t*	table;
 	
 	ut_ad(table_name);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
-	
+#endif /* UNIV_SYNC_DEBUG */
+
 	table = dict_table_check_if_in_cache_low(table_name);
 	
 	if (table == NULL) {
@@ -621,7 +625,9 @@ dict_table_get_on_id_low(
 	dict_table_t*	table;
 	ulint		fold;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	UT_NOT_USED(trx);
 	
 	/* Look for the table name in the hash table */
diff --git a/innobase/include/dict0mem.h b/innobase/include/dict0mem.h
index b18e20a644a..23753df4079 100644
--- a/innobase/include/dict0mem.h
+++ b/innobase/include/dict0mem.h
@@ -198,10 +198,11 @@ struct dict_tree_struct{
 				the list; if the tree is of the mixed
 				type, the first index in the list is the
 				index of the cluster which owns the tree */
+#ifdef UNIV_DEBUG
 	ulint		magic_n;/* magic number */
-};
-
 #define	DICT_TREE_MAGIC_N	7545676
+#endif /* UNIV_DEBUG */
+};
 
 /* Data structure for an index */
 struct dict_index_struct{
@@ -247,7 +248,10 @@ struct dict_index_struct{
 	ulint		stat_n_leaf_pages;
 				/* approximate number of leaf pages in the
 				index tree */
+#ifdef UNIV_DEBUG
 	ulint		magic_n;/* magic number */
+#define	DICT_INDEX_MAGIC_N	76789786
+#endif /* UNIV_DEBUG */
 };
 
 /* Data structure for a foreign key constraint; an example:
@@ -298,9 +302,6 @@ a foreign key constraint is enforced, therefore RESTRICT just means no flag */
 #define DICT_FOREIGN_ON_DELETE_NO_ACTION 16
 #define DICT_FOREIGN_ON_UPDATE_NO_ACTION 32
 
-
-#define	DICT_INDEX_MAGIC_N	76789786
-
 /* Data structure for a database table */
 struct dict_table_struct{
 	dulint		id;	/* id of the table or cluster */
@@ -419,10 +420,12 @@ struct dict_table_struct{
 				inited; MySQL gets the init value by executing
 				SELECT MAX(auto inc column) */
 	ib_longlong	autoinc;/* autoinc counter value to give to the
-				next inserted row */	
+				next inserted row */
+#ifdef UNIV_DEBUG
 	ulint		magic_n;/* magic number */
-};
 #define	DICT_TABLE_MAGIC_N	76333786
+#endif /* UNIV_DEBUG */
+};
 					
 /* Data structure for a stored procedure */
 struct dict_proc_struct{
diff --git a/innobase/include/fut0fut.ic b/innobase/include/fut0fut.ic
index 0f1aa9dd9ae..6a107786376 100644
--- a/innobase/include/fut0fut.ic
+++ b/innobase/include/fut0fut.ic
@@ -30,7 +30,9 @@ fut_get_ptr(
 
 	ptr = buf_page_get(space, addr.page, rw_latch, mtr) + addr.boffset;
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(ptr, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(ptr);
 }
diff --git a/innobase/include/ha0ha.ic b/innobase/include/ha0ha.ic
index 77064cdf9da..5369ca7f273 100644
--- a/innobase/include/ha0ha.ic
+++ b/innobase/include/ha0ha.ic
@@ -81,7 +81,9 @@ ha_search(
 {
 	ha_node_t*	node;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	node = ha_chain_get_first(table, fold);
 
@@ -111,7 +113,9 @@ ha_search_and_get_data(
 {
 	ha_node_t*	node;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	node = ha_chain_get_first(table, fold);
 
@@ -170,7 +174,9 @@ ha_search_with_data(
 {
 	ha_node_t*	node;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	node = ha_chain_get_first(table, fold);
 
@@ -200,7 +206,9 @@ ha_search_and_delete_if_found(
 {
 	ha_node_t*	node;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	node = ha_search_with_data(table, fold, data);
 
diff --git a/innobase/include/hash0hash.h b/innobase/include/hash0hash.h
index 2e9ab498116..79efe016324 100644
--- a/innobase/include/hash0hash.h
+++ b/innobase/include/hash0hash.h
@@ -53,15 +53,24 @@ hash_calc_hash(
 				/* out: hashed value */
 	ulint		fold,	/* in: folded value */
 	hash_table_t*	table);	/* in: hash table */
+/************************************************************************
+Assert that the mutex for the table in a hash operation is owned. */
+#ifdef UNIV_SYNC_DEBUG
+# define HASH_ASSERT_OWNED(TABLE, FOLD) \
+ut_ad(!(TABLE)->mutexes || mutex_own(hash_get_mutex(TABLE, FOLD)));
+#else
+# define HASH_ASSERT_OWNED(TABLE, FOLD)
+#endif
+
 /***********************************************************************
 Inserts a struct to a hash table. */
 
 #define HASH_INSERT(TYPE, NAME, TABLE, FOLD, DATA)\
-{\
+do {\
 	hash_cell_t*	cell3333;\
 	TYPE*		struct3333;\
 \
-	ut_ad(!(TABLE)->mutexes || mutex_own(hash_get_mutex(TABLE, FOLD)));\
+	HASH_ASSERT_OWNED(TABLE, FOLD)\
 \
 	(DATA)->NAME = NULL;\
 \
@@ -79,17 +88,17 @@ Inserts a struct to a hash table. */
 \
 		struct3333->NAME = DATA;\
 	}\
-}
+} while (0)
 
 /***********************************************************************
 Deletes a struct from a hash table. */
 
 #define HASH_DELETE(TYPE, NAME, TABLE, FOLD, DATA)\
-{\
+do {\
 	hash_cell_t*	cell3333;\
 	TYPE*		struct3333;\
 \
-	ut_ad(!(TABLE)->mutexes || mutex_own(hash_get_mutex(TABLE, FOLD)));\
+	HASH_ASSERT_OWNED(TABLE, FOLD)\
 \
 	cell3333 = hash_get_nth_cell(TABLE, hash_calc_hash(FOLD, TABLE));\
 \
@@ -100,13 +109,13 @@ Deletes a struct from a hash table. */
 \
 		while (struct3333->NAME != DATA) {\
 \
-			ut_a(struct3333)\
+			ut_a(struct3333);\
 			struct3333 = struct3333->NAME;\
 		}\
 \
 		struct3333->NAME = DATA->NAME;\
 	}\
-}
+} while (0)
 
 /***********************************************************************
 Gets the first struct in a hash chain, NULL if none. */
@@ -124,7 +133,7 @@ Looks for a struct in a hash table. */
 #define HASH_SEARCH(NAME, TABLE, FOLD, DATA, TEST)\
 {\
 \
-	ut_ad(!(TABLE)->mutexes || mutex_own(hash_get_mutex(TABLE, FOLD)));\
+	HASH_ASSERT_OWNED(TABLE, FOLD)\
 \
 	(DATA) = HASH_GET_FIRST(TABLE, hash_calc_hash(FOLD, TABLE));\
 \
@@ -160,7 +169,7 @@ the heap. The fold value must be stored in the struct NODE in a field named
 'fold'. */
 
 #define HASH_DELETE_AND_COMPACT(TYPE, NAME, TABLE, NODE)\
-{\
+do {\
 	TYPE*		node111;\
 	TYPE*		top_node111;\
 	hash_cell_t*	cell111;\
@@ -211,33 +220,7 @@ the heap. The fold value must be stored in the struct NODE in a field named
 	/* Free the space occupied by the top node */\
 \
 	mem_heap_free_top(hash_get_heap(TABLE, fold111), sizeof(TYPE));\
-}
-
-/***********************************************************************
-Calculates the number of stored structs in a hash table. */
-
-#define HASH_GET_N_NODES(TYPE, NAME, TABLE, N)\
-{\
-	hash_cell_t*	cell3333;\
-	TYPE*		struct3333;\
-	ulint		i3333;\
-\
-	(N) = 0;\
-\
-	for (i3333 = 0; i3333 < hash_get_n_cells(TABLE); i3333++) {\
-\
-		cell3333 = hash_get_nth_cell(TABLE, i3333);\
-\
-		struct3333 = cell3333->node;\
-\
-		while (struct3333) {\
-\
-			(N) = (N) + 1;\
-\
-			struct = HASH_GET_NEXT(NAME, struct3333);\
-		}\
-	}\
-}
+} while (0)
 
 /****************************************************************
 Gets the mutex index for a fold value in a hash table. */
@@ -300,21 +283,6 @@ hash_mutex_exit(
 /*============*/
 	hash_table_t* 	table,	/* in: hash table */
 	ulint 		fold);	/* in: fold */
-/****************************************************************
-Reserves all the mutexes of a hash table, in an ascending order. */
-
-void
-hash_mutex_enter_all(
-/*=================*/
-	hash_table_t* 	table);	/* in: hash table */
-/****************************************************************
-Releases all the mutexes of a hash table. */
-
-void
-hash_mutex_exit_all(
-/*================*/
-	hash_table_t* 	table);	/* in: hash table */
-
 
 struct hash_cell_struct{
 	void*	node;	/* hash chain node, NULL if none */
@@ -335,10 +303,11 @@ struct hash_table_struct {
 				memory heaps; there are then n_mutexes many of
 				these heaps */
 	mem_heap_t*	heap;
+#ifdef UNIV_DEBUG
 	ulint		magic_n;
-};
-
 #define HASH_TABLE_MAGIC_N	76561114
+#endif /* UNIV_DEBUG */
+};
 
 #ifndef UNIV_NONINL
 #include "hash0hash.ic"
diff --git a/innobase/include/hash0hash.ic b/innobase/include/hash0hash.ic
index 0d713140c13..1b9acfa2f34 100644
--- a/innobase/include/hash0hash.ic
+++ b/innobase/include/hash0hash.ic
@@ -18,6 +18,7 @@ hash_get_nth_cell(
 	hash_table_t* 	table,	/* in: hash table */
 	ulint 		n)	/* in: cell index */
 {
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 	ut_ad(n < table->n_cells);
 
 	return(table->array + n);
@@ -32,6 +33,7 @@ hash_get_n_cells(
 				/* out: number of cells */
 	hash_table_t*	table)	/* in: table */
 {
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 	return(table->n_cells);
 }
 
@@ -45,6 +47,7 @@ hash_calc_hash(
 	ulint		fold,	/* in: folded value */
 	hash_table_t*	table)	/* in: hash table */
 {
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 	return(ut_hash_ulint(fold, table->n_cells));
 }
 
@@ -58,6 +61,7 @@ hash_get_mutex_no(
 	hash_table_t* 	table,	/* in: hash table */
 	ulint 		fold)	/* in: fold */
 {
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 	return(ut_2pow_remainder(fold, table->n_mutexes));
 }
 
@@ -71,6 +75,7 @@ hash_get_nth_heap(
 	hash_table_t* 	table,	/* in: hash table */
 	ulint 		i)	/* in: index of the heap */
 {
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 	ut_ad(i < table->n_mutexes);
 
 	return(table->heaps[i]);
@@ -88,6 +93,8 @@ hash_get_heap(
 {
 	ulint	i;
 
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
+
 	if (table->heap) {
 		return(table->heap);
 	}
@@ -107,6 +114,7 @@ hash_get_nth_mutex(
 	hash_table_t* 	table,	/* in: hash table */
 	ulint 		i)	/* in: index of the mutex */
 {
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 	ut_ad(i < table->n_mutexes);
 	
 	return(table->mutexes + i);
diff --git a/innobase/include/ib_odbc.h b/innobase/include/ib_odbc.h
deleted file mode 100644
index 86884b41d39..00000000000
--- a/innobase/include/ib_odbc.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/******************************************************
-Innobase ODBC client library header; this is equivalent to
-the standard sql.h ODBC header file
-
-(c) 1998 Innobase Oy
-
-Created 2/22/1998 Heikki Tuuri
-*******************************************************/
-
-#ifndef ib_odbc_h
-#define ib_odbc_h
-
-typedef unsigned char       UCHAR;
-typedef signed char         SCHAR;
-typedef long int            SDWORD;
-typedef short int           SWORD;
-typedef unsigned long int   UDWORD;
-typedef unsigned short int  UWORD;
-
-typedef void*               PTR;
-
-typedef void*               HENV;
-typedef void*               HDBC;
-typedef void*               HSTMT;
-
-typedef signed short        RETCODE;
-
-/* RETCODEs */
-#define SQL_NO_DATA_FOUND	(-3)
-#define SQL_INVALID_HANDLE	(-2)
-#define SQL_ERROR		(-1)
-#define SQL_SUCCESS 		0
-
-/* Standard SQL datatypes, using ANSI type numbering */
-#define SQL_CHAR		1
-#define SQL_INTEGER 		4
-#define SQL_VARCHAR 		12
-
-/* C datatype to SQL datatype mapping */
-#define SQL_C_CHAR	  SQL_CHAR
-#define SQL_C_LONG	  SQL_INTEGER
-
-/* Special length value */
-#define SQL_NULL_DATA		(-1)
-
-#define SQL_PARAM_INPUT         1
-#define SQL_PARAM_OUTPUT	4
-
-/* Null handles */
-#define SQL_NULL_HENV		NULL
-#define SQL_NULL_HDBC		NULL
-#define SQL_NULL_HSTM		NULL
-
-
-/**************************************************************************
-Allocates an SQL environment. */
-
-RETCODE
-SQLAllocEnv(
-/*========*/
-			/* out: SQL_SUCCESS */
-	HENV*	phenv);	/* out: pointer to an environment handle */
-/**************************************************************************
-Allocates an SQL connection. */
-
-RETCODE
-SQLAllocConnect(
-/*============*/
-			/* out: SQL_SUCCESS */
-	HENV	henv,	/* in: pointer to an environment handle */
-	HDBC*	phdbc);	/* out: pointer to a connection handle */
-/**************************************************************************
-Allocates an SQL statement. */
-
-RETCODE
-SQLAllocStmt(
-/*=========*/
-	HDBC	hdbc,	/* in: SQL connection */
-	HSTMT*	phstmt);	/* out: pointer to a statement handle */
-/**************************************************************************
-Connects to a database server process (establishes a connection and a
-session). */
-
-RETCODE
-SQLConnect(
-/*=======*/
-				/* out: SQL_SUCCESS */
-	HDBC	hdbc,		/* in: SQL connection handle */
-	UCHAR*	szDSN,		/* in: data source name (server name) */
-	SWORD	cbDSN,		/* in: data source name length */
-	UCHAR*	szUID,		/* in: user name */
-	SWORD	cbUID,		/* in: user name length */
-	UCHAR*	szAuthStr,	/* in: password */
-	SWORD	cbAuthStr);	/* in: password length */
-/**************************************************************************
-Makes the server to parse and optimize an SQL string. */
-
-RETCODE
-SQLPrepare(
-/*=======*/
-				/* out: SQL_SUCCESS */
-	HSTMT	hstmt,		/* in: statement handle */
-	UCHAR*	szSqlStr,	/* in: SQL string */
-	SDWORD	cbSqlStr);	/* in: SQL string length */
-/**************************************************************************
-Binds a parameter in a prepared statement. */
-
-RETCODE
-SQLBindParameter(
-/*=============*/
-				/* out: SQL_SUCCESS */
-	HSTMT	hstmt,		/* in: statement handle */
-	UWORD	ipar,		/* in: parameter index, starting from 1 */
-	SWORD	fParamType,	/* in: SQL_PARAM_INPUT or SQL_PARAM_OUTPUT */
-	SWORD	fCType,		/* in: SQL_C_CHAR, ... */
-	SWORD	fSqlType,	/* in: SQL_CHAR, ... */
-	UDWORD	cbColDef,	/* in: precision: ignored */
-	SWORD	ibScale,	/* in: scale: ignored */
-	PTR	rgbValue,	/* in: pointer to a buffer for the data */
-	SDWORD	cbValueMax,	/* in: buffer size */
-	SDWORD*	pcbValue);	/* in: pointer to a buffer for the data
-				length or SQL_NULL_DATA */
-/**************************************************************************
-Executes a prepared statement where all parameters have been bound. */
-
-RETCODE
-SQLExecute(
-/*=======*/
-			/* out: SQL_SUCCESS or SQL_ERROR */
-	HSTMT	hstmt);	/* in: statement handle */
-/**************************************************************************
-Queries an error message. */
-
-RETCODE
-SQLError(
-/*=====*/
-				/* out: SQL_SUCCESS or SQL_NO_DATA_FOUND */
-	HENV	henv,		/* in: SQL_NULL_HENV */
-	HDBC	hdbc,		/* in: SQL_NULL_HDBC */
-	HSTMT	hstmt,		/* in: statement handle */
-	UCHAR*	szSqlState,	/* in/out: SQLSTATE as a null-terminated string,
-				(currently, always == "S1000") */
-	SDWORD*	pfNativeError,	/* out: native error code */
-	UCHAR*	szErrorMsg,	/* in/out: buffer for an error message as a
-				null-terminated string */
-	SWORD	cbErrorMsgMax,	/* in: buffer size for szErrorMsg */
-	SWORD*	pcbErrorMsg);	/* out: error message length */
-
-#endif 
diff --git a/innobase/include/lock0lock.ic b/innobase/include/lock0lock.ic
index 64c43c88d2e..fabc9256401 100644
--- a/innobase/include/lock0lock.ic
+++ b/innobase/include/lock0lock.ic
@@ -64,7 +64,9 @@ lock_clust_rec_some_has_impl(
 {
 	dulint	trx_id;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(index->type & DICT_CLUSTERED);
 	ut_ad(page_rec_is_user_rec(rec));
 
diff --git a/innobase/include/log0log.ic b/innobase/include/log0log.ic
index 7ae7e859032..16423286f6d 100644
--- a/innobase/include/log0log.ic
+++ b/innobase/include/log0log.ic
@@ -255,7 +255,9 @@ log_block_init(
 {
 	ulint	no;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	no = log_block_convert_lsn_to_no(lsn);
 	
@@ -277,7 +279,9 @@ log_block_init_in_old_format(
 {
 	ulint	no;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	no = log_block_convert_lsn_to_no(lsn);
 	
@@ -407,7 +411,9 @@ log_get_online_backup_lsn_low(void)
 				/* out: online_backup_lsn, the caller must
 				own the log_sys mutex */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(log_sys->online_backup_state);
 
 	return(log_sys->online_backup_lsn);
@@ -422,7 +428,9 @@ log_get_online_backup_state_low(void)
 				/* out: online backup state, the caller must
 				own the log_sys mutex */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(log_sys->online_backup_state);
 }
diff --git a/innobase/include/mach0data.h b/innobase/include/mach0data.h
index 006f55d5f1f..f28c9422670 100644
--- a/innobase/include/mach0data.h
+++ b/innobase/include/mach0data.h
@@ -88,25 +88,6 @@ mach_read_from_4(
 /*=============*/
 			/* out: ulint integer */
 	byte*   b);      /* in: pointer to four bytes */
-/***********************************************************
-The following function is used to store data from a ulint to memory
-in standard order:
-we store the most significant byte to the lowest address. */
-UNIV_INLINE
-void 
-mach_write(
-/*=======*/
-	byte*   b,     /* in: pointer to sizeof(ulint) bytes where to store */
-	ulint   n);      /* in: ulint integer to be stored */ 
-/************************************************************
-The following function is used to fetch data from memory to a ulint.
-The most significant byte is at the lowest address. */
-UNIV_INLINE
-ulint 
-mach_read(
-/*======*/
-			/* out: ulint integer */
-	byte*   b);      /* in: pointer to sizeof(ulint) bytes */
 /*************************************************************
 Writes a ulint in a compressed form. */
 UNIV_INLINE
diff --git a/innobase/include/mach0data.ic b/innobase/include/mach0data.ic
index 0934c27d9f4..3ccdcf1dc0a 100644
--- a/innobase/include/mach0data.ic
+++ b/innobase/include/mach0data.ic
@@ -167,44 +167,6 @@ mach_read_from_4(
 #endif
 }
 
-/***********************************************************
-The following function is used to store data from a ulint to memory
-in standard order: we store the most significant byte to the lowest
-address. */
-UNIV_INLINE
-void 
-mach_write(
-/*=======*/
-	byte*   b,      /* in: pointer to 4 bytes where to store */
-	ulint   n)      /* in: ulint integer to be stored */ 
-{
-	ut_ad(b);
-
-	b[0] = (byte)(n >> 24);
-	b[1] = (byte)(n >> 16);
-	b[2] = (byte)(n >> 8);
-	b[3] = (byte)n;
-}
-
-/************************************************************
-The following function is used to fetch data from memory to a ulint.
-The most significant byte is at the lowest address. */
-UNIV_INLINE
-ulint 
-mach_read(
-/*======*/
-			/* out: ulint integer */
-	byte*   b)      /* in: pointer to 4 bytes */
-{
-	ut_ad(b);
-
-	return( ((ulint)(b[0]) << 24)
-		+ ((ulint)(b[1]) << 16)
-		+ ((ulint)(b[2]) << 8)
-		+ (ulint)(b[3])
-	      );
-}
-
 /*************************************************************
 Writes a ulint in a compressed form where the first byte codes the
 length of the stored ulint. We look at the most significant bits of
diff --git a/innobase/include/mem0dbg.ic b/innobase/include/mem0dbg.ic
index 765e23e747e..6efac719760 100644
--- a/innobase/include/mem0dbg.ic
+++ b/innobase/include/mem0dbg.ic
@@ -7,6 +7,7 @@ compilation module but is included in mem0mem.*.
 Created 6/8/1994 Heikki Tuuri
 *************************************************************************/
 
+#ifdef UNIV_MEM_DEBUG
 extern mutex_t	mem_hash_mutex;
 extern ulint	mem_current_allocated_memory;
 
@@ -89,3 +90,4 @@ mem_field_trailer_set_check(byte* field, ulint check);
 
 ulint
 mem_field_trailer_get_check(byte* field);
+#endif /* UNIV_MEM_DEBUG */
diff --git a/innobase/include/mtr0log.h b/innobase/include/mtr0log.h
index cc42924fe4d..f50c1dfcb6a 100644
--- a/innobase/include/mtr0log.h
+++ b/innobase/include/mtr0log.h
@@ -32,7 +32,6 @@ mlog_write_dulint(
 /*==============*/
 	byte*	ptr,	/* in: pointer where to write */
 	dulint	val,	/* in: value to write */
-	byte	type,	/* in: MLOG_8BYTES */
 	mtr_t*	mtr);	/* in: mini-transaction handle */
 /************************************************************
 Writes a string to a file page buffered in the buffer pool. Writes the
diff --git a/innobase/include/mtr0mtr.h b/innobase/include/mtr0mtr.h
index 8408abf43e4..9cf592f71e1 100644
--- a/innobase/include/mtr0mtr.h
+++ b/innobase/include/mtr0mtr.h
@@ -195,7 +195,6 @@ mtr_read_dulint(
 /*===========*/
 			/* out: value read */
 	byte*	ptr,	/* in: pointer from where to read */
-	ulint	type,	/* in: MLOG_8BYTES */
 	mtr_t*	mtr);	/* in: mini-transaction handle */
 /*************************************************************************
 This macro locks an rw-lock in s-mode. */
@@ -296,7 +295,12 @@ struct mtr_memo_slot_struct{
 
 /* Mini-transaction handle and buffer */
 struct mtr_struct{
+#ifdef UNIV_DEBUG
 	ulint		state;	/* MTR_ACTIVE, MTR_COMMITTING, MTR_COMMITTED */
+#define MTR_ACTIVE		12231
+#define MTR_COMMITTING		56456
+#define MTR_COMMITTED		34676
+#endif /* UNIV_DEBUG */
 	dyn_array_t	memo;	/* memo stack for locks etc. */
 	dyn_array_t	log;	/* mini-transaction log */
 	ibool		modifications;
@@ -311,15 +315,12 @@ struct mtr_struct{
 				this mtr */
 	dulint		end_lsn;/* end lsn of the possible log entry for
 				this mtr */
+#ifdef UNIV_DEBUG
 	ulint		magic_n;
-};
-
 #define	MTR_MAGIC_N		54551
+#endif /* UNIV_DEBUG */
+};
 
-#define MTR_ACTIVE		12231
-#define MTR_COMMITTING		56456
-#define MTR_COMMITTED		34676
-	
 #ifndef UNIV_NONINL
 #include "mtr0mtr.ic"
 #endif
diff --git a/innobase/include/odbc0odbc.h b/innobase/include/odbc0odbc.h
deleted file mode 100644
index 7f842b54b27..00000000000
--- a/innobase/include/odbc0odbc.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/******************************************************
-Innobase ODBC client library additional header
-
-(c) 1998 Innobase Oy
-
-Created 2/22/1998 Heikki Tuuri
-*******************************************************/
-
-#ifndef odbc0odbc_h
-#define odbc0odbc_h
-
-#include "ib_odbc.h"
-
-/* Datagram size in communications */
-#define ODBC_DATAGRAM_SIZE	8192
-
-/* Communication address maximum length in bytes */
-#define ODBC_ADDRESS_SIZE	COM_MAX_ADDR_LEN
-
-#endif 
diff --git a/innobase/include/os0file.h b/innobase/include/os0file.h
index 5f2d6e3ed21..cf2dbd68fb1 100644
--- a/innobase/include/os0file.h
+++ b/innobase/include/os0file.h
@@ -20,6 +20,9 @@ extern ibool	os_do_not_call_flush_at_each_write;
 extern ibool	os_has_said_disk_full;
 extern ibool	os_aio_print_debug;
 
+extern ulint	os_file_n_pending_preads;
+extern ulint	os_file_n_pending_pwrites;
+
 #ifdef __WIN__
 
 /* We define always WIN_ASYNC_IO, and check at run-time whether
diff --git a/innobase/include/pars0pars.h b/innobase/include/pars0pars.h
index e08b071e246..8ff226ebbd0 100644
--- a/innobase/include/pars0pars.h
+++ b/innobase/include/pars0pars.h
@@ -21,7 +21,9 @@ extern int	yydebug;
 /* If the following is set TRUE, the lexer will print the SQL string
 as it tokenizes it */
 
+#ifdef UNIV_SQL_DEBUG
 extern ibool	pars_print_lexed;
+#endif /* UNIV_SQL_DEBUG */
 
 /* Global variable used while parsing a single procedure or query : the code is
 NOT re-entrant */
@@ -390,41 +392,18 @@ pars_procedure_definition(
 					table */
 	sym_node_t*	param_list,	/* in: parameter declaration list */
 	que_node_t*	stat_list);	/* in: statement list */
-/*****************************************************************
-Reads stored procedure input parameter values from a buffer. */
-
-void
-pars_proc_read_input_params_from_buf(
-/*=================================*/
-	que_t*	graph,	/* in: query graph which contains a stored procedure */
-	byte*	buf);	/* in: buffer */
-/*****************************************************************
-Writes stored procedure output parameter values to a buffer. */
 
-ulint
-pars_proc_write_output_params_to_buf(
-/*=================================*/
-	byte*	buf,	/* in: buffer which must be big enough */
-	que_t*	graph);	/* in: query graph which contains a stored procedure */
 /*****************************************************************
 Parses a stored procedure call, when this is not within another stored
-procedure, that is, the client issues a procedure call directly. */
+procedure, that is, the client issues a procedure call directly.
+In MySQL/InnoDB, stored InnoDB procedures are invoked via the
+parsed procedure tree, not via InnoDB SQL, so this function is not used. */
 
 que_fork_t*
 pars_stored_procedure_call(
 /*=======================*/
 					/* out: query graph */
 	sym_node_t*	sym_node);	/* in: stored procedure name */
-/*****************************************************************
-Writes info about query parameter markers (denoted with '?' in ODBC) into a
-buffer. */
-
-ulint
-pars_write_query_param_info(
-/*========================*/
-				/* out: number of bytes used for info in buf */
-	byte*		buf,	/* in: buffer which must be big enough */
-	que_fork_t*	graph);	/* in: parsed query graph */
 /**********************************************************************
 Completes a query graph by adding query thread and fork nodes
 above it and prepares the graph for running. The fork created is of
diff --git a/innobase/include/que0que.h b/innobase/include/que0que.h
index a3ed18e2b14..e1874edcaf2 100644
--- a/innobase/include/que0que.h
+++ b/innobase/include/que0que.h
@@ -216,9 +216,7 @@ que_fork_start_command(
 				QUE_THR_RUNNING state, or NULL; the query
 				thread should be executed by que_run_threads
 				by the caller */
-	que_fork_t* 	fork,	/* in: a query fork */
-	ulint		command,/* in: command SESS_COMM_FETCH_NEXT, ... */
-	ulint		param);	/* in: possible parameter to the command */
+	que_fork_t* 	fork);	/* in: a query fork */
 /***************************************************************************
 Gets the trx of a query thread. */
 UNIV_INLINE
@@ -388,11 +386,6 @@ struct que_fork_struct{
 	sym_tab_t*	sym_tab;	/* symbol table of the query,
 					generated by the parser, or NULL
 					if the graph was created 'by hand' */
-	ulint		id;		/* id of this query graph */
-	ulint		command;	/* command currently executed in the
-					graph */
-	ulint		param;		/* possible command parameter */
-
 	/* The following cur_... fields are relevant only in a select graph */
 
 	ulint		cur_end;	/* QUE_CUR_NOT_DEFINED, QUE_CUR_START,
diff --git a/innobase/include/row0ins.h b/innobase/include/row0ins.h
index a5b4b74e7fc..f3f0b7e8eca 100644
--- a/innobase/include/row0ins.h
+++ b/innobase/include/row0ins.h
@@ -145,10 +145,11 @@ struct ins_node_struct{
 				entry_list and sys fields are stored here;
 				if this is NULL, entry list should be created
 				and buffers for sys fields in row allocated */
+#ifdef UNIV_DEBUG
 	ulint		magic_n;
-};
-
 #define	INS_NODE_MAGIC_N	15849075
+#endif /* UNIV_DEBUG */
+};
 
 /* Insert node types */
 #define INS_SEARCHED	0	/* INSERT INTO ... SELECT ... */
diff --git a/innobase/include/row0upd.h b/innobase/include/row0upd.h
index f5e0a88231f..687e90deee5 100644
--- a/innobase/include/row0upd.h
+++ b/innobase/include/row0upd.h
@@ -384,10 +384,11 @@ struct upd_node_struct{
 	sym_node_t*	table_sym;/* table node in symbol table */
 	que_node_t*	col_assign_list;
 				/* column assignment list */
+#ifdef UNIV_DEBUG
 	ulint		magic_n;
-};
-
 #define	UPD_NODE_MAGIC_N	1579975
+#endif /* UNIV_DEBUG */
+};
 
 /* Node execution states */
 #define UPD_NODE_SET_IX_LOCK	   1	/* execution came to the node from
diff --git a/innobase/include/row0upd.ic b/innobase/include/row0upd.ic
index 1878431d1a4..6b9deeac5e3 100644
--- a/innobase/include/row0upd.ic
+++ b/innobase/include/row0upd.ic
@@ -107,8 +107,10 @@ row_upd_rec_sys_fields(
 	dulint		roll_ptr)/* in: roll ptr of the undo log record */
 {
 	ut_ad(index->type & DICT_CLUSTERED);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!buf_block_align(rec)->is_hashed
 			|| rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 
 	row_set_rec_trx_id(rec, index, trx->id);
 	row_set_rec_roll_ptr(rec, index, roll_ptr);
diff --git a/innobase/include/srv0srv.h b/innobase/include/srv0srv.h
index 23c30554f08..8aac71de2a9 100644
--- a/innobase/include/srv0srv.h
+++ b/innobase/include/srv0srv.h
@@ -13,7 +13,6 @@ Created 10/10/1995 Heikki Tuuri
 #include "univ.i"
 #include "sync0sync.h"
 #include "os0sync.h"
-#include "com0com.h"
 #include "que0types.h"
 #include "trx0types.h"
 
@@ -405,9 +404,6 @@ struct srv_sys_struct{
 	os_event_t	operational;	/* created threads must wait for the
 					server to become operational by
 					waiting for this event */
-	com_endpoint_t*	endpoint;	/* the communication endpoint of the
-					server */
-
 	srv_table_t*	threads;	/* server thread table */
 	UT_LIST_BASE_NODE_T(que_thr_t)
 			tasks;		/* task queue */
diff --git a/innobase/include/sync0rw.h b/innobase/include/sync0rw.h
index 5aa3dcdffc3..d71691b4353 100644
--- a/innobase/include/sync0rw.h
+++ b/innobase/include/sync0rw.h
@@ -25,13 +25,16 @@ smaller than 30 and the order of the numerical values like below! */
 #define	RW_NO_LATCH	3
 
 typedef struct rw_lock_struct		rw_lock_t;
+#ifdef UNIV_SYNC_DEBUG
 typedef struct rw_lock_debug_struct	rw_lock_debug_t;
+#endif /* UNIV_SYNC_DEBUG */
 
 typedef UT_LIST_BASE_NODE_T(rw_lock_t)	rw_lock_list_t;
 
 extern rw_lock_list_t 	rw_lock_list;
 extern mutex_t		rw_lock_list_mutex;
 
+#ifdef UNIV_SYNC_DEBUG
 /* The global mutex which protects debug info lists of all rw-locks.
 To modify the debug info list of an rw-lock, this mutex has to be
 
@@ -42,6 +45,7 @@ extern os_event_t	rw_lock_debug_event;	/* If deadlock detection does
 					may wait for this event */
 extern ibool		rw_lock_debug_waiters;	/* This is set to TRUE, if
 					there may be waiters for the event */
+#endif /* UNIV_SYNC_DEBUG */
 
 extern	ulint	rw_s_system_call_count;
 extern	ulint	rw_s_spin_wait_count;
@@ -327,6 +331,7 @@ ulint
 rw_lock_get_reader_count(
 /*=====================*/
 	rw_lock_t*	lock);
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Checks if the thread has locked the rw-lock in the specified mode, with
 the pass value == 0. */
@@ -337,6 +342,7 @@ rw_lock_own(
 	rw_lock_t*	lock,		/* in: rw-lock */
 	ulint		lock_type);	/* in: lock type: RW_LOCK_SHARED,
 					RW_LOCK_EX */
+#endif /* UNIV_SYNC_DEBUG */
 /**********************************************************************
 Checks if somebody has locked the rw-lock in the specified mode. */
 
@@ -346,6 +352,7 @@ rw_lock_is_locked(
 	rw_lock_t*	lock,		/* in: rw-lock */
 	ulint		lock_type);	/* in: lock type: RW_LOCK_SHARED,
 					RW_LOCK_EX */
+#ifdef UNIV_SYNC_DEBUG
 /*******************************************************************
 Prints debug info of an rw-lock. */
 
@@ -392,6 +399,7 @@ void
 rw_lock_debug_print(
 /*================*/
 	rw_lock_debug_t*	info);	/* in: debug struct */
+#endif /* UNIV_SYNC_DEBUG */
 
 /* NOTE! The structure appears here only for the compiler to know its size.
 Do not use its fields directly! The structure used in the spin lock
@@ -434,10 +442,12 @@ struct rw_lock_struct {
 	UT_LIST_NODE_T(rw_lock_t) list;
 				/* All allocated rw locks are put into a
 				list */
+#ifdef UNIV_SYNC_DEBUG
 	UT_LIST_BASE_NODE_T(rw_lock_debug_t) debug_list;
 				/* In the debug version: pointer to the debug
 				info list of the lock */
-	ulint	level;		/* Debug version: level in the global latching
+#endif /* UNIV_SYNC_DEBUG */
+	ulint	level;		/* Level in the global latching
 				order; default SYNC_LEVEL_NONE */
 	char*	cfile_name;	/* File name where lock created */
 	ulint	cline;		/* Line where created */
@@ -450,6 +460,7 @@ struct rw_lock_struct {
 
 #define	RW_LOCK_MAGIC_N	22643
 
+#ifdef UNIV_SYNC_DEBUG
 /* The structure for storing debug info of an rw-lock */
 struct	rw_lock_debug_struct {
 
@@ -464,6 +475,7 @@ struct	rw_lock_debug_struct {
 				/* Debug structs are linked in a two-way
 				list */
 };
+#endif /* UNIV_SYNC_DEBUG */
 
 #ifndef UNIV_NONINL
 #include "sync0rw.ic"
diff --git a/innobase/include/sync0rw.ic b/innobase/include/sync0rw.ic
index caf6f5f1de4..8fc93f4a9da 100644
--- a/innobase/include/sync0rw.ic
+++ b/innobase/include/sync0rw.ic
@@ -20,6 +20,7 @@ rw_lock_s_lock_spin(
 				be passed to another thread to unlock */
 	char*		file_name,/* in: file name where lock requested */
 	ulint		line);	/* in: line where requested */
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Inserts the debug information for an rw-lock. */
 
@@ -40,7 +41,7 @@ rw_lock_remove_debug_info(
 	rw_lock_t*	lock,		/* in: rw-lock */
 	ulint		pass,		/* in: pass value */
 	ulint		lock_type);	/* in: lock type */
-
+#endif /* UNIV_SYNC_DEBUG */
 
 /************************************************************************
 Accessor functions for rw lock. */
@@ -132,8 +133,9 @@ rw_lock_s_lock_low(
 	char*		file_name, /* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(rw_lock_get_mutex(lock)));
-
+#endif /* UNIV_SYNC_DEBUG */
 	/* Check if the writer field is free */
 
 	if (lock->writer == RW_LOCK_NOT_LOCKED) {
@@ -144,7 +146,6 @@ rw_lock_s_lock_low(
 		rw_lock_add_debug_info(lock, pass, RW_LOCK_SHARED, file_name,
 									line);
 #endif
-		
 		lock->last_s_file_name = file_name;
 		lock->last_s_line = line;
 
@@ -236,7 +237,9 @@ rw_lock_s_lock_func(
 	the threads which have s-locked a latch. This would use some CPU
 	time. */
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!rw_lock_own(lock, RW_LOCK_SHARED)); /* see NOTE above */
+#endif /* UNIV_SYNC_DEBUG */
 
 	mutex_enter(rw_lock_get_mutex(lock));
 
diff --git a/innobase/include/sync0sync.h b/innobase/include/sync0sync.h
index f83f8cbe712..3a7203bbb56 100644
--- a/innobase/include/sync0sync.h
+++ b/innobase/include/sync0sync.h
@@ -185,6 +185,7 @@ sync_thread_levels_empty_gen(
 					allowed to be owned by the thread,
 					also purge_is_running mutex is
 					allowed */
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Checks that the current thread owns the mutex. Works only
 in the debug version. */
@@ -217,6 +218,7 @@ Prints debug info of currently reserved mutexes. */
 void
 mutex_list_print_info(void);
 /*========================*/
+#endif /* UNIV_SYNC_DEBUG */
 /**********************************************************************
 NOT to be used outside this module except in debugging! Gets the value
 of the lock word. */
@@ -225,6 +227,7 @@ ulint
 mutex_get_lock_word(
 /*================*/
 	mutex_t*	mutex);	/* in: mutex */
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 NOT to be used outside this module except in debugging! Gets the waiters
 field in a mutex. */
@@ -234,6 +237,7 @@ mutex_get_waiters(
 /*==============*/
 				/* out: value to set */		
 	mutex_t*	mutex);	/* in: mutex */
+#endif /* UNIV_SYNC_DEBUG */
 
 /*
 		LATCHING ORDER WITHIN THE DATABASE
@@ -442,13 +446,13 @@ struct mutex_struct {
 				Otherwise, this is 0. */
 	UT_LIST_NODE_T(mutex_t)	list; /* All allocated mutexes are put into
 				a list.	Pointers to the next and prev. */
+#ifdef UNIV_SYNC_DEBUG
+	const char*	file_name;	/* File where the mutex was locked */
+	ulint	line;		/* Line where the mutex was locked */
 	os_thread_id_t thread_id; /* Debug version: The thread id of the
 				thread which locked the mutex. */
-	char*	file_name;	/* Debug version: File name where the mutex
-				was locked */
-	ulint	line;		/* Debug version: Line where the mutex was
-				locked */
-	ulint	level;		/* Debug version: level in the global latching
+#endif /* UNIV_SYNC_DEBUG */
+	ulint	level;		/* Level in the global latching
 				order; default SYNC_LEVEL_NONE */
 	char*	cfile_name;	/* File name where mutex created */
 	ulint	cline;		/* Line where created */
diff --git a/innobase/include/sync0sync.ic b/innobase/include/sync0sync.ic
index 816b44a5bd3..758c8524f66 100644
--- a/innobase/include/sync0sync.ic
+++ b/innobase/include/sync0sync.ic
@@ -25,6 +25,7 @@ mutex_spin_wait(
         mutex_t*	mutex,  	/* in: pointer to mutex */
 	char*		file_name,/* in: file name where mutex requested */
 	ulint		line);	/* in: line where requested */
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Sets the debug information for a reserved mutex. */
 
@@ -34,6 +35,7 @@ mutex_set_debug_info(
 	mutex_t*	mutex,		/* in: mutex */
 	char*		file_name,	/* in: file where requested */
 	ulint		line);		/* in: line where requested */
+#endif /* UNIV_SYNC_DEBUG */
 /**********************************************************************
 Releases the threads waiting in the primary wait array for this mutex. */
 
@@ -200,9 +202,9 @@ mutex_exit(
 /*=======*/
 	mutex_t*	mutex)	/* in: pointer to mutex */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(mutex));
 
-#ifdef UNIV_SYNC_DEBUG
 	mutex->thread_id = ULINT_UNDEFINED;
 
 	sync_thread_reset_level(mutex);
@@ -249,14 +251,9 @@ mutex_enter_func(
 	the atomic test_and_set; we could peek, and possibly save time. */
 	
 	if (!mutex_test_and_set(mutex)) {
-
 #ifdef UNIV_SYNC_DEBUG
 		mutex_set_debug_info(mutex, file_name, line);
 #endif
-
-		mutex->file_name = file_name;
-		mutex->line = line;
-
 		return;	/* Succeeded! */
 	}
 
diff --git a/innobase/include/trx0rseg.ic b/innobase/include/trx0rseg.ic
index 6b242b66c09..35e927f5e79 100644
--- a/innobase/include/trx0rseg.ic
+++ b/innobase/include/trx0rseg.ic
@@ -24,7 +24,9 @@ trx_rsegf_get(
 
 	header = TRX_RSEG + buf_page_get(space, page_no, RW_X_LATCH, mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(header, SYNC_RSEG_HEADER);
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(header);
 }
@@ -45,7 +47,9 @@ trx_rsegf_get_new(
 
 	header = TRX_RSEG + buf_page_get(space, page_no, RW_X_LATCH, mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(header, SYNC_RSEG_HEADER_NEW);
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(header);
 }
@@ -64,7 +68,7 @@ trx_rsegf_get_nth_undo(
 	if (n >= TRX_RSEG_N_SLOTS) {
 		fprintf(stderr,
 		"InnoDB: Error: trying to get slot %lu of rseg\n", (unsigned long) n);
-		ut_a(0);
+		ut_error;
 	}
 
 	return(mtr_read_ulint(rsegf + TRX_RSEG_UNDO_SLOTS +
@@ -85,7 +89,7 @@ trx_rsegf_set_nth_undo(
 	if (n >= TRX_RSEG_N_SLOTS) {
 		fprintf(stderr,
 		"InnoDB: Error: trying to set slot %lu of rseg\n", (unsigned long) n);
-		ut_a(0);
+		ut_error;
 	}
 
 	mlog_write_ulint(rsegf + TRX_RSEG_UNDO_SLOTS + n * TRX_RSEG_SLOT_SIZE,
diff --git a/innobase/include/trx0sys.ic b/innobase/include/trx0sys.ic
index 343e6d7c2fa..8f455e554ea 100644
--- a/innobase/include/trx0sys.ic
+++ b/innobase/include/trx0sys.ic
@@ -60,7 +60,9 @@ trx_sys_get_nth_rseg(
 	trx_sys_t*	sys,	/* in: trx system */
 	ulint		n)	/* in: index of slot */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(kernel_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(n < TRX_SYS_N_RSEGS);
 
 	return(sys->rseg_array[n]);
@@ -98,7 +100,9 @@ trx_sysf_get(
 	header = TRX_SYS + buf_page_get(TRX_SYS_SPACE, TRX_SYS_PAGE_NO,
 							RW_X_LATCH, mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(header, SYNC_TRX_SYS_HEADER);
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(header);
 }
@@ -115,7 +119,9 @@ trx_sysf_rseg_get_space(
 	ulint		i,		/* in: slot index == rseg id */
 	mtr_t*		mtr)		/* in: mtr */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(kernel_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(sys_header);
 	ut_ad(i < TRX_SYS_N_RSEGS);
 
@@ -138,7 +144,9 @@ trx_sysf_rseg_get_page_no(
 	mtr_t*		mtr)		/* in: mtr */
 {
 	ut_ad(sys_header);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(kernel_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(i < TRX_SYS_N_RSEGS);
 
 	return(mtr_read_ulint(sys_header + TRX_SYS_RSEGS
@@ -158,7 +166,9 @@ trx_sysf_rseg_set_space(
 	ulint		space,		/* in: space id */
 	mtr_t*		mtr)		/* in: mtr */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(kernel_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(sys_header);
 	ut_ad(i < TRX_SYS_N_RSEGS);
 
@@ -182,7 +192,9 @@ trx_sysf_rseg_set_page_no(
 					slot is reset to unused */
 	mtr_t*		mtr)		/* in: mtr */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(kernel_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(sys_header);
 	ut_ad(i < TRX_SYS_N_RSEGS);
 
@@ -236,7 +248,9 @@ trx_get_on_id(
 {
 	trx_t*	trx;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(kernel_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
 
@@ -266,7 +280,9 @@ trx_list_get_min_trx_id(void)
 {
 	trx_t*	trx;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(kernel_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	trx = UT_LIST_GET_LAST(trx_sys->trx_list);
 
@@ -289,7 +305,9 @@ trx_is_active(
 {
 	trx_t*	trx;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(kernel_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (ut_dulint_cmp(trx_id, trx_list_get_min_trx_id()) < 0) {
 
@@ -325,7 +343,9 @@ trx_sys_get_new_trx_id(void)
 {
 	dulint	id;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* VERY important: after the database is started, max_trx_id value is
 	divisible by TRX_SYS_TRX_ID_WRITE_MARGIN, and the following if
@@ -355,7 +375,9 @@ trx_sys_get_new_trx_no(void)
 /*========================*/
 			/* out: new, allocated trx number */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(trx_sys_get_new_trx_id());
 }
diff --git a/innobase/include/trx0trx.h b/innobase/include/trx0trx.h
index 6b08b674db8..d9b91ee62dc 100644
--- a/innobase/include/trx0trx.h
+++ b/innobase/include/trx0trx.h
@@ -203,13 +203,9 @@ trx_sig_send(
 	ulint		type,		/* in: signal type */
 	ulint		sender,		/* in: TRX_SIG_SELF or
 					TRX_SIG_OTHER_SESS */
-	ibool		reply,		/* in: TRUE if the sender of the signal
-					wants reply after the operation induced
-					by the signal is completed; if type
-					is TRX_SIG_END_WAIT, this must be
-					FALSE */
 	que_thr_t*	receiver_thr,	/* in: query thread which wants the
-					reply, or NULL */
+					reply, or NULL; if type is
+					TRX_SIG_END_WAIT, this must be NULL */
 	trx_savept_t* 	savept,		/* in: possible rollback savepoint, or
 					NULL */
 	que_thr_t**	next_thr);	/* in/out: next query thread to run;
@@ -225,7 +221,6 @@ been handled. */
 void
 trx_sig_reply(
 /*==========*/
-	trx_t*		trx,		/* in: trx handle */
 	trx_sig_t*	sig,		/* in: signal */
 	que_thr_t**	next_thr);	/* in/out: next query thread to run;
 					if the value which is passed in is
@@ -297,15 +292,9 @@ struct trx_sig_struct{
 					TRX_SIG_BEING_HANDLED */
 	ulint		sender;		/* TRX_SIG_SELF or
 					TRX_SIG_OTHER_SESS */
-	ibool		reply;		/* TRUE if the sender of the signal
+	que_thr_t*	receiver;	/* non-NULL if the sender of the signal
 					wants reply after the operation induced
-					by the signal is completed; if this
-					field is TRUE and the receiver field
-					below is NULL, then a SUCCESS message
-					is sent to the client of the session
-					to which this trx belongs */
-	que_thr_t*	receiver;	/* query thread which wants the reply,
-					or NULL */
+					by the signal is completed */
 	trx_savept_t	savept;		/* possible rollback savepoint */
 	UT_LIST_NODE_T(trx_sig_t)
 			signals;	/* queue of pending signals to the
diff --git a/innobase/include/trx0undo.ic b/innobase/include/trx0undo.ic
index bedbc02b00b..a04b234b495 100644
--- a/innobase/include/trx0undo.ic
+++ b/innobase/include/trx0undo.ic
@@ -126,7 +126,9 @@ trx_undo_page_get(
 	
 	page = buf_page_get(space, page_no, RW_X_LATCH, mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_TRX_UNDO_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(page);
 }
@@ -146,7 +148,9 @@ trx_undo_page_get_s_latched(
 	
 	page = buf_page_get(space, page_no, RW_S_LATCH, mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_TRX_UNDO_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(page);
 }
diff --git a/innobase/include/usr0sess.h b/innobase/include/usr0sess.h
index e277d801672..c7bcfb20fed 100644
--- a/innobase/include/usr0sess.h
+++ b/innobase/include/usr0sess.h
@@ -11,7 +11,6 @@ Created 6/25/1996 Heikki Tuuri
 
 #include "univ.i"
 #include "ut0byte.h"
-#include "hash0hash.h"
 #include "trx0types.h"
 #include "srv0srv.h"
 #include "trx0types.h"
@@ -19,52 +18,14 @@ Created 6/25/1996 Heikki Tuuri
 #include "que0types.h"
 #include "data0data.h"
 #include "rem0rec.h"
-#include "com0com.h"
 
-/* The session system global data structure */
-extern sess_sys_t*	sess_sys;
-
-/*************************************************************************
-Sets the session id in a client message. */
-
-void
-sess_cli_msg_set_sess(
-/*==================*/
-	byte*	str,	/* in/out: message string */
-	dulint	sess_id);/* in: session id */
-/***************************************************************************
-Sets the message type of a message from the client. */
-UNIV_INLINE
-void
-sess_cli_msg_set_type(
-/*==================*/
-	byte*	str,	/* in: message string */
-	ulint	type);	/* in: message type */
-/***************************************************************************
-Gets the message type of a message from the server. */
-UNIV_INLINE
-ulint
-sess_srv_msg_get_type(
-/*==================*/
-			/* out: message type */
-	byte*	str);	/* in: message string */
-/***************************************************************************
-Creates a session sytem at database start. */
-
-void
-sess_sys_init_at_db_start(void);
-/*===========================*/
 /*************************************************************************
 Opens a session. */
 
 sess_t*
-sess_open(
-/*======*/
+sess_open(void);
+/*============*/
 					/* out, own: session object */
-	com_endpoint_t*	endpoint,	/* in: communication endpoint used
-					for communicating with the client */
-	byte*		addr_buf,	/* in: client address */
-	ulint		addr_len);	/* in: client address length */
 /*************************************************************************
 Closes a session, freeing the memory occupied by it, if it is in a state
 where it should be closed. */
@@ -74,200 +35,25 @@ sess_try_close(
 /*===========*/
 				/* out: TRUE if closed */
 	sess_t*		sess);	/* in, own: session object */
-/*************************************************************************
-Initializes the first fields of a message to client. */
-
-void
-sess_srv_msg_init(
-/*==============*/
-	sess_t*	sess,	/* in: session object */
-	byte*	buf,	/* in: message buffer, must be at least of size
-			SESS_SRV_MSG_DATA */
-	ulint	type);	/* in: message type */
-/*************************************************************************
-Sends a simple message to client. */
-
-void
-sess_srv_msg_send_simple(
-/*=====================*/
-	sess_t*	sess,		/* in: session object */
-	ulint	type,		/* in: message type */
-	ulint	rel_kernel);	/* in: SESS_RELEASE_KERNEL or
-				SESS_NOT_RELEASE_KERNEL */
-/***************************************************************************
-When a command has been completed, this function sends the message about it
-to the client. */
-
-void
-sess_command_completed_message(
-/*===========================*/
-	sess_t*	sess,	/* in: session */
-	byte*	msg,	/* in: message buffer */
-	ulint	len);	/* in: message data length */
-
 
 /* The session handle. All fields are protected by the kernel mutex */
 struct sess_struct{
-	dulint		id;		/* session id */
-	dulint		usr_id;		/* user id */
-	hash_node_t	hash;		/* hash chain node */
-	ulint		refer_count;	/* reference count to the session
-					object: when this drops to zero
-					and the session has no query graphs
-					left, discarding the session object
-					is allowed */
-	dulint		error_count;	/* if this counter has increased while
-					a thread is parsing an SQL command,
-					its graph should be discarded */
-	ibool		disconnecting;	/* TRUE if the session is to be
-					disconnected when its reference
-					count drops to 0 */
 	ulint		state;		/* state of the session */
-	dulint		msgs_sent;	/* count of messages sent to the
-					client */
-	dulint		msgs_recv;	/* count of messages received from the
-					client */
-	ibool		client_waits;	/* when the session receives a message
-					from the client, this set to TRUE, and
-					when the session sends a message to
-					the client this is set to FALSE */
 	trx_t*		trx;		/* transaction object permanently
 					assigned for the session: the
 					transaction instance designated by the
 					trx id changes, but the memory
 					structure is preserved */
-	ulint		next_graph_id;	/* next query graph id to assign */
 	UT_LIST_BASE_NODE_T(que_t)
 			graphs;		/* query graphs belonging to this
 					session */
-	/*------------------------------*/
-	ulint		err_no;		/* latest error number, 0 if none */
-	char*		err_str;	/* latest error string */
-	ulint		err_len;	/* error string length */
-	/*------------------------------*/
-	com_endpoint_t*	endpoint;	/* server communications endpoint used
-					to communicate with the client */
-	char*		addr_buf;	/* client address string */
-	ulint		addr_len;	/* client address string length */
-	/*------------------------------*/
-	byte*		big_msg;	/* if the client sends a message which
-					does not fit in a single packet,
-					it is assembled in this buffer; if
-					this field is not NULL, it is assumed
-					that the message should be catenated
-					here */
-	ulint		big_msg_size;	/* size of the big message buffer */
-	ulint		big_msg_len;	/* length of data in the big message
-					buffer */
-};
-
-/* The session system; this is protected by the kernel mutex */
-struct sess_sys_struct{
-	ulint		state;		/* state of the system:
-					SESS_SYS_RUNNING or
-					SESS_SYS_SHUTTING_DOWN */
-	sess_t*		shutdown_req;	/* if shutdown was requested by some
-					session, confirmation of shutdown
-					completion should be sent to this
-					session */	
-	dulint		free_sess_id;	/* first unused session id */
-	hash_table_t*	hash;		/* hash table of the sessions */
 };
 
-
-/*---------------------------------------------------*/
-/* The format of an incoming message from a client */
-#define SESS_CLI_MSG_CHECKSUM	0	/* the checksum should be the first
-					field in the message */
-#define SESS_CLI_MSG_SESS_ID	4	/* this is set to 0 if the client
-					wants to connect and establish
-					a new session */
-#define	SESS_CLI_MSG_SESS_ID_CHECK 12	/* checksum of the sess id field */
-#define SESS_CLI_MSG_TYPE	16
-#define SESS_CLI_MSG_NO		20
-#define	SESS_CLI_MSG_CONTINUE	28	/* 0, or SESS_MSG_FIRST_PART
-					SESS_MSG_MIDDLE_PART, or
-					SESS_MSG_LAST_PART */
-#define	SESS_CLI_MSG_CONT_SIZE	32	/* size of a multipart message in
-					kilobytes (rounded upwards) */
-#define SESS_CLI_MSG_DATA	36
-/*---------------------------------------------------*/
-
-/* Client-to-session message types */
-#define SESS_CLI_CONNECT	1
-#define	SESS_CLI_PREPARE	2
-#define	SESS_CLI_EXECUTE	3
-#define	SESS_CLI_BREAK_EXECUTION 4
-
-/* Client-to-session statement command types */
-#define SESS_COMM_FETCH_NEXT	1
-#define SESS_COMM_FETCH_PREV	2
-#define SESS_COMM_FETCH_FIRST	3
-#define SESS_COMM_FETCH_LAST	4
-#define SESS_COMM_FETCH_NTH	5
-#define SESS_COMM_FETCH_NTH_LAST 6
-#define	SESS_COMM_EXECUTE	7
-#define	SESS_COMM_NO_COMMAND	8
-
-/*---------------------------------------------------*/
-/* The format of an outgoing message from a session to the client */
-#define SESS_SRV_MSG_CHECKSUM	0	/* the checksum should be the first
-					field in the message */
-#define SESS_SRV_MSG_SESS_ID	4
-#define SESS_SRV_MSG_TYPE	12
-#define SESS_SRV_MSG_NO		16
-#define	SESS_SRV_MSG_CONTINUE	24	/* 0, or SESS_MSG_FIRST_PART
-					SESS_MSG_MIDDLE_PART, or
-					SESS_MSG_LAST_PART */
-#define	SESS_SRV_MSG_CONT_SIZE	28	/* size of a multipart message
-					in kilobytes (rounded upward) */
-#define SESS_SRV_MSG_DATA	32
-/*---------------------------------------------------*/
-
-/* Session-to-client message types */
-#define	SESS_SRV_ACCEPT_CONNECT	1
-#define	SESS_SRV_SUCCESS	2
-#define	SESS_SRV_ERROR		3
-
-/* Multipart messages */
-#define SESS_MSG_SINGLE_PART	0
-#define SESS_MSG_FIRST_PART	1
-#define	SESS_MSG_MIDDLE_PART	2
-#define	SESS_MSG_LAST_PART	3
-
-/* Error numbers */
-#define SESS_ERR_NONE			0
-#define SESS_ERR_TRX_COMMITTED		1
-#define SESS_ERR_TRX_ROLLED_BACK	2
-#define	SESS_ERR_SESSION_DISCONNECTED	3
-#define	SESS_ERR_REPLY_FAILED		4
-#define	SESS_ERR_CANNOT_BREAK_OP	5
-#define	SESS_ERR_MSG_LOST		6
-#define	SESS_ERR_MSG_CORRUPTED		7
-#define	SESS_ERR_EXTRANEOUS_MSG		8
-#define	SESS_ERR_OUT_OF_MEMORY		9
-#define SESS_ERR_SQL_ERROR		10
-#define SESS_ERR_STMT_NOT_FOUND		11
-#define SESS_ERR_STMT_NOT_READY		12
-#define	SESS_ERR_EXTRANEOUS_SRV_MSG	13
-#define	SESS_ERR_BREAK_BY_CLIENT	14
-
 /* Session states */
 #define SESS_ACTIVE		1
 #define SESS_ERROR		2	/* session contains an error message
 					which has not yet been communicated
 					to the client */
-/* Session system states */
-#define SESS_SYS_RUNNING	1
-#define SESS_SYS_SHUTTING_DOWN	2
-
-/* Session hash table size */
-#define SESS_HASH_SIZE		1024
-
-/* Flags used in sess_srv_msg_send */
-#define SESS_RELEASE_KERNEL	1
-#define SESS_NOT_RELEASE_KERNEL	2
-
 #ifndef UNIV_NONINL
 #include "usr0sess.ic"
 #endif
diff --git a/innobase/include/usr0sess.ic b/innobase/include/usr0sess.ic
index ee2592c7963..c851d5745b9 100644
--- a/innobase/include/usr0sess.ic
+++ b/innobase/include/usr0sess.ic
@@ -5,27 +5,3 @@ Sessions
 
 Created 6/25/1996 Heikki Tuuri
 *******************************************************/
-
-/***************************************************************************
-Sets the message type of a message from the client. */
-UNIV_INLINE
-void
-sess_cli_msg_set_type(
-/*==================*/
-	byte*	str,	/* in: message string */
-	ulint	type)	/* in: message type */
-{
-	mach_write_to_4(str + SESS_CLI_MSG_TYPE, type);
-}
-
-/***************************************************************************
-Gets the message type of a message from the server. */
-UNIV_INLINE
-ulint
-sess_srv_msg_get_type(
-/*==================*/
-			/* out: message type */
-	byte*	str)	/* in: message string */
-{
-	return(mach_read_from_4(str + SESS_SRV_MSG_TYPE));
-}
diff --git a/innobase/include/usr0types.h b/innobase/include/usr0types.h
index 67070ccce27..29359425169 100644
--- a/innobase/include/usr0types.h
+++ b/innobase/include/usr0types.h
@@ -10,7 +10,5 @@ Created 6/25/1996 Heikki Tuuri
 #define usr0types_h
 
 typedef struct sess_struct	sess_t;
-typedef struct sess_sys_struct	sess_sys_t;
-typedef struct sess_sig_struct	sess_sig_t;
 
 #endif 
diff --git a/innobase/include/ut0dbg.h b/innobase/include/ut0dbg.h
index 9b07d5da488..085b4811a73 100644
--- a/innobase/include/ut0dbg.h
+++ b/innobase/include/ut0dbg.h
@@ -10,7 +10,6 @@ Created 1/30/1994 Heikki Tuuri
 #define ut0dbg_h
 
 #include "univ.i"
-#include <assert.h>
 #include <stdlib.h>
 #include "os0thread.h"
 
@@ -24,7 +23,7 @@ extern const char*	ut_dbg_msg_assert_fail;
 extern const char*	ut_dbg_msg_trap;
 extern const char*	ut_dbg_msg_stop;
 
-#define ut_a(EXPR)\
+#define ut_a(EXPR) do {\
 	if (!((ulint)(EXPR) + ut_dbg_zero)) {\
                 ut_print_timestamp(stderr);\
 	   	fprintf(stderr, ut_dbg_msg_assert_fail,\
@@ -33,38 +32,32 @@ extern const char*	ut_dbg_msg_stop;
 		fputs("InnoDB: Failing assertion: " #EXPR "\n", stderr);\
 		fputs(ut_dbg_msg_trap, stderr);\
 		ut_dbg_stop_threads = TRUE;\
-		(*ut_dbg_null_ptr)++;\
+		if (*(ut_dbg_null_ptr)) ut_dbg_null_ptr = NULL;\
 	}\
 	if (ut_dbg_stop_threads) {\
 	        fprintf(stderr, ut_dbg_msg_stop,\
      os_thread_pf(os_thread_get_curr_id()), IB__FILE__, (ulint)__LINE__);\
 		os_thread_sleep(1000000000);\
-	}
+	}\
+} while (0)
 
-#define ut_error\
+#define ut_error do {\
         ut_print_timestamp(stderr);\
 	fprintf(stderr, ut_dbg_msg_assert_fail,\
 	os_thread_pf(os_thread_get_curr_id()), IB__FILE__, (ulint)__LINE__);\
 	fprintf(stderr, ut_dbg_msg_trap);\
 	ut_dbg_stop_threads = TRUE;\
-	(*ut_dbg_null_ptr)++;
+	if (*(ut_dbg_null_ptr)) ut_dbg_null_ptr = NULL;\
+} while (0)
 
 #ifdef UNIV_DEBUG
 #define ut_ad(EXPR)  	ut_a(EXPR)
-#define ut_d(EXPR)	{EXPR;}
+#define ut_d(EXPR)	do {EXPR;} while (0)
 #else
 #define ut_ad(EXPR)
 #define ut_d(EXPR)
 #endif
 
-
 #define UT_NOT_USED(A)	A = A
 
-
-
-
-
-
-
 #endif
-
diff --git a/innobase/lock/lock0lock.c b/innobase/lock/lock0lock.c
index 4e6abf32c9e..2430380d65c 100644
--- a/innobase/lock/lock0lock.c
+++ b/innobase/lock/lock0lock.c
@@ -953,7 +953,9 @@ lock_rec_get_next_on_page(
 	ulint	space;
 	ulint	page_no;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(lock_get_type(lock) == LOCK_REC);
 
 	space = lock->un_member.rec_lock.space;
@@ -990,7 +992,9 @@ lock_rec_get_first_on_page_addr(
 {
 	lock_t*	lock;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	lock = HASH_GET_FIRST(lock_sys->rec_hash,
 					lock_rec_hash(space, page_no));
@@ -1048,7 +1052,9 @@ lock_rec_get_first_on_page(
 	ulint	space;
 	ulint	page_no;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	hash = buf_frame_get_lock_hash_val(ptr);
 
@@ -1080,7 +1086,9 @@ lock_rec_get_next(
 	rec_t*	rec,	/* in: record on a page */
 	lock_t*	lock)	/* in: lock */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(lock_get_type(lock) == LOCK_REC);
 
 	for (;;) {
@@ -1109,7 +1117,9 @@ lock_rec_get_first(
 {
 	lock_t*	lock;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	lock = lock_rec_get_first_on_page(rec);
 
@@ -1197,7 +1207,9 @@ lock_rec_get_prev(
 	ulint	page_no;
 	lock_t*	found_lock 	= NULL;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(lock_get_type(in_lock) == LOCK_REC);
 
 	space = in_lock->un_member.rec_lock.space;
@@ -1237,7 +1249,9 @@ lock_table_has(
 {
 	lock_t*	lock;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* Look for stronger locks the same trx already has on the table */
 
@@ -1281,7 +1295,9 @@ lock_rec_has_expl(
 {
 	lock_t*	lock;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad((precise_mode & LOCK_MODE_MASK) == LOCK_S
 	      || (precise_mode & LOCK_MODE_MASK) == LOCK_X);
 	ut_ad(!(precise_mode & LOCK_INSERT_INTENTION));
@@ -1328,7 +1344,9 @@ lock_rec_other_has_expl_req(
 {
 	lock_t*	lock;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(mode == LOCK_X || mode == LOCK_S);
 	ut_ad(gap == 0 || gap == LOCK_GAP);
 	ut_ad(wait == 0 || wait == LOCK_WAIT);
@@ -1367,7 +1385,9 @@ lock_rec_other_has_conflicting(
 {
 	lock_t*	lock;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	lock = lock_rec_get_first(rec);
 
@@ -1399,7 +1419,9 @@ lock_rec_find_similar_on_page(
 	lock_t*	lock;
 	ulint	heap_no;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	heap_no = rec_get_heap_no(rec);
 	
@@ -1433,7 +1455,9 @@ lock_sec_rec_some_has_impl_off_kernel(
 {
 	page_t*	page;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(!(index->type & DICT_CLUSTERED));
 	ut_ad(page_rec_is_user_rec(rec));
 
@@ -1491,7 +1515,9 @@ lock_rec_create(
 	ulint	n_bits;
 	ulint	n_bytes;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	page = buf_frame_align(rec);
 	space = buf_frame_get_space_id(page);
@@ -1575,7 +1601,9 @@ lock_rec_enqueue_waiting(
 	lock_t*	lock;
 	trx_t*	trx;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* Test if there already is some other reason to suspend thread:
 	we do not enqueue a lock request if the query thread should be
@@ -1583,7 +1611,7 @@ lock_rec_enqueue_waiting(
 
 	if (que_thr_stop(thr)) {
 
-		ut_a(0);
+		ut_error;
 
 		return(DB_QUE_THR_SUSPENDED);
 	}
@@ -1661,7 +1689,9 @@ lock_rec_add_to_queue(
 	page_t*	page;
 	ibool	somebody_waits	= FALSE;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad((type_mode & (LOCK_WAIT | LOCK_GAP))
 	      || ((type_mode & LOCK_MODE_MASK) != LOCK_S)
 	      || !lock_rec_other_has_expl_req(LOCK_X, 0, LOCK_WAIT, rec, trx));
@@ -1741,7 +1771,9 @@ lock_rec_lock_fast(
 	lock_t*	lock;
 	ulint	heap_no;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad((LOCK_MODE_MASK & mode) != LOCK_S
 		|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
 	ut_ad((LOCK_MODE_MASK & mode) != LOCK_X
@@ -1805,7 +1837,9 @@ lock_rec_lock_slow(
 	trx_t*	trx;
 	ulint	err;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad((LOCK_MODE_MASK & mode) != LOCK_S
 		|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
 	ut_ad((LOCK_MODE_MASK & mode) != LOCK_X
@@ -1867,7 +1901,9 @@ lock_rec_lock(
 {
 	ulint	err;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad((LOCK_MODE_MASK & mode) != LOCK_S
 		|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
 	ut_ad((LOCK_MODE_MASK & mode) != LOCK_X
@@ -1905,7 +1941,9 @@ lock_rec_has_to_wait_in_queue(
 	ulint	page_no;
 	ulint	heap_no;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
  	ut_ad(lock_get_wait(wait_lock));
 	ut_ad(lock_get_type(wait_lock) == LOCK_REC);
  	
@@ -1938,7 +1976,9 @@ lock_grant(
 /*=======*/
 	lock_t*	lock)	/* in: waiting lock request */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	lock_reset_lock_and_trx_wait(lock);
 
@@ -1980,7 +2020,9 @@ lock_rec_cancel(
 /*============*/
 	lock_t*	lock)	/* in: waiting record lock request */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(lock_get_type(lock) == LOCK_REC);
 
 	/* Reset the bit (there can be only one set bit) in the lock bitmap */
@@ -2013,7 +2055,9 @@ lock_rec_dequeue_from_page(
 	lock_t*	lock;
 	trx_t*	trx;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(lock_get_type(in_lock) == LOCK_REC);
 
 	trx = in_lock->trx;
@@ -2056,7 +2100,9 @@ lock_rec_discard(
 	ulint	page_no;
 	trx_t*	trx;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(lock_get_type(in_lock) == LOCK_REC);
 
 	trx = in_lock->trx;
@@ -2085,7 +2131,9 @@ lock_rec_free_all_from_discard_page(
 	lock_t*	lock;
 	lock_t*	next_lock;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	space = buf_frame_get_space_id(page);
 	page_no = buf_frame_get_page_no(page);
@@ -2118,7 +2166,9 @@ lock_rec_reset_and_release_wait(
 	lock_t*	lock;
 	ulint	heap_no;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	heap_no = rec_get_heap_no(rec);
 	
@@ -2150,7 +2200,9 @@ lock_rec_inherit_to_gap(
 {
 	lock_t*	lock;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	lock = lock_rec_get_first(rec);
 
@@ -2180,7 +2232,9 @@ lock_rec_inherit_to_gap_if_gap_lock(
 {
 	lock_t*	lock;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	lock = lock_rec_get_first(rec);
 
@@ -2213,7 +2267,9 @@ lock_rec_move(
 	ulint	heap_no;
 	ulint	type_mode;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	heap_no = rec_get_heap_no(donator);
 	
@@ -2849,7 +2905,9 @@ lock_deadlock_occurs(
 	char*		err_buf;
 
 	ut_ad(trx && lock);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 retry:
 	/* We check that adding this trx to the waits-for graph
 	does not produce a cycle. First mark all active transactions
@@ -2925,7 +2983,9 @@ lock_deadlock_recursive(
 	ulint	ret;
 	
 	ut_a(trx && start && wait_lock);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	if (trx->deadlock_mark == 1) {
 		/* We have already exhaustively searched the subtree starting
@@ -3116,7 +3176,9 @@ lock_table_create(
 	lock_t*	lock;
 
 	ut_ad(table && trx);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (type_mode == LOCK_AUTO_INC) {
 		/* Only one trx can have the lock on the table
@@ -3166,7 +3228,9 @@ lock_table_remove_low(
 	dict_table_t*	table;
 	trx_t*		trx;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	table = lock->un_member.tab_lock.table;
 	trx = lock->trx;
@@ -3200,14 +3264,16 @@ lock_table_enqueue_waiting(
 	lock_t*	lock;
 	trx_t*	trx;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	/* Test if there already is some other reason to suspend thread:
 	we do not enqueue a lock request if the query thread should be
 	stopped anyway */
 
 	if (que_thr_stop(thr)) {
-		ut_a(0);
+		ut_error;
 
 		return(DB_QUE_THR_SUSPENDED);
 	}
@@ -3270,7 +3336,9 @@ lock_table_other_has_incompatible(
 {
 	lock_t*	lock;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	lock = UT_LIST_GET_LAST(table->locks);
 
@@ -3420,7 +3488,9 @@ lock_table_dequeue(
 {
 	lock_t*	lock;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(lock_get_type(in_lock) == LOCK_TABLE);
 
 	lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, in_lock);
@@ -3476,7 +3546,9 @@ lock_release_off_kernel(
 	ulint		count;
 	lock_t*		lock;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	lock = UT_LIST_GET_LAST(trx->trx_locks);
 	
@@ -3537,7 +3609,9 @@ lock_cancel_waiting_and_release(
 /*============================*/
 	lock_t*	lock)	/* in: waiting lock request */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (lock_get_type(lock) == LOCK_REC) {
 			
@@ -3570,7 +3644,9 @@ lock_reset_all_on_table_for_trx(
 	lock_t*	lock;
 	lock_t*	prev_lock;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	lock = UT_LIST_GET_LAST(trx->trx_locks);
 	
@@ -3632,7 +3708,9 @@ lock_table_print(
 			500 bytes */
 	lock_t*	lock)	/* in: table type lock */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(lock_get_type(lock) == LOCK_TABLE);
 
 	buf += sprintf(buf, "TABLE LOCK table %s trx id %lu %lu",
@@ -3679,7 +3757,9 @@ lock_rec_print(
 	char*	buf_start	= buf;
 	mtr_t	mtr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(lock_get_type(lock) == LOCK_REC);
 
 	space = lock->un_member.rec_lock.space;
@@ -3743,7 +3823,9 @@ lock_rec_print(
 	}
 				
 	if (page) {
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(page, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 	}
 
 	for (i = 0; i < lock_rec_get_n_bits(lock); i++) {
@@ -3788,7 +3870,9 @@ lock_get_n_rec_locks(void)
 	ulint	n_locks	= 0;
 	ulint	i;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	for (i = 0; i < hash_get_n_cells(lock_sys->rec_hash); i++) {
 
@@ -4060,7 +4144,9 @@ lock_table_queue_validate(
 	lock_t*	lock;
 	ibool	is_waiting;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	is_waiting = FALSE;
 
@@ -4213,12 +4299,16 @@ lock_rec_validate_page(
 	ulint	i;
 	mtr_t	mtr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mtr_start(&mtr);
 	
 	page = buf_page_get(space, page_no, RW_X_LATCH, &mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 
 	lock_mutex_enter_kernel();
 loop:	
@@ -4464,7 +4554,9 @@ lock_rec_convert_impl_to_expl(
 {
 	trx_t*	impl_trx;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(page_rec_is_user_rec(rec));
 
 	if (index->type & DICT_CLUSTERED) {
diff --git a/innobase/log/log0log.c b/innobase/log/log0log.c
index a40be74cac2..095d84f6527 100644
--- a/innobase/log/log0log.c
+++ b/innobase/log/log0log.c
@@ -133,7 +133,9 @@ log_buf_pool_get_oldest_modification(void)
 {
 	dulint	lsn;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	lsn = buf_pool_get_oldest_modification();
 
@@ -231,7 +233,9 @@ log_write_low(
 	ulint	data_len;
 	byte*	log_block;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 part_loop:
 	/* Calculate a part length */
 
@@ -298,7 +302,9 @@ log_close(void)
 	log_t*	log	= log_sys;
 	ulint	checkpoint_age;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	lsn = log->lsn;
 	
@@ -414,7 +420,9 @@ log_group_get_capacity(
 				/* out: capacity in bytes */
 	log_group_t*	group)	/* in: log group */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	return((group->file_size - LOG_FILE_HDR_SIZE) * group->n_files); 
 }
@@ -430,7 +438,9 @@ log_group_calc_size_offset(
 	ulint		offset,	/* in: real offset within the log group */
 	log_group_t*	group)	/* in: log group */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(offset - LOG_FILE_HDR_SIZE * (1 + offset / group->file_size));
 }
@@ -446,7 +456,9 @@ log_group_calc_real_offset(
 	ulint		offset,	/* in: size offset within the log group */
 	log_group_t*	group)	/* in: log group */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	return(offset + LOG_FILE_HDR_SIZE
 		* (1 + offset / (group->file_size - LOG_FILE_HDR_SIZE)));
@@ -469,7 +481,9 @@ log_group_calc_lsn_offset(
 	ib_longlong	group_size;
 	ib_longlong	offset;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* If total log file size is > 2 GB we can easily get overflows
 	with 32-bit integers. Use 64-bit integers instead. */
@@ -583,7 +597,9 @@ log_calc_max_ages(void)
 	ulint		archive_margin;
 	ulint		smallest_archive_margin;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mutex_enter(&(log_sys->mutex));
 
@@ -873,7 +889,9 @@ log_flush_do_unlocks(
 	ulint	code)	/* in: any ORed combination of LOG_UNLOCK_FLUSH_LOCK
 			and LOG_UNLOCK_NONE_FLUSHED_LOCK */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* NOTE that we must own the log mutex when doing the setting of the
 	events: this is because transactions will wait for these events to
@@ -905,7 +923,9 @@ log_group_check_flush_completion(
 				/* out: LOG_UNLOCK_NONE_FLUSHED_LOCK or 0 */
 	log_group_t*	group)	/* in: log group */
 {
-	ut_ad(mutex_own(&(log_sys->mutex)));	
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (!log_sys->one_flushed && group->n_pending_writes == 0) {
 
@@ -939,7 +959,9 @@ log_sys_check_flush_completion(void)
 	ulint	move_start;
 	ulint	move_end;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (log_sys->n_pending_writes == 0) {
 	
@@ -1002,7 +1024,7 @@ log_io_complete(
 		return;
 	}
 
-	ut_a(0);	/* We currently use synchronous writing of the
+	ut_error;	/* We currently use synchronous writing of the
 			logs and cannot end up here! */
 
 	if (srv_unix_file_flush_method != SRV_UNIX_O_DSYNC
@@ -1046,7 +1068,9 @@ log_group_file_header_flush(
 	
 	UT_NOT_USED(type);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	ut_a(nth_file < group->n_files);
 
@@ -1114,7 +1138,9 @@ log_group_write_buf(
 	ulint	next_offset;
 	ulint	i;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(len % OS_FILE_LOG_BLOCK_SIZE == 0);
 	ut_a(ut_dulint_get_low(start_lsn) % OS_FILE_LOG_BLOCK_SIZE == 0);
 
@@ -1513,7 +1539,9 @@ void
 log_complete_checkpoint(void)
 /*=========================*/
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(log_sys->n_pending_checkpoint_writes == 0);
 
 	log_sys->next_checkpoint_no
@@ -1604,7 +1632,9 @@ log_group_checkpoint(
 	byte*	buf;
 	ulint	i;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(LOG_CHECKPOINT_SIZE <= OS_FILE_LOG_BLOCK_SIZE);
 	
 	buf = group->checkpoint_buf;
@@ -1758,7 +1788,9 @@ log_group_read_checkpoint_info(
 	log_group_t*	group,	/* in: log group */
 	ulint		field)	/* in: LOG_CHECKPOINT_1 or LOG_CHECKPOINT_2 */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	log_sys->n_log_ios++;
 	
@@ -1776,7 +1808,9 @@ log_groups_write_checkpoint_info(void)
 {
 	log_group_t*	group;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	group = UT_LIST_GET_FIRST(log_sys->log_groups);
 
@@ -2041,7 +2075,9 @@ log_group_read_log_seg(
 	ulint	source_offset;
 	ibool	sync;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	sync = FALSE;
 
@@ -2113,9 +2149,11 @@ log_group_archive_file_header_write(
 	byte*	buf;
 	ulint	dest_offset;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_a(0);
 
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	ut_a(nth_file < group->n_files);
 
@@ -2152,9 +2190,11 @@ log_group_archive_completed_header_write(
 	byte*	buf;
 	ulint	dest_offset;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_a(0);
 
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(nth_file < group->n_files);
 
 	buf = *(group->archive_file_header_bufs + nth_file);
@@ -2193,9 +2233,11 @@ log_group_archive(
 	ulint	n_files;
 	ulint	open_mode;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_a(0);
 
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	start_lsn = log_sys->archived_lsn;
 
@@ -2320,9 +2362,11 @@ log_archive_groups(void)
 {
 	log_group_t*	group;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_a(0);
 
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	group = UT_LIST_GET_FIRST(log_sys->log_groups);
 
@@ -2345,9 +2389,11 @@ log_archive_write_complete_groups(void)
 	dulint		end_lsn;
 	ulint		i;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_a(0);
 
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	group = UT_LIST_GET_FIRST(log_sys->log_groups);
 
@@ -2409,9 +2455,11 @@ void
 log_archive_check_completion_low(void)
 /*==================================*/
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_a(0);
 
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (log_sys->n_pending_archive_ios == 0
 			&& log_sys->archiving_phase == LOG_ARCHIVE_READ) {
@@ -2513,7 +2561,6 @@ loop:
 	
 	if (calc_new_limit) {
 		ut_a(log_sys->archive_buf_size % OS_FILE_LOG_BLOCK_SIZE
-								== 0);
 		limit_lsn = ut_dulint_add(start_lsn,
 						log_sys->archive_buf_size);
 
@@ -2649,7 +2696,9 @@ log_archive_close_groups(
 	log_group_t*	group;
 	ulint		trunc_len;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (log_sys->archiving_state == LOG_ARCH_OFF) {
 
@@ -3172,7 +3221,9 @@ log_check_log_recs(
 	byte*	buf1;
 	byte*	scan_buf;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (len == 0) {
 
diff --git a/innobase/log/log0recv.c b/innobase/log/log0recv.c
index 0a1115a6891..f80181cc207 100644
--- a/innobase/log/log0recv.c
+++ b/innobase/log/log0recv.c
@@ -165,14 +165,16 @@ void
 recv_sys_empty_hash(void)
 /*=====================*/
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(recv_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	if (recv_sys->n_addrs != 0) {
 		fprintf(stderr,
 "InnoDB: Error: %lu pages with log records were left unprocessed!\n"
 "InnoDB: Maximum page number with log records on it %lu\n",
 			(ulong) recv_sys->n_addrs, 
 			(ulong) recv_max_parsed_page_no);
-		ut_a(0);
+		ut_error;
 	}
 	
 	hash_table_free(recv_sys->addr_hash);
@@ -1078,7 +1080,9 @@ recv_recover_page(
 					&mtr);
 		ut_a(success);
 
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(page, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 	}
 
 	/* Read the newest modification lsn from the page */
@@ -1280,14 +1284,13 @@ loop:
 		goto loop;
 	}
 
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(!allow_ibuf == mutex_own(&log_sys->mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	if (!allow_ibuf) {
-		ut_ad(mutex_own(&(log_sys->mutex)));
-
 		recv_no_ibuf_operations = TRUE;
-	} else {
-		ut_ad(!mutex_own(&(log_sys->mutex)));
 	}
-	
+
 	recv_sys->apply_log_recs = TRUE;
 	recv_sys->apply_batch_on = TRUE;
 
@@ -1317,8 +1320,10 @@ loop:
 					page = buf_page_get(space, page_no,
 							RW_X_LATCH, &mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 					buf_page_dbg_add_level(page,
 							SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 					recv_recover_page(FALSE, FALSE, page,
 							space, page_no);
 					mtr_commit(&mtr);
@@ -1541,7 +1546,9 @@ recv_update_replicate(
 
 	replica = buf_page_get(space + RECV_REPLICA_SPACE_ADD, page_no,
 							RW_X_LATCH, &mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(replica, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 							
 	ptr = recv_parse_or_apply_log_rec_body(type, body, end_ptr, replica,
 									&mtr);
@@ -1610,7 +1617,9 @@ recv_compare_replicate(
 
 	replica = buf_page_get(space + RECV_REPLICA_SPACE_ADD, page_no,
 							RW_X_LATCH, &mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(replica, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 
 	recv_check_identical(page + FIL_PAGE_DATA,
 			replica + FIL_PAGE_DATA,
@@ -1651,7 +1660,9 @@ recv_compare_spaces(
 						IB__FILE__, __LINE__,
 						&mtr);
 		if (frame) {
+#ifdef UNIV_SYNC_DEBUG
 			buf_page_dbg_add_level(frame, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 			ut_memcpy(page, frame, UNIV_PAGE_SIZE);
 		} else {
 			/* Read it from file */
@@ -1664,7 +1675,9 @@ recv_compare_spaces(
 						IB__FILE__, __LINE__,
 						&mtr);
 		if (frame) {
+#ifdef UNIV_SYNC_DEBUG
 			buf_page_dbg_add_level(frame, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 			ut_memcpy(replica, frame, UNIV_PAGE_SIZE);
 		} else {
 			/* Read it from file */
@@ -1916,7 +1929,9 @@ recv_parse_log_recs(
 	byte*	body;
 	ulint	n_recs;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(!ut_dulint_is_zero(recv_sys->parse_start_lsn));
 loop:
 	ptr = recv_sys->buf + recv_sys->recovered_offset;
@@ -2899,8 +2914,9 @@ recv_reset_logs(
 {
 	log_group_t*	group;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
-
+#endif /* UNIV_SYNC_DEBUG */
 	log_sys->lsn = ut_dulint_align_up(lsn, OS_FILE_LOG_BLOCK_SIZE);
 
 	group = UT_LIST_GET_FIRST(log_sys->log_groups);
diff --git a/innobase/mem/mem0dbg.c b/innobase/mem/mem0dbg.c
index 89ca68a1232..1007f8413b4 100644
--- a/innobase/mem/mem0dbg.c
+++ b/innobase/mem/mem0dbg.c
@@ -7,6 +7,7 @@ but is included in mem0mem.* !
 Created 6/9/1994 Heikki Tuuri
 *************************************************************************/
 
+#ifdef UNIV_MEM_DEBUG
 mutex_t	mem_hash_mutex;	 /* The mutex which protects in the
 			debug version the hash table containing
 			the list of live memory heaps, and
@@ -16,12 +17,11 @@ mutex_t	mem_hash_mutex;	 /* The mutex which protects in the
 extent of memory allocations. Only used in the debug version.
 Protected by mem_hash_mutex above. */
 
-ulint	mem_n_created_heaps 		= 0;
-ulint	mem_n_allocations	  	= 0;
-ulint	mem_total_allocated_memory	= 0;
-ulint	mem_current_allocated_memory	= 0;
-ulint	mem_max_allocated_memory	= 0;
-ulint	mem_last_print_info		= 0;
+static ulint	mem_n_created_heaps 		= 0;
+static ulint	mem_n_allocations	  	= 0;
+static ulint	mem_total_allocated_memory	= 0;
+static ulint	mem_current_allocated_memory	= 0;
+static ulint	mem_max_allocated_memory	= 0;
 
 /* Size of the hash table for memory management tracking */
 #define	MEM_HASH_SIZE	997
@@ -43,12 +43,12 @@ struct mem_hash_node_struct {
 typedef UT_LIST_BASE_NODE_T(mem_hash_node_t) mem_hash_cell_t;
 
 /* The hash table of allocated heaps */
-mem_hash_cell_t		mem_hash_table[MEM_HASH_SIZE];
+static mem_hash_cell_t		mem_hash_table[MEM_HASH_SIZE];
 
 /* The base node of the list of all allocated heaps */
-mem_hash_cell_t		mem_all_list_base;
+static mem_hash_cell_t		mem_all_list_base;
 
-ibool	mem_hash_initialized	= FALSE;
+static ibool	mem_hash_initialized	= FALSE;
 
 
 UNIV_INLINE
@@ -65,45 +65,44 @@ mem_hash_get_nth_cell(ulint i)
 
 	return(&(mem_hash_table[i]));
 }
+#endif /* UNIV_MEM_DEBUG */
 
 /* Accessor functions for a memory field in the debug version */
 
 void
 mem_field_header_set_len(byte* field, ulint len)
 {
-	ut_ad(len >= 0);
-
-	mach_write(field - 2 * sizeof(ulint), len);
+	mach_write_to_4(field - 2 * sizeof(ulint), len);
 }
 
 ulint
 mem_field_header_get_len(byte* field)
 {
-	return(mach_read(field - 2 * sizeof(ulint)));
+	return(mach_read_from_4(field - 2 * sizeof(ulint)));
 }
 
 void
 mem_field_header_set_check(byte* field, ulint check)
 {
-	mach_write(field - sizeof(ulint), check);
+	mach_write_to_4(field - sizeof(ulint), check);
 }
 
 ulint
 mem_field_header_get_check(byte* field)
 {
-	return(mach_read(field - sizeof(ulint)));
+	return(mach_read_from_4(field - sizeof(ulint)));
 }
 
 void
 mem_field_trailer_set_check(byte* field, ulint check)
 {
-	mach_write(field + mem_field_header_get_len(field), check);
+	mach_write_to_4(field + mem_field_header_get_len(field), check);
 }
 
 ulint
 mem_field_trailer_get_check(byte* field)
 {
-	return(mach_read(field +
+	return(mach_read_from_4(field +
 			mem_field_header_get_len(field)));
 }
 
@@ -164,6 +163,7 @@ mem_field_init(
 	mem_field_header_set_check(usr_buf, rnd);
 	mem_field_trailer_set_check(usr_buf, rnd);
 
+#ifdef UNIV_MEM_DEBUG
 	/* Update the memory allocation information */
 
 	mutex_enter(&mem_hash_mutex);
@@ -182,6 +182,7 @@ mem_field_init(
 	combination of 0xBA and 0xBE */
 
 	mem_init_buf(usr_buf, n);
+#endif /* UNIV_MEM_DEBUG */
 }
 
 /**********************************************************************
@@ -191,12 +192,14 @@ void
 mem_field_erase(
 /*============*/
 	byte*	buf,	/* in: memory field */
-	ulint	n)	/* in: how many bytes the user requested */
+	ulint	n __attribute__((unused)))
+			/* in: how many bytes the user requested */
 {
 	byte*	usr_buf;
 
 	usr_buf = buf + MEM_FIELD_HEADER_SIZE;
-	
+
+#ifdef UNIV_MEM_DEBUG
 	mutex_enter(&mem_hash_mutex);
 	mem_current_allocated_memory    -= n;
 	mutex_exit(&mem_hash_mutex);
@@ -208,8 +211,10 @@ mem_field_erase(
 	combination of 0xDE and 0xAD */
 
 	mem_erase_buf(buf, MEM_SPACE_NEEDED(n));
+#endif /* UNIV_MEM_DEBUG */
 }
 
+#ifdef UNIV_MEM_DEBUG
 /*******************************************************************
 Initializes a buffer to a random combination of hex BA and BE.
 Used to initialize allocated memory. */
@@ -372,6 +377,7 @@ mem_hash_remove(
 
 	mutex_exit(&mem_hash_mutex);
 }
+#endif /* UNIV_MEM_DEBUG */
 
 /*******************************************************************
 Checks a memory heap for consistency and prints the contents if requested.
diff --git a/innobase/mem/mem0pool.c b/innobase/mem/mem0pool.c
index 2817e1f12d4..4f1ac2bcd7c 100644
--- a/innobase/mem/mem0pool.c
+++ b/innobase/mem/mem0pool.c
@@ -259,7 +259,9 @@ mem_pool_fill_free_list(
 	mem_area_t*	area2;
 	ibool		ret;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(pool->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (i >= 63) {
 		/* We come here when we have run out of space in the
@@ -296,7 +298,7 @@ mem_pool_fill_free_list(
 	if (UT_LIST_GET_LEN(pool->free_list[i + 1]) == 0) {
 	        mem_analyze_corruption((byte*)area);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	UT_LIST_REMOVE(free_list, pool->free_list[i + 1], area);
@@ -374,7 +376,7 @@ mem_area_alloc(
 "InnoDB: Probably a race condition because now the area is marked free!\n");
 		}
 
-		ut_a(0);
+		ut_error;
 	}
 
 	if (UT_LIST_GET_LEN(pool->free_list[n]) == 0) {
@@ -384,7 +386,7 @@ mem_area_alloc(
 			(ulong) n);
 		mem_analyze_corruption((byte*)area);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	ut_ad(mem_area_get_size(area) == ut_2_exp(n));	
@@ -480,7 +482,7 @@ mem_area_free(
 "InnoDB: element is marked free!\n");
 
 		mem_analyze_corruption((byte*)area);
-		ut_a(0);
+		ut_error;
 	}
 
 	size = mem_area_get_size(area);
@@ -491,7 +493,7 @@ mem_area_free(
 "InnoDB: previous allocated area!\n");
 
 		mem_analyze_corruption((byte*)area);
-		ut_a(0);
+		ut_error;
 	}
 
 #ifdef UNIV_LIGHT_MEM_DEBUG	
@@ -508,7 +510,7 @@ mem_area_free(
 			  (ulong) size, (ulong) next_size);
 			mem_analyze_corruption((byte*)area);
 
-			ut_a(0);
+			ut_error;
 		}
 	}
 #endif
diff --git a/innobase/mtr/mtr0log.c b/innobase/mtr/mtr0log.c
index 4b5d7e61de6..5a4aaa2377d 100644
--- a/innobase/mtr/mtr0log.c
+++ b/innobase/mtr/mtr0log.c
@@ -59,7 +59,7 @@ mlog_write_initial_log_record(
 		fprintf(stderr,
 	"InnoDB: Error: trying to write to a stray memory location %lx\n",
 			(ulong) ptr);
-		ut_a(0);
+		ut_error;
 	}
 
 	log_ptr = mlog_open(mtr, 20);
@@ -222,7 +222,7 @@ mlog_write_ulint(
 		fprintf(stderr,
 	"InnoDB: Error: trying to write to a stray memory location %lx\n",
 			(ulong) ptr);
-		ut_a(0);
+		ut_error;
 	}
 
 	if (type == MLOG_1BYTE) {
@@ -261,7 +261,6 @@ mlog_write_dulint(
 /*==============*/
 	byte*	ptr,	/* in: pointer where to write */
 	dulint	val,	/* in: value to write */
-	byte	type,	/* in: MLOG_8BYTES */
 	mtr_t*	mtr)	/* in: mini-transaction handle */
 {
 	byte*	log_ptr;
@@ -270,11 +269,10 @@ mlog_write_dulint(
 		fprintf(stderr,
 	"InnoDB: Error: trying to write to a stray memory location %lx\n",
 			(ulong) ptr);
-		ut_a(0);
+		ut_error;
 	}
 
 	ut_ad(ptr && mtr);
-	ut_ad(type == MLOG_8BYTES);
 
 	mach_write_to_8(ptr, val);
 
@@ -286,7 +284,8 @@ mlog_write_dulint(
 		return;
 	}
 
-	log_ptr = mlog_write_initial_log_record_fast(ptr, type, log_ptr, mtr);
+	log_ptr = mlog_write_initial_log_record_fast(ptr, MLOG_8BYTES,
+							log_ptr, mtr);
 
 	mach_write_to_2(log_ptr, ptr - buf_frame_align(ptr));
 	log_ptr += 2;
@@ -314,7 +313,7 @@ mlog_write_string(
 		fprintf(stderr,
 	"InnoDB: Error: trying to write to a stray memory location %lx\n",
 			(ulong) ptr);
-		ut_a(0);
+		ut_error;
 	}
 	ut_ad(ptr && mtr);
 	ut_a(len < UNIV_PAGE_SIZE);
diff --git a/innobase/mtr/mtr0mtr.c b/innobase/mtr/mtr0mtr.c
index 60e3ecfe150..ac1a638063d 100644
--- a/innobase/mtr/mtr0mtr.c
+++ b/innobase/mtr/mtr0mtr.c
@@ -495,13 +495,11 @@ mtr_read_dulint(
 /*===========*/
 				/* out: value read */
 	byte*		ptr,	/* in: pointer from where to read */
-	ulint		type __attribute__((unused)), /* in: MLOG_8BYTES */
 	mtr_t*		mtr __attribute__((unused)))
                                 /* in: mini-transaction handle */
 {
 	ut_ad(mtr->state == MTR_ACTIVE);
 	ut_ad(ptr && mtr);
-	ut_ad(type == MLOG_8BYTES);
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(ptr), 
 						MTR_MEMO_PAGE_S_FIX) ||
 	      mtr_memo_contains(mtr, buf_block_align(ptr), 
diff --git a/innobase/os/os0file.c b/innobase/os/os0file.c
index a87ab974b83..7c9272fa13f 100644
--- a/innobase/os/os0file.c
+++ b/innobase/os/os0file.c
@@ -1068,7 +1068,7 @@ try_again:
 	} else if (type == OS_DATA_FILE) {
 		type_str = "DATA";
 	} else {
-	        ut_a(0);
+	        ut_error;
 	}
 	  
 	if (purpose == OS_FILE_AIO) {
@@ -1076,7 +1076,7 @@ try_again:
 	} else if (purpose == OS_FILE_NORMAL) {
 		purpose_str = "NORMAL";
 	} else {
-	        ut_a(0);
+	        ut_error;
 	}
 
 /*	printf("Opening file %s, mode %s, type %s, purpose %s\n",
@@ -1558,7 +1558,7 @@ os_file_flush(
 
 	/* It is a fatal error if a file flush does not succeed, because then
 	the database can get corrupt on disk */
-	ut_a(0);
+	ut_error;
 
 	return(FALSE);
 #else
@@ -1593,7 +1593,7 @@ os_file_flush(
 
 	/* It is a fatal error if a file flush does not succeed, because then
 	the database can get corrupt on disk */
-	ut_a(0);
+	ut_error;
 
 	return(FALSE);
 #endif
@@ -2430,7 +2430,7 @@ os_aio_get_array_no(
 
 		return(3);
 	} else {
-		ut_a(0);
+		ut_error;
 
 		return(0);
 	}
@@ -2457,7 +2457,7 @@ os_aio_get_array_from_no(
 
 		return(os_aio_write_array);
 	} else {
-		ut_a(0);
+		ut_error;
 
 		return(NULL);
 	}
@@ -3047,7 +3047,7 @@ os_aio_posix_handle(
 
 	if (sig != SIGRTMIN + 1 + array_no) {
 
-		ut_a(0);
+		ut_error;
 	
 		return(FALSE);
 	}
@@ -3312,7 +3312,7 @@ consecutive_loop:
 					slot->name, (ulong) slot->offset_high,
 					(ulong) slot->offset,
 					(ulong) total_len);
-				ut_a(0);
+				ut_error;
 			}
 			  
 			/* Do a 'last millisecond' check that the page end
diff --git a/innobase/page/page0cur.c b/innobase/page/page0cur.c
index 89dad4f268f..eb2ba5b8bf8 100644
--- a/innobase/page/page0cur.c
+++ b/innobase/page/page0cur.c
@@ -716,7 +716,7 @@ page_cur_parse_insert_rec(
 
 	       buf_page_print(page);
 
-	       ut_a(0);
+	       ut_error;
 	}
 
 	ut_memcpy(buf, rec_get_start(cursor_rec), mismatch_index);
diff --git a/innobase/page/page0page.c b/innobase/page/page0page.c
index b7a85e79658..c64a7590b94 100644
--- a/innobase/page/page0page.c
+++ b/innobase/page/page0page.c
@@ -110,7 +110,7 @@ page_dir_find_owner_slot(
 
 			buf_page_print(page);
 
-	  		ut_a(0);
+	  		ut_error;
 	  	}
 
 		i--;
@@ -441,7 +441,7 @@ page_copy_rec_list_end_no_locks(
 			      (ulong)(rec - page),
 			      (ulong)(page_cur_get_rec(&cur1) - page),
 			      (ulong)(page_cur_get_rec(&cur2) - new_page));
-			ut_a(0);
+			ut_error;
 		}
 
 		page_cur_move_to_next(&cur1);
diff --git a/innobase/pars/lexyy.c b/innobase/pars/lexyy.c
index 7c6711d2f97..f014200b2a6 100644
--- a/innobase/pars/lexyy.c
+++ b/innobase/pars/lexyy.c
@@ -627,7 +627,7 @@ Linux.
 #define malloc(A)	mem_alloc(A)
 #define free(A)		mem_free(A)
 #define realloc(P, A)	mem_realloc(P, A, __FILE__, __LINE__)
-#define exit(A) 	ut_a(0)
+#define exit(A) 	ut_error
 
 #define YY_INPUT(buf, result, max_size) pars_get_lex_chars(buf, &result, max_size)
 #define comment 1
diff --git a/innobase/pars/pars0pars.c b/innobase/pars/pars0pars.c
index 3e43b6ae262..5bbfca831f2 100644
--- a/innobase/pars/pars0pars.c
+++ b/innobase/pars/pars0pars.c
@@ -29,13 +29,14 @@ on 1/27/1998 */
 #include "trx0trx.h"
 #include "trx0roll.h"
 #include "lock0lock.h"
-#include "odbc0odbc.h"
 #include "eval0eval.h"
 
+#ifdef UNIV_SQL_DEBUG
 /* If the following is set TRUE, the lexer will print the SQL string
 as it tokenizes it */
 
 ibool	pars_print_lexed	= FALSE;
+#endif /* UNIV_SQL_DEBUG */
 
 /* Global variable used while parsing a single procedure or query : the code is
 NOT re-entrant */
@@ -389,7 +390,7 @@ pars_resolve_exp_variables_and_types(
 	}
 
 	if (!node) {
-		printf("PARSER ERROR: Unresolved identifier %s\n",
+		fprintf(stderr, "PARSER ERROR: Unresolved identifier %s\n",
 							sym_node->name);
 	}
 	
@@ -522,25 +523,6 @@ pars_resolve_exp_list_columns(
 }
 
 /*************************************************************************
-Retrieves the stored procedure definition for a procedure name. */
-static
-void
-pars_retrieve_procedure_def(
-/*========================*/
-	sym_node_t*	sym_node)	/* in: procedure name node */
-{
-	ut_a(sym_node);
-	ut_a(que_node_get_type(sym_node) == QUE_NODE_SYMBOL);
-
-	sym_node->resolved = TRUE;
-	sym_node->token_type = SYM_PROCEDURE_NAME;
-
-	sym_node->procedure_def = dict_procedure_get((char*)sym_node->name,
-								NULL);
-	ut_a(sym_node->procedure_def);
-}
-
-/*************************************************************************
 Retrieves the table definition for a table name id. */
 static
 void
@@ -1662,219 +1644,22 @@ pars_procedure_definition(
 
 /*****************************************************************
 Parses a stored procedure call, when this is not within another stored
-procedure, that is, the client issues a procedure call directly. */
+procedure, that is, the client issues a procedure call directly.
+In MySQL/InnoDB, stored InnoDB procedures are invoked via the
+parsed procedure tree, not via InnoDB SQL, so this function is not used. */
 
 que_fork_t*
 pars_stored_procedure_call(
 /*=======================*/
 					/* out: query graph */
-	sym_node_t*	sym_node)	/* in: stored procedure name */
+	sym_node_t*	sym_node __attribute__((unused)))
+					/* in: stored procedure name */
 {
-	call_node_t*	node;
-	que_fork_t*	fork;
-	que_thr_t*	thr;
-	mem_heap_t*	heap;
-
-	heap = pars_sym_tab_global->heap;
-
-	fork = que_fork_create(NULL, NULL, QUE_FORK_PROCEDURE_CALL, heap);
-	fork->trx = NULL;
-
-	thr = que_thr_create(fork, heap);
-
-	node = mem_heap_alloc(heap, sizeof(call_node_t));
-
-	thr->child = node;
-
-	node->common.type = QUE_NODE_CALL;
-	node->common.parent = thr;
-
-	sym_node->token_type = SYM_PROCEDURE_NAME;
-
-	pars_retrieve_procedure_def(sym_node);	
-	
-	node->procedure_def = sym_node->procedure_def;
-	node->proc_name = sym_node;
-
-	node->sym_tab = pars_sym_tab_global;
-
- 	pars_sym_tab_global->query_graph = fork;
-
-	return(fork);
-}
-
-/*****************************************************************
-Writes info about query parameter markers (denoted with '?' in ODBC) into a
-buffer. */
-
-ulint
-pars_write_query_param_info(
-/*========================*/
-				/* out: number of bytes used for info in buf */
-	byte*		buf,	/* in: buffer which must be big enough */
-	que_fork_t*	graph)	/* in: parsed query graph */
-{
-	que_thr_t*	thr;
-	call_node_t*	call_node;
-	dict_proc_t*	procedure_def;
-	que_t*		stored_graph;
-	proc_node_t*	proc_node;
-	sym_node_t*	param;
-	ulint		n_params;
-	ibool		is_input;
-
-	/* We currently support parameter markers only in stored procedure
-	calls, and there ALL procedure parameters must be marked with '?':
-	no literal values are allowed */
-
-	thr = UT_LIST_GET_FIRST(graph->thrs);
-
-	n_params = 0;
-
-	if (que_node_get_type(thr->child) == QUE_NODE_CALL) {
-		call_node = thr->child;
-
-		procedure_def = call_node->procedure_def;
-
-		stored_graph = dict_procedure_reserve_parsed_copy(
-								procedure_def);
-		proc_node = que_fork_get_child(stored_graph);
-
-		param = proc_node->param_list;
-
-		while (param) {
-			if (param->param_type == PARS_INPUT) {
-				is_input = TRUE;
-			} else {
-				is_input = FALSE;
-			}
-
-			mach_write_to_1(buf + 4 + n_params, is_input);
-
-			n_params++;
-
-			param = que_node_get_next(param);
-		}
-
-		dict_procedure_release_parsed_copy(stored_graph);
-	}
-
-	mach_write_to_4(buf, n_params);
-
-	return(4 + n_params);
+	ut_error;
+	return(NULL);
 }
 
 /*****************************************************************
-Reads stored procedure input parameter values from a buffer. */
-
-void
-pars_proc_read_input_params_from_buf(
-/*=================================*/
-	que_t*	graph,	/* in: query graph which contains a stored procedure */
-	byte*	buf)	/* in: buffer */
-{
-	que_thr_t*	thr;
-	proc_node_t*	proc_node;
-	sym_node_t*	param;
-	byte*		ptr;
-	ulint		len;
-	lint		odbc_len;
-
-	ut_ad(graph->fork_type == QUE_FORK_PROCEDURE);
-
-	thr = UT_LIST_GET_FIRST(graph->thrs);
-
-	proc_node = thr->child;
-
-	ptr = buf;
-	
-	param = proc_node->param_list;
-
-	while (param) {
-		if (param->param_type == PARS_INPUT) {
-			odbc_len = (lint)mach_read_from_4(ptr);
-
-			ptr += 4;
-
-			if (odbc_len == SQL_NULL_DATA) {
-				len = UNIV_SQL_NULL;
-			} else {
-				len = (ulint)odbc_len;
-			}
-
- 			eval_node_copy_and_alloc_val(param, ptr, len);
-		
-			if (len != UNIV_SQL_NULL) {
-				ptr += len;
-			}
-		}
-
-		param = que_node_get_next(param);
-	}
-
-	ut_ad(ptr - buf < ODBC_DATAGRAM_SIZE);
-}	
-
-/*****************************************************************
-Writes stored procedure output parameter values to a buffer. */
-
-ulint
-pars_proc_write_output_params_to_buf(
-/*=================================*/
-			/* out: bytes used in buf */
-	byte*	buf,	/* in: buffer which must be big enough */
-	que_t*	graph)	/* in: query graph which contains a stored procedure */
-{
-	que_thr_t*	thr;
-	proc_node_t*	proc_node;
-	sym_node_t*	param;
-	dfield_t*	dfield;
-	byte*		ptr;
-	ulint		len;
-	lint		odbc_len;
-
-	ut_ad(graph->fork_type == QUE_FORK_PROCEDURE);
-
-	thr = UT_LIST_GET_FIRST(graph->thrs);
-
-	proc_node = thr->child;
-
-	ptr = buf;
-	
-	param = proc_node->param_list;
-
-	while (param) {
-		if (param->param_type == PARS_OUTPUT) {
-			dfield = que_node_get_val(param);
-		
-			len = dfield_get_len(dfield);
-
-			if (len == UNIV_SQL_NULL) {
-				odbc_len = SQL_NULL_DATA;
-			} else {
-				odbc_len = (lint)len;
-			}
-		
-			mach_write_to_4(ptr, (ulint)odbc_len);
-
-			ptr += 4;
-
-			if (len != UNIV_SQL_NULL) {
-				ut_memcpy(ptr, dfield_get_data(dfield), len);
-
-				ptr += len;
-			}
-		}
-
-		param = que_node_get_next(param);
-	}
-
-	ut_ad(ptr - buf < ODBC_DATAGRAM_SIZE);
-
-	return((ulint)(ptr - buf));
-}	
-
-/*****************************************************************
 Retrieves characters to the lexical analyzer. */
 
 void
@@ -1886,13 +1671,12 @@ pars_get_lex_chars(
 				in the buffer */
 {
 	int	len;
-	char	print_buf[16];
 	
 	len = pars_sym_tab_global->string_len
 				- pars_sym_tab_global->next_char_pos;
 	if (len == 0) {
 #ifdef YYDEBUG
-		/* printf("SQL string ends\n"); */
+		/* fputs("SQL string ends\n", stderr); */
 #endif	
 		*result = 0;
 
@@ -1903,18 +1687,18 @@ pars_get_lex_chars(
 		len = max_size;
 	}
 
+#ifdef UNIV_SQL_DEBUG
 	if (pars_print_lexed) {
 		
 		if (len >= 5) {
 			len = 5;
 		}
-	
-		ut_memcpy(print_buf, pars_sym_tab_global->sql_string +
-				pars_sym_tab_global->next_char_pos, len);
-		print_buf[len] = '\0';
-		
-		printf("%s", print_buf);
+
+		fwrite(pars_sym_tab_global->sql_string +
+			pars_sym_tab_global->next_char_pos,
+			1, len, stderr);
 	}
+#endif /* UNIV_SQL_DEBUG */
 	
 	ut_memcpy(buf, pars_sym_tab_global->sql_string +
 				pars_sym_tab_global->next_char_pos, len);
@@ -1944,7 +1728,7 @@ yyerror(
 {
 	ut_ad(s);
 
-	printf("PARSER ERROR: Syntax error in SQL string\n");
+	fputs("PARSER ERROR: Syntax error in SQL string\n", stderr);
 
 	ut_error;
 }
@@ -1968,10 +1752,10 @@ pars_sql(
 
 	heap = mem_heap_create(256);
 
+#ifdef UNIV_SYNC_DEBUG
 	/* Currently, the parser is not reentrant: */
-
 	ut_ad(mutex_own(&(dict_sys->mutex)));
-	
+#endif /* UNIV_SYNC_DEBUG */
 	pars_sym_tab_global = sym_tab_create(heap);
 
 	len = ut_strlen(str);
@@ -1996,7 +1780,7 @@ pars_sql(
 
 	graph->sym_tab = pars_sym_tab_global;
 
-	/* printf("SQL graph size %lu\n", mem_heap_get_size(heap)); */
+	/* fprintf(stderr, "SQL graph size %lu\n", mem_heap_get_size(heap)); */
 
 	return(graph);
 }
diff --git a/innobase/que/que0que.c b/innobase/que/que0que.c
index 40483988c12..127e7f84576 100644
--- a/innobase/que/que0que.c
+++ b/innobase/que/que0que.c
@@ -25,7 +25,6 @@ Created 5/27/1996 Heikki Tuuri
 #include "log0log.h"
 #include "eval0proc.h"
 #include "eval0eval.h"
-#include "odbc0odbc.h"
 
 #define QUE_PARALLELIZE_LIMIT	(64 * 256 * 256 * 256)
 #define QUE_ROUND_ROBIN_LIMIT	(64 * 256 * 256 * 256)
@@ -83,7 +82,9 @@ que_graph_publish(
 	que_t*	graph,	/* in: graph */
 	sess_t*	sess)	/* in: session */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	UT_LIST_ADD_LAST(graphs, sess->graphs, graph);
 }
@@ -190,7 +191,9 @@ que_thr_end_wait(
 {
 	ibool	was_active;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(thr);
 	ut_ad((thr->state == QUE_THR_LOCK_WAIT)
 	      || (thr->state == QUE_THR_PROCEDURE_WAIT)
@@ -229,7 +232,9 @@ que_thr_end_wait_no_next_thr(
 
 	ut_a(thr->state == QUE_THR_LOCK_WAIT);	/* In MySQL this is the
 						only possible state here */
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(thr);
 	ut_ad((thr->state == QUE_THR_LOCK_WAIT)
 	      || (thr->state == QUE_THR_PROCEDURE_WAIT)
@@ -279,15 +284,9 @@ que_fork_start_command(
 				QUE_THR_RUNNING state, or NULL; the query
 				thread should be executed by que_run_threads
 				by the caller */
-	que_fork_t* 	fork,	/* in: a query fork */
-	ulint		command,/* in: command SESS_COMM_FETCH_NEXT, ... */
-	ulint		param)	/* in: possible parameter to the command */
+	que_fork_t* 	fork)	/* in: a query fork */
 {
 	que_thr_t*	thr;
-	
-	/* Set the command parameters in the fork root */
-	fork->command = command;
-	fork->param = param;	
 
 	fork->state = QUE_FORK_ACTIVE;
 	
@@ -370,7 +369,9 @@ que_fork_error_handle(
 {
 	que_thr_t*	thr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(trx->sess->state == SESS_ERROR);
 	ut_ad(UT_LIST_GET_LEN(trx->reply_signals) == 0);
 	ut_ad(UT_LIST_GET_LEN(trx->wait_thrs) == 0);
@@ -484,7 +485,7 @@ que_graph_free_recursive(
 		"que_thr struct appears corrupt; magic n %lu\n",
 				(unsigned long) thr->magic_n);
 			mem_analyze_corruption((byte*)thr);
-			ut_a(0);
+			ut_error;
 		}
 
 		thr->magic_n = QUE_THR_MAGIC_FREED;
@@ -596,7 +597,7 @@ que_graph_free_recursive(
 		"que_node struct appears corrupt; type %lu\n",
 			(unsigned long) que_node_get_type(node));
 		mem_analyze_corruption((byte*)node);
-		ut_a(0);
+		ut_error;
 	}
 }
 
@@ -640,7 +641,9 @@ que_graph_try_free(
 {
 	sess_t*	sess;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	sess = (graph->trx)->sess;
 	
@@ -665,50 +668,21 @@ does nothing! */
 void
 que_thr_handle_error(
 /*=================*/
-	que_thr_t*	thr,	/* in: query thread */
-	ulint		err_no,	/* in: error number */
-	byte*		err_str,/* in, own: error string or NULL; NOTE: the
+	que_thr_t*	thr __attribute((unused)),
+				/* in: query thread */
+	ulint		err_no __attribute((unused)),
+				/* in: error number */
+	byte*		err_str __attribute((unused)),
+				/* in, own: error string or NULL; NOTE: the
 				function will take care of freeing of the
 				string! */
-	ulint		err_len)/* in: error string length */	
+	ulint		err_len __attribute((unused)))
+				/* in: error string length */	
 {
-	UT_NOT_USED(thr);
-	UT_NOT_USED(err_no);
-	UT_NOT_USED(err_str);
-	UT_NOT_USED(err_len);
-	
 	/* Does nothing */
 }
 
 /********************************************************************
-Builds a command completed-message to the client. */
-static
-ulint
-que_build_srv_msg(
-/*==============*/
-				/* out: message data length */
-	byte*		buf,	/* in: message buffer */
-	que_fork_t*	fork,	/* in: query graph where execution completed */
-	sess_t*		sess)	/* in: session */
-{
-	ulint	len;
-	
-	/* Currently, we only support stored procedures: */
-	ut_ad(fork->fork_type == QUE_FORK_PROCEDURE);
-
-	if (sess->state == SESS_ERROR) {
-
-		return(0);
-	}
-
-  	sess_srv_msg_init(sess, buf, SESS_SRV_SUCCESS);
-
-	len = pars_proc_write_output_params_to_buf(buf + SESS_SRV_MSG_DATA,
-									fork);
-	return(len);
-}
-
-/********************************************************************
 Performs an execution step on a thr node. */
 static
 que_thr_t*
@@ -804,10 +778,6 @@ que_thr_dec_refer_count(
 	que_fork_t*	fork;
 	trx_t*		trx;
 	sess_t*		sess;
-	ibool		send_srv_msg		= FALSE;
-	ibool		release_stored_proc	= FALSE;
-	ulint		msg_len			= 0;
-	byte		msg_buf[ODBC_DATAGRAM_SIZE];
 	ulint		fork_type;
 	ibool		stopped;
 	
@@ -828,8 +798,8 @@ que_thr_dec_refer_count(
 			already canceled before we came here: continue
 			running the thread */
 
-			/* printf(
-			"!!!!!!!!!! Wait already ended: continue thr\n"); */
+			/* fputs("!!!!!!!! Wait already ended: continue thr\n",
+				stderr); */
 
 			if (next_thr && *next_thr == NULL) {
 				*next_thr = thr;
@@ -882,40 +852,13 @@ que_thr_dec_refer_count(
 		} else if (fork_type == QUE_FORK_MYSQL_INTERFACE) {
 
 			/* Do nothing */
-		} else if (fork->common.parent == NULL
-				&& fork->caller == NULL
-			 	&& UT_LIST_GET_LEN(trx->signals) == 0) {
-
-			ut_a(0);	/* not used in MySQL */
-
-			/* Reply to the client */ 
-	
-			/* que_thr_add_update_info(thr); */
-		
-			fork->state = QUE_FORK_COMMAND_WAIT;
-
-			msg_len = que_build_srv_msg(msg_buf, fork, sess);
-
-			send_srv_msg = TRUE;
-
-			if (fork->fork_type == QUE_FORK_PROCEDURE) {
-
-				release_stored_proc = TRUE;
-			}
-
-			ut_ad(trx->graph == fork);
-
-			trx->graph = NULL;
 		} else {
-			/* Subprocedure calls not implemented yet */
-			ut_a(0);
+			ut_error;	/* not used in MySQL */
 		}
 	}
 
 	if (UT_LIST_GET_LEN(trx->signals) > 0 && trx->n_active_thrs == 0) {
 
-		ut_ad(!send_srv_msg);
-
 	    	/* If the trx is signaled and its query thread count drops to
 		zero, then we start processing a signal; from it we may get
 		a new query thread to run */
@@ -929,26 +872,6 @@ que_thr_dec_refer_count(
 	}
 
 	mutex_exit(&kernel_mutex);
-
-	if (send_srv_msg) {
-		/* Note that, as we do not own the kernel mutex at this point,
-		and neither do we own it all the time when doing the actual
-		communication operation within the next function, it is
-		possible that the messages will not get delivered in the right
-		sequential order. This is possible if the client communicates
-		an extra message to the server while the message below is still
-		undelivered. But then the client should notice that there
-		is an error in the order numbers of the messages. */
-		
-		sess_command_completed_message(sess, msg_buf, msg_len);
-	}
-
-	if (release_stored_proc) {
-
-		/* Return the stored procedure graph to the dictionary cache */
-
-		dict_procedure_release_parsed_copy(fork);
-	}
 }
 
 /**************************************************************************
@@ -966,7 +889,9 @@ que_thr_stop(
 	que_t*	graph;
 	ibool	ret	= TRUE;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	graph = thr->graph;
 	trx = graph->trx;
@@ -1063,7 +988,7 @@ que_thr_move_to_run_state_for_mysql(
 
 		mem_analyze_corruption((byte*)thr);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	if (!thr->is_active) {
@@ -1100,7 +1025,7 @@ que_thr_stop_for_mysql_no_error(
 
 		mem_analyze_corruption((byte*)thr);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	thr->state = QUE_THR_COMPLETED;
@@ -1119,59 +1044,56 @@ que_node_print_info(
 /*================*/
 	que_node_t*	node)	/* in: query graph node */
 {
-	ulint	type;
-	char*	str;
-	ulint	addr;
+	ulint		type;
+	const char*	str;
 
 	type = que_node_get_type(node);
 
-	addr = (ulint)node;
-
 	if (type == QUE_NODE_SELECT) {
-		str = (char *) "SELECT";
+		str = "SELECT";
 	} else if (type == QUE_NODE_INSERT) {
-		str = (char *) "INSERT";
+		str = "INSERT";
 	} else if (type == QUE_NODE_UPDATE) {
-		str = (char *) "UPDATE";
+		str = "UPDATE";
 	} else if (type == QUE_NODE_WHILE) {
-		str = (char *) "WHILE";
+		str = "WHILE";
 	} else if (type == QUE_NODE_ASSIGNMENT) {
-		str = (char *) "ASSIGNMENT";
+		str = "ASSIGNMENT";
 	} else if (type == QUE_NODE_IF) {
-		str = (char *) "IF";
+		str = "IF";
 	} else if (type == QUE_NODE_FETCH) {
-		str = (char *) "FETCH";
+		str = "FETCH";
 	} else if (type == QUE_NODE_OPEN) {
-		str = (char *) "OPEN";
+		str = "OPEN";
 	} else if (type == QUE_NODE_PROC) {
-		str = (char *) "STORED PROCEDURE";
+		str = "STORED PROCEDURE";
 	} else if (type == QUE_NODE_FUNC) {
-		str = (char *) "FUNCTION";
+		str = "FUNCTION";
 	} else if (type == QUE_NODE_LOCK) {
-		str = (char *) "LOCK";
+		str = "LOCK";
 	} else if (type == QUE_NODE_THR) {
-		str = (char *) "QUERY THREAD";
+		str = "QUERY THREAD";
 	} else if (type == QUE_NODE_COMMIT) {
-		str = (char *) "COMMIT";
+		str = "COMMIT";
 	} else if (type == QUE_NODE_UNDO) {
-		str = (char *) "UNDO ROW";
+		str = "UNDO ROW";
 	} else if (type == QUE_NODE_PURGE) {
-		str = (char *) "PURGE ROW";
+		str = "PURGE ROW";
 	} else if (type == QUE_NODE_ROLLBACK) {
-		str = (char *) "ROLLBACK";
+		str = "ROLLBACK";
 	} else if (type == QUE_NODE_CREATE_TABLE) {
-		str = (char *) "CREATE TABLE";
+		str = "CREATE TABLE";
 	} else if (type == QUE_NODE_CREATE_INDEX) {
-		str = (char *) "CREATE INDEX";
+		str = "CREATE INDEX";
 	} else if (type == QUE_NODE_FOR) {
-		str = (char *) "FOR LOOP";
+		str = "FOR LOOP";
 	} else if (type == QUE_NODE_RETURN) {
-		str = (char *) "RETURN";
+		str = "RETURN";
 	} else {
-		str = (char *) "UNKNOWN NODE TYPE";
+		str = "UNKNOWN NODE TYPE";
 	}
 
-	printf("Node type %lu: %s, address %lx\n", (unsigned long) type, str,
+	fprintf(stderr, "Node type %lu: %s, address %lx\n", (unsigned long) type, str,
 	       (unsigned long) addr);
 }
 
@@ -1202,7 +1124,7 @@ que_thr_step(
 	
 #ifdef UNIV_DEBUG
 	if (que_trace_on) {
-		printf("To execute: ");
+		fputs("To execute: ", stderr);
 		que_node_print_info(node);
 	}
 #endif
@@ -1299,7 +1221,9 @@ que_run_threads(
 	ulint		loop_count;
 	
 	ut_ad(thr->state == QUE_THR_RUNNING);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* cumul_resource counts how much resources the OS thread (NOT the
 	query thread) has spent in this function */
diff --git a/innobase/read/read0read.c b/innobase/read/read0read.c
index 4a8aaee39ca..889612deef4 100644
--- a/innobase/read/read0read.c
+++ b/innobase/read/read0read.c
@@ -54,9 +54,10 @@ read_view_oldest_copy_or_open_new(
 	ulint		insert_done	= 0;
 	ulint		n;
 	ulint		i;
-	
-	ut_ad(mutex_own(&kernel_mutex));
 
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	old_view = UT_LIST_GET_LAST(trx_sys->view_list);
 
 	if (old_view == NULL) {
@@ -132,9 +133,9 @@ read_view_open_now(
 	read_view_t*	view;
 	trx_t*		trx;
 	ulint		n;
-
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
-
+#endif /* UNIV_SYNC_DEBUG */
 	view = read_view_create_low(UT_LIST_GET_LEN(trx_sys->trx_list), heap);
 
 	view->creator = cr_trx;
@@ -195,8 +196,9 @@ read_view_close(
 /*============*/
 	read_view_t*	view)	/* in: read view */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
-
+#endif /* UNIV_SYNC_DEBUG */
 	UT_LIST_REMOVE(view_list, trx_sys->view_list, view);
 } 
 
diff --git a/innobase/rem/rem0cmp.c b/innobase/rem/rem0cmp.c
index fb8732f35be..254ebeec8c9 100644
--- a/innobase/rem/rem0cmp.c
+++ b/innobase/rem/rem0cmp.c
@@ -283,7 +283,7 @@ cmp_whole_field(
 	        fprintf(stderr,
 			"InnoDB: unknown type number %lu\n",
 			(ulong) data_type);
-	        ut_a(0);
+	        ut_error;
 	}
 
 	return(0);
diff --git a/innobase/rem/rem0rec.c b/innobase/rem/rem0rec.c
index 5a3996c9dce..3d0b997db85 100644
--- a/innobase/rem/rem0rec.c
+++ b/innobase/rem/rem0rec.c
@@ -108,12 +108,12 @@ rec_get_nth_field(
 	if (n > 1024) {
 		fprintf(stderr, "Error: trying to access field %lu in rec\n",
 								(ulong) n);
-		ut_a(0);
+		ut_error;
 	}
 
 	if (rec == NULL) {
 		fprintf(stderr, "Error: rec is NULL pointer\n");
-		ut_a(0);
+		ut_error;
 	}
 	
 	if (rec_get_1byte_offs_flag(rec)) {
diff --git a/innobase/row/row0ins.c b/innobase/row/row0ins.c
index 5fef07683af..fc1f7a19d53 100644
--- a/innobase/row/row0ins.c
+++ b/innobase/row/row0ins.c
@@ -80,9 +80,9 @@ ins_node_create(
 	node->trx_id = ut_dulint_zero;
 	
 	node->entry_sys_heap = mem_heap_create(128);
-
-	node->magic_n = INS_NODE_MAGIC_N;	
-	
+#ifdef UNIV_DEBUG
+	node->magic_n = INS_NODE_MAGIC_N;
+#endif /* UNIV_DEBUG */
 	return(node);
 }
 
@@ -194,6 +194,7 @@ ins_node_set_new_row(
 	ins_node_t*	node,	/* in: insert node */
 	dtuple_t*	row)	/* in: new row (or first row) for the node */
 {
+	ut_ad(node->magic_n == INS_NODE_MAGIC_N);
 	node->state = INS_NODE_SET_IX_LOCK;
 	node->index = NULL;
 	node->entry = NULL;
@@ -855,7 +856,7 @@ row_ins_foreign_check_on_constraint(
 			"InnoDB: Make a detailed bug report and send it\n");
 	  	fprintf(stderr, "InnoDB: to mysql@lists.mysql.com\n");
 
-		ut_a(0);
+		ut_error;
 */
 		err = DB_SUCCESS;		
 
@@ -1031,8 +1032,10 @@ row_ins_check_foreign_constraint(
 	mtr_t		mtr;
 
 run_again:
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_SHARED));
-	
+#endif /* UNIV_SYNC_DEBUG */
+
 	err = DB_SUCCESS;
 
 	if (thr_get_trx(thr)->check_foreigns == FALSE) {
@@ -2040,6 +2043,7 @@ row_ins(
 	ulint	err;
 	
 	ut_ad(node && thr);
+	ut_ad(node->magic_n == INS_NODE_MAGIC_N);
 
 	if (node->state == INS_NODE_ALLOC_ROW_ID) {
 
@@ -2104,7 +2108,7 @@ row_ins_step(
 	trx_start_if_not_started(trx);
 	
 	node = thr->run_node;
-
+	ut_ad(node->magic_n == INS_NODE_MAGIC_N);
 	ut_ad(que_node_get_type(node) == QUE_NODE_INSERT);
 
 	parent = que_node_get_parent(node);
diff --git a/innobase/row/row0mysql.c b/innobase/row/row0mysql.c
index 626382398b7..efcca623a76 100644
--- a/innobase/row/row0mysql.c
+++ b/innobase/row/row0mysql.c
@@ -287,7 +287,7 @@ handle_new_error:
 	} else {
 		fprintf(stderr, "InnoDB: unknown error code %lu\n",
 			(ulong) err);
-		ut_a(0);
+		ut_error;
 	}		
 
 	if (trx->error_state != DB_SUCCESS) {
@@ -402,7 +402,7 @@ row_prebuilt_free(
 
 		mem_analyze_corruption((byte*)prebuilt);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	prebuilt->magic_n = ROW_PREBUILT_FREED;
@@ -450,7 +450,7 @@ row_prebuilt_free(
 				mem_analyze_corruption(
 						prebuilt->fetch_cache[i]);
 
-				ut_a(0);
+				ut_error;
 			}
 
 			mem_free((prebuilt->fetch_cache[i]) - 4);
@@ -482,7 +482,7 @@ row_update_prebuilt_trx(
 
 		mem_analyze_corruption((byte*)trx);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	if (prebuilt->magic_n != ROW_PREBUILT_ALLOCATED) {
@@ -493,7 +493,7 @@ row_update_prebuilt_trx(
 
 		mem_analyze_corruption((byte*)prebuilt);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	prebuilt->trx = trx;
@@ -720,7 +720,7 @@ row_insert_for_mysql(
 
 		mem_analyze_corruption((byte*)prebuilt);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	if (srv_created_new_raw || srv_force_recovery) {
@@ -936,7 +936,7 @@ row_update_for_mysql(
 
 		mem_analyze_corruption((byte*)prebuilt);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	if (srv_created_new_raw || srv_force_recovery) {
@@ -1289,9 +1289,11 @@ row_create_table_for_mysql(
 	ulint		err;
 
 	ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX));
-	ut_ad(trx->dict_operation_lock_mode == RW_X_LATCH);
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
+	ut_ad(trx->dict_operation_lock_mode == RW_X_LATCH);
 	
 	if (srv_created_new_raw) {
 		fprintf(stderr,
@@ -1424,8 +1426,7 @@ row_create_table_for_mysql(
 
 	thr = pars_complete_graph_for_exec(node, trx, heap);
 
-	ut_a(thr == que_fork_start_command(que_node_get_parent(thr),
-						SESS_COMM_EXECUTE, 0));
+	ut_a(thr == que_fork_start_command(que_node_get_parent(thr)));
 	que_run_threads(thr);
 
 	err = trx->error_state;
@@ -1496,8 +1497,10 @@ row_create_index_for_mysql(
 	ulint		err;
 	ulint		i, j;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX));
 	ut_ad(mutex_own(&(dict_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
 	
 	trx->op_info = (char *) "creating index";
@@ -1552,8 +1555,7 @@ row_create_index_for_mysql(
 
 	thr = pars_complete_graph_for_exec(node, trx, heap);
 
-	ut_a(thr == que_fork_start_command(que_node_get_parent(thr),
-						SESS_COMM_EXECUTE, 0));
+	ut_a(thr == que_fork_start_command(que_node_get_parent(thr)));
 	que_run_threads(thr);
 
  	err = trx->error_state;
@@ -1604,8 +1606,10 @@ row_table_add_foreign_constraints(
 	ulint	keywordlen;
 	ulint	err;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
 	ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_a(sql_string);
 	
 	trx->op_info = (char *) "adding foreign keys";
@@ -1776,7 +1780,9 @@ row_get_background_drop_list_len_low(void)
 /*======================================*/
 					/* out: how many tables in list */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (!row_mysql_drop_list_inited) {
 
@@ -2255,8 +2261,10 @@ row_drop_table_for_mysql(
 		locked_dictionary = TRUE;
 	}
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
 	ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	graph = pars_sql(buf);
 
@@ -2356,7 +2364,7 @@ row_drop_table_for_mysql(
 	trx->dict_operation = TRUE;
 	trx->table_id = table->id;
 
-	ut_a(thr = que_fork_start_command(graph, SESS_COMM_EXECUTE, 0));
+	ut_a(thr = que_fork_start_command(graph));
 
 	que_run_threads(thr);
 
@@ -2369,7 +2377,7 @@ row_drop_table_for_mysql(
 		
 		row_mysql_handle_errors(&err, trx, thr, NULL);
 
-		ut_a(0);
+		ut_error;
 	} else {
 		space_id = table->space;
 		dict_table_remove_from_cache(table);
@@ -2786,7 +2794,7 @@ row_rename_table_for_mysql(
 
 	graph->fork_type = QUE_FORK_MYSQL_INTERFACE;
 
-	ut_a(thr = que_fork_start_command(graph, SESS_COMM_EXECUTE, 0));
+	ut_a(thr = que_fork_start_command(graph));
 
 	que_run_threads(thr);
 
diff --git a/innobase/row/row0purge.c b/innobase/row/row0purge.c
index d5895f20461..a409b64f8e4 100644
--- a/innobase/row/row0purge.c
+++ b/innobase/row/row0purge.c
@@ -140,7 +140,7 @@ row_purge_remove_clust_if_poss_low(
 		} else if (err == DB_OUT_OF_FILE_SPACE) {
 			success = FALSE;
 		} else {
-			ut_a(0);
+			ut_error;
 		}
 	}
 
@@ -266,7 +266,7 @@ row_purge_remove_sec_if_poss_low(
 			} else if (err == DB_OUT_OF_FILE_SPACE) {
 				success = FALSE;
 			} else {
-				ut_a(0);
+				ut_error;
 			}
 		}
 	}
@@ -447,8 +447,10 @@ skip_secondaries:
 			data_field = buf_page_get(0, page_no, RW_X_LATCH, &mtr)
 				     + offset + internal_offset;
 
+#ifdef UNIV_SYNC_DEBUG
 			buf_page_dbg_add_level(buf_frame_align(data_field),
 						SYNC_TRX_UNDO_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 				     
 			data_field_len = ufield->new_val.len;
 
diff --git a/innobase/row/row0row.c b/innobase/row/row0row.c
index b5d676a936a..6820cb5bccd 100644
--- a/innobase/row/row0row.c
+++ b/innobase/row/row0row.c
@@ -406,7 +406,7 @@ row_build_row_ref_in_tuple(
 	if (!table) {
 		fprintf(stderr, "InnoDB: table %s for index %s not found\n",
 				index->table_name, index->name);
-		ut_a(0);
+		ut_error;
 	}
 	
 	clust_index = dict_table_get_first_index(table);
@@ -415,7 +415,7 @@ row_build_row_ref_in_tuple(
 		fprintf(stderr,
                 "InnoDB: clust index for table %s for index %s not found\n",
 				index->table_name, index->name);
-		ut_a(0);
+		ut_error;
 	}
 	
 	ref_len = dict_index_get_n_unique(clust_index);
diff --git a/innobase/row/row0sel.c b/innobase/row/row0sel.c
index b32f0b204b3..4f70cea2058 100644
--- a/innobase/row/row0sel.c
+++ b/innobase/row/row0sel.c
@@ -930,7 +930,9 @@ row_sel_try_search_shortcut(
 	ut_ad(node->read_view);
 	ut_ad(plan->unique_search);
 	ut_ad(!plan->must_get_clust);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	row_sel_open_pcur(node, plan, TRUE, mtr);
 
@@ -2080,7 +2082,7 @@ row_sel_store_row_id_to_prebuilt(
 		      (ulong) len, index->table_name, index->name,
 		      (ulong) dict_index_get_sys_col_pos(index, DATA_ROW_ID),
 		      err_buf);
-		ut_a(0);
+		ut_error;
 	}
 
 	ut_memcpy(prebuilt->row_id, data, len);
@@ -2770,7 +2772,7 @@ row_search_for_mysql(
 
 		mem_analyze_corruption((byte*)prebuilt);
 
-		ut_a(0);
+		ut_error;
 	}
 
 	if (trx->n_mysql_tables_in_use == 0) {
@@ -2831,7 +2833,7 @@ row_search_for_mysql(
 
 		if (direction != prebuilt->fetch_direction) {
 			if (prebuilt->n_fetch_cached > 0) {
-				ut_a(0);
+				ut_error;
 				/* TODO: scrollable cursor: restore cursor to
 				the place of the latest returned row,
 				or better: prevent caching for a scroll
diff --git a/innobase/row/row0undo.c b/innobase/row/row0undo.c
index f223bb5eed5..613d0a3b890 100644
--- a/innobase/row/row0undo.c
+++ b/innobase/row/row0undo.c
@@ -334,7 +334,7 @@ row_undo_step(
 			exit(1);			
 		}
 		
-		ut_a(0);
+		ut_error;
 
 		return(NULL);
 	}
diff --git a/innobase/row/row0upd.c b/innobase/row/row0upd.c
index b9e9b8c15c9..f8739b65c2f 100644
--- a/innobase/row/row0upd.c
+++ b/innobase/row/row0upd.c
@@ -77,8 +77,8 @@ index record. This is only used in foreign key checks and we can assume
 that index does not contain column prefixes. */
 static
 ibool
-row_upd_changes_first_fields(
-/*=========================*/
+row_upd_changes_first_fields_binary(
+/*================================*/
 				/* out: TRUE if changes */
 	dtuple_t*	entry,	/* in: old value of index entry */
 	dict_index_t*	index,	/* in: index of entry */
@@ -196,7 +196,7 @@ row_upd_check_references_constraints(
 
 		if (foreign->referenced_index == index
 		    && (node->is_delete
-		       || row_upd_changes_first_fields(entry, index,
+		       || row_upd_changes_first_fields_binary(entry, index,
 			    		node->update, foreign->n_fields))) {
 			    				
 			if (foreign->foreign_table == NULL) {
@@ -287,7 +287,9 @@ upd_node_create(
 	node->select = NULL;
 	
 	node->heap = mem_heap_create(128);
-	node->magic_n = UPD_NODE_MAGIC_N;	
+#ifdef UNIV_DEBUG
+	node->magic_n = UPD_NODE_MAGIC_N;
+#endif /* UNIV_DEBUG */
 
 	node->cmpl_info = 0;
 	
@@ -1048,8 +1050,8 @@ index record. This is only used in foreign key checks and we can assume
 that index does not contain column prefixes. */
 static
 ibool
-row_upd_changes_first_fields(
-/*=========================*/
+row_upd_changes_first_fields_binary(
+/*================================*/
 				/* out: TRUE if changes */
 	dtuple_t*	entry,	/* in: index entry */
 	dict_index_t*	index,	/* in: index of entry */
@@ -1074,15 +1076,16 @@ row_upd_changes_first_fields(
 		col = dict_field_get_col(ind_field);
 		col_pos = dict_col_get_clust_pos(col);
 
+		ut_a(ind_field->prefix_len == 0);
+
 		for (j = 0; j < n_upd_fields; j++) {
 
 			upd_field = upd_get_nth_field(update, j);
 
 			if (col_pos == upd_field->field_no
-			    && (ind_field->prefix_len > 0
-			        || 0 != cmp_dfield_dfield(
+			    && !dfield_datas_are_binary_equal(
 					     dtuple_get_nth_field(entry, i),
-					     &(upd_field->new_val)))) {
+					     &(upd_field->new_val))) {
 				return(TRUE);
 			}
 		}
@@ -1804,6 +1807,7 @@ row_upd_step(
 	trx_start_if_not_started(trx);
 
 	node = thr->run_node;
+	ut_ad(node->magic_n == UPD_NODE_MAGIC_N);
 	
 	sel_node = node->select;
 
@@ -1923,6 +1927,7 @@ row_upd_in_place_in_select(
 
 	node = que_node_get_parent(sel_node);
 
+	ut_ad(node->magic_n == UPD_NODE_MAGIC_N);
 	ut_ad(que_node_get_type(node) == QUE_NODE_UPDATE);
 
 	pcur = node->pcur;
diff --git a/innobase/row/row0vers.c b/innobase/row/row0vers.c
index fca56389e45..bc17ede89e3 100644
--- a/innobase/row/row0vers.c
+++ b/innobase/row/row0vers.c
@@ -60,8 +60,10 @@ row_vers_impl_x_locked_off_kernel(
 	ulint		err;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
 	ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mutex_exit(&kernel_mutex);
 
@@ -254,7 +256,9 @@ row_vers_must_preserve_del_marked(
 	mtr_t*	mtr)	/* in: mtr holding the latch on the clustered index
 			record; it will also hold the latch on purge_view */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mtr_s_lock(&(purge_sys->latch), mtr);
 
@@ -302,7 +306,9 @@ row_vers_old_has_index_entry(
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(rec), MTR_MEMO_PAGE_X_FIX)
 	   	|| mtr_memo_contains(mtr, buf_block_align(rec),
 						MTR_MEMO_PAGE_S_FIX));
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
+#endif /* UNIV_SYNC_DEBUG */
 	mtr_s_lock(&(purge_sys->latch), mtr);
 
 	clust_index = dict_table_get_first_index(index->table);
@@ -411,7 +417,9 @@ row_vers_build_for_consistent_read(
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(rec), MTR_MEMO_PAGE_X_FIX)
 	   	|| mtr_memo_contains(mtr, buf_block_align(rec),
 						MTR_MEMO_PAGE_S_FIX));
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(!read_view_sees_trx_id(view, row_get_rec_trx_id(rec, index)));
 
 	rw_lock_s_lock(&(purge_sys->latch));
diff --git a/innobase/srv/srv0que.c b/innobase/srv/srv0que.c
index 4d36adfefa4..ac8bd7d0e65 100644
--- a/innobase/srv/srv0que.c
+++ b/innobase/srv/srv0que.c
@@ -83,7 +83,9 @@ srv_que_task_enqueue_low(
 {
 	ut_ad(thr);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	UT_LIST_ADD_LAST(queue, srv_sys->tasks, thr);
 
diff --git a/innobase/srv/srv0srv.c b/innobase/srv/srv0srv.c
index e9ea4155e0d..838e63b3e25 100644
--- a/innobase/srv/srv0srv.c
+++ b/innobase/srv/srv0srv.c
@@ -34,12 +34,9 @@ Created 10/8/1995 Heikki Tuuri
 #include "sync0sync.h"
 #include "sync0ipm.h"
 #include "thr0loc.h"
-#include "com0com.h"
-#include "com0shm.h"
 #include "que0que.h"
 #include "srv0que.h"
 #include "log0recv.h"
-#include "odbc0odbc.h"
 #include "pars0pars.h"
 #include "usr0sess.h"
 #include "lock0lock.h"
@@ -253,9 +250,6 @@ ibool	srv_use_adaptive_hash_indexes 	= TRUE;
 ulint	srv_n_spin_wait_rounds	= 20;
 ulint	srv_spin_wait_delay	= 5;
 ibool	srv_priority_boost	= TRUE;
-char	srv_endpoint_name[COM_MAX_ADDR_LEN];
-ulint	srv_n_com_threads	= ULINT_MAX;
-ulint	srv_n_worker_threads	= ULINT_MAX;
 
 ibool	srv_print_thread_releases	= FALSE;
 ibool	srv_print_lock_waits		= FALSE;
@@ -263,14 +257,14 @@ ibool	srv_print_buf_io		= FALSE;
 ibool	srv_print_log_io		= FALSE;
 ibool	srv_print_latch_waits		= FALSE;
 
-ulint	srv_n_rows_inserted		= 0;
-ulint	srv_n_rows_updated		= 0;
-ulint	srv_n_rows_deleted		= 0;
-ulint	srv_n_rows_read			= 0;
-ulint	srv_n_rows_inserted_old		= 0;
-ulint	srv_n_rows_updated_old		= 0;
-ulint	srv_n_rows_deleted_old		= 0;
-ulint	srv_n_rows_read_old		= 0;
+ulint		srv_n_rows_inserted		= 0;
+ulint		srv_n_rows_updated		= 0;
+ulint		srv_n_rows_deleted		= 0;
+ulint		srv_n_rows_read			= 0;
+static ulint	srv_n_rows_inserted_old		= 0;
+static ulint	srv_n_rows_updated_old		= 0;
+static ulint	srv_n_rows_deleted_old		= 0;
+static ulint	srv_n_rows_read_old		= 0;
 
 /*
   Set the following to 0 if you want InnoDB to write messages on
@@ -630,7 +624,9 @@ srv_suspend_thread(void)
 	ulint		slot_no;
 	ulint		type;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	slot_no = thr_local_get_slot_no(os_thread_get_curr_id());
 
@@ -681,7 +677,9 @@ srv_release_threads(
 	ut_ad(type >= SRV_WORKER);
 	ut_ad(type <= SRV_MASTER);
 	ut_ad(n > 0);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	for (i = 0; i < OS_THREAD_MAX_N; i++) {
 	
@@ -1185,7 +1183,9 @@ srv_table_reserve_slot_for_mysql(void)
 	srv_slot_t*	slot;
 	ulint		i;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	i = 0;
 	slot = srv_mysql_table + i;
@@ -1215,7 +1215,7 @@ srv_table_reserve_slot_for_mysql(void)
 			  (ulong) difftime(ut_time(), slot->suspend_time));
 			}
 
-		        ut_a(0);
+		        ut_error;
 		}
 		
 		slot = srv_mysql_table + i;
@@ -1250,7 +1250,9 @@ srv_suspend_mysql_thread(
 	ibool		had_dict_lock			= FALSE;
 	ibool		was_declared_inside_innodb	= FALSE;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	trx = thr_get_trx(thr);
 	
@@ -1369,7 +1371,9 @@ srv_release_mysql_thread_if_suspended(
 	srv_slot_t*	slot;
 	ulint		i;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	for (i = 0; i < OS_THREAD_MAX_N; i++) {
 
@@ -1465,6 +1469,13 @@ srv_sprintf_innodb_monitor(
 	buf = buf + strlen(buf);
 	ut_a(buf < buf_end + 1500);
 
+	/* Conceptually, srv_innodb_monitor_mutex has a very high latching
+	order level in sync0sync.h, while dict_foreign_err_mutex has a very
+	low level 135. Therefore we can reserve the latter mutex here without
+	a danger of a deadlock of threads. */
+
+	mutex_enter(&dict_foreign_err_mutex);
+
 	if (*dict_foreign_err_buf != '\0') {
 		buf += sprintf(buf,
 			"------------------------\n"
@@ -1476,18 +1487,7 @@ srv_sprintf_innodb_monitor(
 		}
 	}	
 
-	ut_a(buf < buf_end + 1500);
-
-	if (*dict_unique_err_buf != '\0') {
-		buf += sprintf(buf,
-"---------------------------------------------------------------\n"
-"LATEST UNIQUE KEY ERROR (is masked in REPLACE or INSERT IGNORE)\n"
-"---------------------------------------------------------------\n");
-
-		if (buf_end - buf > 6000) {
-			buf+= sprintf(buf, "%.4000s", dict_unique_err_buf);
-		}
-	}	
+	mutex_exit(&dict_foreign_err_mutex);
 
 	ut_a(buf < buf_end + 1500);
 
diff --git a/innobase/srv/srv0start.c b/innobase/srv/srv0start.c
index 6335b857b09..7b50877709b 100644
--- a/innobase/srv/srv0start.c
+++ b/innobase/srv/srv0start.c
@@ -40,7 +40,6 @@ Created 2/16/1996 Heikki Tuuri
 #include "rem0rec.h"
 #include "srv0srv.h"
 #include "que0que.h"
-#include "com0com.h"
 #include "usr0sess.h"
 #include "lock0lock.h"
 #include "trx0roll.h"
@@ -1300,8 +1299,6 @@ NetWare. */
 		mutex_exit(&(log_sys->mutex));
 	}
 
-	sess_sys_init_at_db_start();
-
 	if (create_new_db) {
 		mtr_start(&mtr);
 
diff --git a/innobase/sync/sync0arr.c b/innobase/sync/sync0arr.c
index 9bcee34a7d1..8082f598b0c 100644
--- a/innobase/sync/sync0arr.c
+++ b/innobase/sync/sync0arr.c
@@ -14,6 +14,7 @@ Created 9/5/1995 Heikki Tuuri
 #include "sync0sync.h"
 #include "sync0rw.h"
 #include "os0sync.h"
+#include "os0file.h"
 #include "srv0srv.h"
 
 /*
@@ -99,6 +100,7 @@ struct sync_array_struct {
 					since creation of the array */
 };
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 This function is called only in the debug version. Detects a deadlock
 of one or more threads because of waits of semaphores. */
@@ -112,6 +114,7 @@ sync_array_detect_deadlock(
 	sync_cell_t*	start,	/* in: cell where recursive search started */
 	sync_cell_t*	cell,	/* in: cell to search */
 	ulint		depth);	/* in: recursion depth */
+#endif /* UNIV_SYNC_DEBUG */
 
 /*********************************************************************
 Gets the nth cell in array. */
@@ -464,13 +467,17 @@ sync_array_cell_print(
 		mutex = cell->old_wait_mutex;
 
 		buf += sprintf(buf,
-		"Mutex at %lx created file %s line %lu, lock var %lu\n",
-			       (ulong) mutex, mutex->cfile_name,
-			       (ulong) mutex->cline, (ulong) mutex->lock_word);
-		buf += sprintf(buf,
-		"Last time reserved in file %s line %lu, waiters flag %lu\n",
-			       mutex->file_name, (ulong) mutex->line,
-			       (ulong) mutex->waiters);
+			"Mutex at %p created file %s line %lu, lock var %lu\n"
+#ifdef UNIV_SYNC_DEBUG
+			"Last time reserved in file %s line %lu, "
+#endif /* UNIV_SYNC_DEBUG */
+			"waiters flag %lu\n",
+			mutex, mutex->cfile_name, (ulong) mutex->cline,
+			(ulong) mutex->lock_word,
+#ifdef UNIV_SYNC_DEBUG
+			mutex->file_name, (ulong) mutex->line,
+#endif /* UNIV_SYNC_DEBUG */
+			(ulong) mutex->waiters);
 
 	} else if (type == RW_LOCK_EX || type == RW_LOCK_SHARED) {
 
@@ -522,6 +529,7 @@ sync_array_cell_print(
 	}
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Looks for a cell with the given thread id. */
 static
@@ -693,7 +701,6 @@ sync_array_detect_deadlock(
 				sync_array_cell_print(buf, cell);
 				printf("rw-lock %lx %s ", (ulong)  lock, buf);
 				rw_lock_debug_print(debug);
-
 				return(TRUE);
 			}
 		}
@@ -743,6 +750,7 @@ sync_array_detect_deadlock(
 	return(TRUE); 	/* Execution never reaches this line: for compiler
 			fooling only */
 }
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Determines if we can wake up the thread waiting for a sempahore. */
@@ -936,7 +944,7 @@ sync_array_print_long_waits(void)
 "InnoDB: We intentionally crash the server, because it appears to be hung.\n"
 		    	);
 
-		    	ut_a(0);
+		    	ut_error;
                 }
        	}
 
@@ -945,6 +953,16 @@ sync_array_print_long_waits(void)
 "InnoDB: ###### Starts InnoDB Monitor for 30 secs to print diagnostic info:\n");
         	old_val = srv_print_innodb_monitor;
 
+		/* If some crucial semaphore is reserved, then also the InnoDB
+		Monitor can hang, and we do not get diagnostics. Since in
+		many cases an InnoDB hang is caused by a pwrite() or a pread()
+		call hanging inside the operating system, let us print right
+		now the values of pending calls of these. */
+
+		fprintf(stderr,
+"InnoDB: Pending preads %lu, pwrites %lu\n", (ulong)os_file_n_pending_preads,
+				(ulong)os_file_n_pending_pwrites);
+
         	srv_print_innodb_monitor = TRUE;
 		os_event_set(srv_lock_timeout_thread_event);
 
diff --git a/innobase/sync/sync0rw.c b/innobase/sync/sync0rw.c
index e6da03c53fa..93fd9f14575 100644
--- a/innobase/sync/sync0rw.c
+++ b/innobase/sync/sync0rw.c
@@ -31,6 +31,7 @@ ulint	rw_x_exit_count		= 0;
 rw_lock_list_t	rw_lock_list;
 mutex_t		rw_lock_list_mutex;
 
+#ifdef UNIV_SYNC_DEBUG
 /* The global mutex which protects debug info lists of all rw-locks.
 To modify the debug info list of an rw-lock, this mutex has to be
 acquired in addition to the mutex protecting the lock. */
@@ -76,6 +77,7 @@ rw_lock_debug_free(
 {
 	mem_free(info);
 }
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Creates, or rather, initializes an rw-lock object in a specified memory
@@ -107,10 +109,12 @@ rw_lock_create_func(
 
 	lock->writer_is_wait_ex = FALSE;
 
+#ifdef UNIV_SYNC_DEBUG
 	UT_LIST_INIT(lock->debug_list);
 
-	lock->magic_n = RW_LOCK_MAGIC_N;
 	lock->level = SYNC_LEVEL_NONE;
+#endif /* UNIV_SYNC_DEBUG */
+	lock->magic_n = RW_LOCK_MAGIC_N;
 	
 	lock->cfile_name = cfile_name;
 	lock->cline = cline;
@@ -319,8 +323,9 @@ rw_lock_x_lock_low(
 	char*		file_name,/* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(rw_lock_get_mutex(lock)));
-
+#endif /* UNIV_SYNC_DEBUG */
 	if (rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED) {
 
 		if (rw_lock_get_reader_count(lock) == 0) {
@@ -528,6 +533,7 @@ lock_loop:
         goto lock_loop;
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Acquires the debug mutex. We cannot use the mutex defined in sync0sync,
 because the debug mutex is also acquired in sync0arr while holding the OS
@@ -653,6 +659,7 @@ rw_lock_remove_debug_info(
 
 	ut_error;
 }
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Sets the rw-lock latching level field. */
@@ -666,6 +673,7 @@ rw_lock_set_level(
 	lock->level = level;
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Checks if the thread has locked the rw-lock in the specified mode, with
 the pass value == 0. */
@@ -683,9 +691,6 @@ rw_lock_own(
 	ut_ad(lock);
 	ut_ad(rw_lock_validate(lock));
 
-#ifndef UNIV_SYNC_DEBUG
-	ut_error;
-#endif	
 	mutex_enter(&(lock->mutex));
 
 	info = UT_LIST_GET_FIRST(lock->debug_list);
@@ -708,6 +713,7 @@ rw_lock_own(
 
 	return(FALSE);
 }
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Checks if somebody has locked the rw-lock in the specified mode. */
@@ -744,6 +750,7 @@ rw_lock_is_locked(
 	return(ret);
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /*******************************************************************
 Prints debug info of currently locked rw-locks. */
 
@@ -751,8 +758,6 @@ void
 rw_lock_list_print_info(void)
 /*=========================*/
 {
-#ifndef UNIV_SYNC_DEBUG
-#else
 	rw_lock_t*	lock;
 	ulint		count		= 0;
 	rw_lock_debug_t* info;
@@ -796,7 +801,6 @@ rw_lock_list_print_info(void)
 
 	printf("Total number of rw-locks %ld\n", count);
 	mutex_exit(&rw_lock_list_mutex);
-#endif
 }
 
 /*******************************************************************
@@ -807,11 +811,6 @@ rw_lock_print(
 /*==========*/
 	rw_lock_t*	lock __attribute__((unused)))	/* in: rw-lock */
 {
-#ifndef UNIV_SYNC_DEBUG
-	printf(
-	   "Sorry, cannot give rw-lock info in non-debug version!\n");
-#else
-	ulint		count		= 0;
 	rw_lock_debug_t* info;
 	
 	printf("-------------\n");
@@ -834,7 +833,6 @@ rw_lock_print(
 			info = UT_LIST_GET_NEXT(list, info);
 		}
 	}
-#endif
 }
 
 /*************************************************************************
@@ -875,12 +873,6 @@ ulint
 rw_lock_n_locked(void)
 /*==================*/
 {
-#ifndef UNIV_SYNC_DEBUG
-	printf(
-	   "Sorry, cannot give rw-lock info in non-debug version!\n");
-	ut_error;
-	return(0);
-#else
 	rw_lock_t*	lock;
 	ulint		count		= 0;
 	
@@ -903,5 +895,5 @@ rw_lock_n_locked(void)
 	mutex_exit(&rw_lock_list_mutex);
 
 	return(count);
-#endif
 }
+#endif /* UNIV_SYNC_DEBUG */
diff --git a/innobase/sync/sync0sync.c b/innobase/sync/sync0sync.c
index 22e0975dd37..6ad766d8bc8 100644
--- a/innobase/sync/sync0sync.c
+++ b/innobase/sync/sync0sync.c
@@ -188,8 +188,10 @@ mutex_create_func(
 #endif
 	mutex_set_waiters(mutex, 0);
 	mutex->magic_n = MUTEX_MAGIC_N;
+#ifdef UNIV_SYNC_DEBUG
 	mutex->line = 0;
 	mutex->file_name = (char *) "not yet reserved";
+#endif /* UNIV_SYNC_DEBUG */
 	mutex->level = SYNC_LEVEL_NONE;
 	mutex->cfile_name = cfile_name;
 	mutex->cline = cline;
@@ -266,9 +268,11 @@ mutex_enter_nowait(
 /*===============*/
 					/* out: 0 if succeed, 1 if not */
 	mutex_t*	mutex,		/* in: pointer to mutex */
-	char*	   	file_name, 	/* in: file name where mutex
+	char*	   	file_name __attribute__((unused)),
+					/* in: file name where mutex
 					requested */
-	ulint	   	line)		/* in: line where requested */
+	ulint	   	line __attribute__((unused)))
+					/* in: line where requested */
 {
 	ut_ad(mutex_validate(mutex));
 
@@ -277,9 +281,6 @@ mutex_enter_nowait(
 #ifdef UNIV_SYNC_DEBUG
 		mutex_set_debug_info(mutex, file_name, line);
 #endif
-		
-		mutex->file_name = file_name;
-		mutex->line = line;
 
 		return(0);	/* Succeeded! */
 	}
@@ -379,9 +380,6 @@ spin_loop:
 		mutex_set_debug_info(mutex, file_name, line);
 #endif
 
-		mutex->file_name = file_name;
-		mutex->line = line;
-
                 return;
    	}
 
@@ -426,9 +424,6 @@ spin_loop:
 		mutex_set_debug_info(mutex, file_name, line);
 #endif
 
-		mutex->file_name = file_name;
-		mutex->line = line;
-
 		if (srv_print_latch_waits) {
 			printf(
 			"Thread %lu spin wait succeeds at 2: mutex at %lx\n",
@@ -479,6 +474,7 @@ mutex_signal_object(
 	sync_array_signal_object(sync_primary_wait_array, mutex);
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Sets the debug information for a reserved mutex. */
 
@@ -516,7 +512,8 @@ mutex_get_debug_info(
 	*file_name = mutex->file_name;
 	*line	   = mutex->line;
 	*thread_id = mutex->thread_id;
-}	
+}
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Sets the mutex latching level field. */
@@ -530,6 +527,7 @@ mutex_set_level(
 	mutex->level = level;
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Checks that the current thread owns the mutex. Works only in the debug
 version. */
@@ -562,8 +560,6 @@ void
 mutex_list_print_info(void)
 /*=======================*/
 {
-#ifndef UNIV_SYNC_DEBUG
-#else
 	mutex_t*	mutex;
 	char*		file_name;
 	ulint		line;
@@ -596,7 +592,6 @@ mutex_list_print_info(void)
 	printf("Total number of mutexes %ld\n", count);
 	
 	mutex_exit(&mutex_list_mutex);
-#endif
 }
 
 /**********************************************************************
@@ -606,12 +601,6 @@ ulint
 mutex_n_reserved(void)
 /*==================*/
 {
-#ifndef UNIV_SYNC_DEBUG
-	printf("Sorry, cannot give mutex info in non-debug version!\n");
-	ut_error;
-
-	return(0);
-#else
 	mutex_t*	mutex;
 	ulint		count		= 0;
 
@@ -634,7 +623,6 @@ mutex_n_reserved(void)
 
 	return(count - 1); /* Subtract one, because this function itself
 			   was holding one mutex (mutex_list_mutex) */
-#endif
 }
 
 /**********************************************************************
@@ -645,19 +633,9 @@ ibool
 sync_all_freed(void)
 /*================*/
 {
-#ifdef UNIV_SYNC_DEBUG
-	if (mutex_n_reserved() + rw_lock_n_locked() == 0) {
-
-		return(TRUE);
-	} else {
-		return(FALSE);
-	}	
-#else
-	ut_error;
-
-	return(FALSE);
-#endif
+	return(mutex_n_reserved() + rw_lock_n_locked() == 0);
 }
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Gets the value in the nth slot in the thread level arrays. */
@@ -754,9 +732,6 @@ sync_thread_levels_g(
 				thread */
 	ulint		limit)	/* in: level limit */
 {
-	char*		file_name;
-	ulint		line;
-	os_thread_id_t	thread_id;
 	sync_level_t*	slot;
 	rw_lock_t*	lock;
 	mutex_t*	mutex;
@@ -781,18 +756,28 @@ sync_thread_levels_g(
 						(ulong) mutex->cline);
 
 					if (mutex_get_lock_word(mutex) != 0) {
+#ifdef UNIV_SYNC_DEBUG
+						char*		file_name;
+						ulint		line;
+						os_thread_id_t	thread_id;
 
 		    				mutex_get_debug_info(mutex,
 						&file_name, &line, &thread_id);
 
-	printf("InnoDB: Locked mutex: addr %lx thread %ld file %s line %ld\n",
-		    	(ulong) mutex, (ulong) os_thread_pf(thread_id),
-						file_name, (ulong) line);
+						fprintf(stderr,
+		"InnoDB: Locked mutex: addr %p thread %ld file %s line %ld\n",
+		mutex, os_thread_pf(thread_id), file_name, (ulong) line);
+#else /* UNIV_SYNC_DEBUG */
+						fprintf(stderr,
+		"InnoDB: Locked mutex: addr %p\n", mutex);
+#endif /* UNIV_SYNC_DEBUG */
 					} else {
-						printf("Not locked\n");
+						fputs("Not locked\n", stderr);
 					}	
 				} else {
+#ifdef UNIV_SYNC_DEBUG
 					rw_lock_print(lock);
+#endif /* UNIV_SYNC_DEBUG */
 				}
 								
 				return(FALSE);
@@ -932,7 +917,9 @@ sync_thread_add_level(
 
 	if ((latch == (void*)&sync_thread_mutex)
 	    || (latch == (void*)&mutex_list_mutex)
+#ifdef UNIV_SYNC_DEBUG
 	    || (latch == (void*)&rw_lock_debug_mutex)
+#endif /* UNIV_SYNC_DEBUG */
 	    || (latch == (void*)&rw_lock_list_mutex)) {
 
 		return;
@@ -1112,7 +1099,9 @@ sync_thread_reset_level(
 
 	if ((latch == (void*)&sync_thread_mutex)
 	    || (latch == (void*)&mutex_list_mutex)
+#ifdef UNIV_SYNC_DEBUG
 	    || (latch == (void*)&rw_lock_debug_mutex)
+#endif /* UNIV_SYNC_DEBUG */
 	    || (latch == (void*)&rw_lock_list_mutex)) {
 
 		return(FALSE);
@@ -1198,11 +1187,13 @@ sync_init(void)
         mutex_create(&rw_lock_list_mutex);
         mutex_set_level(&rw_lock_list_mutex, SYNC_NO_ORDER_CHECK);
 
+#ifdef UNIV_SYNC_DEBUG
         mutex_create(&rw_lock_debug_mutex);
         mutex_set_level(&rw_lock_debug_mutex, SYNC_NO_ORDER_CHECK);
 
 	rw_lock_debug_event = os_event_create(NULL);
 	rw_lock_debug_waiters = FALSE;
+#endif /* UNIV_SYNC_DEBUG */
 }
 
 /**********************************************************************
@@ -1267,9 +1258,11 @@ sync_print(
 	char*	buf,		/* in/out: buffer where to print */
 	char*	buf_end)	/* in: buffer end */
 {
+#ifdef UNIV_SYNC_DEBUG
 	mutex_list_print_info();
 
 	rw_lock_list_print_info();
+#endif /* UNIV_SYNC_DEBUG */
 
 	sync_array_print_info(buf, buf_end, sync_primary_wait_array);
 
diff --git a/innobase/thr/thr0loc.c b/innobase/thr/thr0loc.c
index 839cb024f25..a17d09fcca6 100644
--- a/innobase/thr/thr0loc.c
+++ b/innobase/thr/thr0loc.c
@@ -46,10 +46,11 @@ struct thr_local_struct{
 	ibool		in_ibuf;/* TRUE if the the thread is doing an ibuf
 				operation */
 	hash_node_t	hash;	/* hash chain node */
+#ifdef UNIV_DEBUG
 	ulint		magic_n;
-};
-
 #define THR_LOCAL_MAGIC_N	1231234
+#endif /* UNIV_DEBUG */
+};
 
 /***********************************************************************
 Returns the local storage struct for a thread. */
@@ -64,7 +65,9 @@ thr_local_get(
 	
 try_again:	
 	ut_ad(thr_local_hash);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&thr_local_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	/* Look for the local struct in the hash table */
 
@@ -167,8 +170,9 @@ thr_local_create(void)
 
 	local->id = os_thread_get_curr_id();
 	local->handle = os_thread_get_curr();
+#ifdef UNIV_DEBUG
 	local->magic_n = THR_LOCAL_MAGIC_N;
-
+#endif /* UNIV_DEBUG */
  	local->in_ibuf = FALSE;
 	
 	mutex_enter(&thr_local_mutex);
@@ -207,7 +211,7 @@ thr_local_free(
 
 	mutex_exit(&thr_local_mutex);
 				
-	ut_a(local->magic_n == THR_LOCAL_MAGIC_N);
+	ut_ad(local->magic_n == THR_LOCAL_MAGIC_N);
 	
 	mem_free(local);
 }
diff --git a/innobase/trx/trx0purge.c b/innobase/trx/trx0purge.c
index 31223aa280e..558a0825fd7 100644
--- a/innobase/trx/trx0purge.c
+++ b/innobase/trx/trx0purge.c
@@ -45,7 +45,9 @@ trx_purge_update_undo_must_exist(
 			the undo log still exists in the system */
 	dulint	trx_id)	/* in: transaction id */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (!read_view_sees_trx_id(purge_sys->view, trx_id)) {
 
@@ -195,9 +197,9 @@ void
 trx_purge_sys_create(void)
 /*======================*/
 {
-	com_endpoint_t*	com_endpoint;
-
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	purge_sys = mem_alloc(sizeof(trx_purge_t));
 
@@ -219,9 +221,7 @@ trx_purge_sys_create(void)
 
 	purge_sys->arr = trx_undo_arr_create();
 
-	com_endpoint = (com_endpoint_t*)purge_sys; /* This is a dummy non-NULL
-						   value */
-	purge_sys->sess = sess_open(com_endpoint, (byte*)"purge_system", 13);
+	purge_sys->sess = sess_open();
 
 	purge_sys->trx = purge_sys->sess->trx;
 
@@ -262,7 +262,9 @@ trx_purge_add_update_undo_to_history(
 	ut_ad(undo);
 	
 	rseg = undo->rseg;
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(rseg->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	rseg_header = trx_rsegf_get(rseg->space, rseg->page_no, mtr);
 
@@ -276,7 +278,7 @@ trx_purge_add_update_undo_to_history(
 		if (undo->id >= TRX_RSEG_N_SLOTS) {
 			fprintf(stderr,
 			"InnoDB: Error: undo->id is %lu\n", (ulong) undo->id);
-			ut_a(0);
+			ut_error;
 		}
 
 		trx_rsegf_set_nth_undo(rseg_header, undo->id, FIL_NULL, mtr);
@@ -295,8 +297,7 @@ trx_purge_add_update_undo_to_history(
 				undo_header + TRX_UNDO_HISTORY_NODE, mtr);
 
 	/* Write the trx number to the undo log header */
-	mlog_write_dulint(undo_header + TRX_UNDO_TRX_NO, trx->no, MLOG_8BYTES,
-									mtr);
+	mlog_write_dulint(undo_header + TRX_UNDO_TRX_NO, trx->no, mtr);
 	/* Write information about delete markings to the undo log header */
 	
 	if (!undo->del_marks) {
@@ -338,7 +339,9 @@ trx_purge_free_segment(
 	
 /*	printf("Freeing an update undo log segment\n"); */
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(purge_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 loop:	
 	mtr_start(&mtr);
 	mutex_enter(&(rseg->mutex));	
@@ -434,7 +437,9 @@ trx_purge_truncate_rseg_history(
 	ulint		n_removed_logs	= 0;
 	mtr_t		mtr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(purge_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mtr_start(&mtr);
 	mutex_enter(&(rseg->mutex));	
@@ -520,7 +525,9 @@ trx_purge_truncate_history(void)
 	dulint		limit_trx_no;
 	dulint		limit_undo_no;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(purge_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	trx_purge_arr_get_biggest(purge_sys->arr, &limit_trx_no,
 							&limit_undo_no);
@@ -560,7 +567,9 @@ trx_purge_truncate_if_arr_empty(void)
 /*=================================*/
 			/* out: TRUE if array empty */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(purge_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (purge_sys->arr->n_used == 0) {
 
@@ -589,7 +598,9 @@ trx_purge_rseg_get_next_history_log(
 	ibool		del_marks;
 	mtr_t		mtr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(purge_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mutex_enter(&(rseg->mutex));
 
@@ -669,7 +680,9 @@ trx_purge_choose_next_log(void)
 	ulint		offset = 0;  /* remove warning (??? bug ???) */
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(purge_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(purge_sys->next_stored == FALSE);
 
 	rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list);
@@ -770,7 +783,9 @@ trx_purge_get_next_rec(
 	ulint		cmpl_info;
 	mtr_t		mtr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(purge_sys->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(purge_sys->next_stored);
 
 	space = purge_sys->rseg->space;
@@ -1001,7 +1016,7 @@ trx_purge(void)
 
 		/* Should not happen */
 
-		ut_a(0);
+		ut_error;
 		
 		return(0);
 	}		
@@ -1034,11 +1049,11 @@ trx_purge(void)
 
 	mutex_enter(&kernel_mutex);
 
-	thr = que_fork_start_command(purge_sys->query, SESS_COMM_EXECUTE, 0);
+	thr = que_fork_start_command(purge_sys->query);
 
 	ut_ad(thr);
 	
-/*	thr2 = que_fork_start_command(purge_sys->query, SESS_COMM_EXECUTE, 0);
+/*	thr2 = que_fork_start_command(purge_sys->query);
 	
 	ut_ad(thr2); */
 	
diff --git a/innobase/trx/trx0rec.c b/innobase/trx/trx0rec.c
index e10f019ac13..bd37a4b506b 100644
--- a/innobase/trx/trx0rec.c
+++ b/innobase/trx/trx0rec.c
@@ -1070,7 +1070,9 @@ trx_undo_report_row_operation(
 						IB__FILE__, __LINE__,
 						&mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(undo_page, SYNC_TRX_UNDO_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 
 		if (op_type == TRX_UNDO_INSERT_OP) {
 			offset = trx_undo_page_report_insert(undo_page, trx,
@@ -1197,7 +1199,9 @@ trx_undo_get_undo_rec(
 	trx_undo_rec_t** undo_rec,	/* out, own: copy of the record */
 	mem_heap_t*	heap)		/* in: memory heap where copied */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (!trx_purge_update_undo_must_exist(trx_id)) {
 
@@ -1257,7 +1261,9 @@ trx_undo_prev_version_build(
 	ulint		i;
 	char		err_buf[1000];
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(mtr_memo_contains(index_mtr, buf_block_align(index_rec), 
 						MTR_MEMO_PAGE_S_FIX) ||
 	      mtr_memo_contains(index_mtr, buf_block_align(index_rec), 
diff --git a/innobase/trx/trx0roll.c b/innobase/trx/trx0roll.c
index 1f053aeed89..6a25304c7ef 100644
--- a/innobase/trx/trx0roll.c
+++ b/innobase/trx/trx0roll.c
@@ -73,8 +73,7 @@ trx_general_rollback_for_mysql(
 
 	thr = pars_complete_graph_for_exec(roll_node, trx, heap);
 	
-	ut_a(thr == que_fork_start_command(que_node_get_parent(thr),
-						SESS_COMM_EXECUTE, 0));
+	ut_a(thr == que_fork_start_command(que_node_get_parent(thr)));
 	que_run_threads(thr);
 
 	mutex_enter(&kernel_mutex);
@@ -354,8 +353,7 @@ trx_rollback_or_clean_all_without_sess(void)
 	/* Open a dummy session */
 
 	if (!trx_dummy_sess) {
-		trx_dummy_sess = sess_open(NULL, (byte*)"Dummy sess",
-					ut_strlen((char *) "Dummy sess"));
+		trx_dummy_sess = sess_open();
 	}
 	
 	mutex_exit(&kernel_mutex);
@@ -418,7 +416,7 @@ loop:
 
 	trx->graph = fork;
 
-	ut_a(thr == que_fork_start_command(fork, SESS_COMM_EXECUTE, 0));
+	ut_a(thr == que_fork_start_command(fork));
 	
 	trx_roll_max_undo_no = ut_conv_dulint_to_longlong(trx->undo_no);
 	trx_roll_progress_printed_pct = 0;
@@ -678,8 +676,10 @@ trx_roll_try_truncate(
 	dulint		limit;
 	dulint		biggest;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(trx->undo_mutex)));
 	ut_ad(mutex_own(&((trx->rseg)->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	trx->pages_undone = 0;
 	
@@ -722,7 +722,9 @@ trx_roll_pop_top_rec(
 	trx_undo_rec_t*	prev_rec;
 	page_t*		prev_rec_page;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(trx->undo_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	undo_page = trx_undo_page_get_s_latched(undo->space,
 						undo->top_page_no, mtr);
@@ -946,7 +948,9 @@ trx_rollback(
 	que_thr_t*	thr;
 /*	que_thr_t*	thr2; */
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad((trx->undo_no_arr == NULL) || ((trx->undo_no_arr)->n_used == 0));
 	
 	/* Initialize the rollback field in the transaction */
@@ -981,11 +985,11 @@ trx_rollback(
 	trx->graph = roll_graph;
 	trx->que_state = TRX_QUE_ROLLING_BACK;
 
-	thr = que_fork_start_command(roll_graph, SESS_COMM_EXECUTE, 0);
+	thr = que_fork_start_command(roll_graph);
 
 	ut_ad(thr);
 
-/*	thr2 = que_fork_start_command(roll_graph, SESS_COMM_EXECUTE, 0);
+/*	thr2 = que_fork_start_command(roll_graph);
 
 	ut_ad(thr2); */
 	
@@ -1015,7 +1019,9 @@ trx_roll_graph_build(
 	que_thr_t*	thr;
 /*	que_thr_t*	thr2; */
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	heap = mem_heap_create(512);
 	fork = que_fork_create(NULL, NULL, QUE_FORK_ROLLBACK, heap);
@@ -1042,7 +1048,9 @@ trx_finish_error_processing(
 	trx_sig_t*	sig;
 	trx_sig_t*	next_sig;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	sig = UT_LIST_GET_FIRST(trx->signals);
 
@@ -1075,14 +1083,16 @@ trx_finish_partial_rollback_off_kernel(
 {
 	trx_sig_t*	sig;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	sig = UT_LIST_GET_FIRST(trx->signals);
 
 	/* Remove the signal from the signal queue and send reply message
 	to it */
 
-	trx_sig_reply(trx, sig, next_thr);
+	trx_sig_reply(sig, next_thr);
 	trx_sig_remove(trx, sig);
 
 	trx->que_state = TRX_QUE_RUNNING;
@@ -1106,7 +1116,9 @@ trx_finish_rollback_off_kernel(
 	trx_sig_t*	sig;
 	trx_sig_t*	next_sig;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	ut_a(trx->undo_no_arr == NULL || trx->undo_no_arr->n_used == 0);
 
@@ -1145,7 +1157,7 @@ trx_finish_rollback_off_kernel(
 
 		if (sig->type == TRX_SIG_TOTAL_ROLLBACK) {
 
-			trx_sig_reply(trx, sig, next_thr);
+			trx_sig_reply(sig, next_thr);
 
 			trx_sig_remove(trx, sig);
 		}
@@ -1213,7 +1225,7 @@ trx_rollback_step(
 
 		success = trx_sig_send(thr_get_trx(thr),
 					sig_no, TRX_SIG_SELF,
-					TRUE, thr, savept, NULL);
+					thr, savept, NULL);
 
 		thr->state = QUE_THR_SIG_REPLY_WAIT;
 		
diff --git a/innobase/trx/trx0rseg.c b/innobase/trx/trx0rseg.c
index b1fb8a9539c..e3885c86def 100644
--- a/innobase/trx/trx0rseg.c
+++ b/innobase/trx/trx0rseg.c
@@ -60,7 +60,9 @@ trx_rseg_header_create(
 	page_t*		page;
 	
 	ut_ad(mtr);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(mtr_memo_contains(mtr, fil_space_get_latch(space),
 							MTR_MEMO_X_LOCK));
 	sys_header = trx_sysf_get(mtr);
@@ -81,7 +83,9 @@ trx_rseg_header_create(
 		return(FIL_NULL);
 	}
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_RSEG_HEADER_NEW);
+#endif /* UNIV_SYNC_DEBUG */
 
 	page_no = buf_frame_get_page_no(page);
 
@@ -132,7 +136,9 @@ trx_rseg_mem_create(
 	fil_addr_t	node_addr;
 	ulint		sum_of_undo_sizes;
 
-	ut_ad(mutex_own(&kernel_mutex));	
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	rseg = mem_alloc(sizeof(trx_rseg_t));
 
@@ -173,8 +179,7 @@ trx_rseg_mem_create(
 			       + node_addr.boffset;
 			       
 		rseg->last_trx_no = mtr_read_dulint(
-					undo_log_hdr + TRX_UNDO_TRX_NO,
-					MLOG_8BYTES, mtr);
+					undo_log_hdr + TRX_UNDO_TRX_NO, mtr);
 		rseg->last_del_marks = mtr_read_ulint(
 					undo_log_hdr + TRX_UNDO_DEL_MARKS,
 					MLOG_2BYTES, mtr);
diff --git a/innobase/trx/trx0sys.c b/innobase/trx/trx0sys.c
index 6084c70102f..e7439935b7e 100644
--- a/innobase/trx/trx0sys.c
+++ b/innobase/trx/trx0sys.c
@@ -177,7 +177,9 @@ start_again:
 	mtr_start(&mtr);
 
 	page = buf_page_get(TRX_SYS_SPACE, TRX_SYS_PAGE_NO, RW_X_LATCH, &mtr);
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 
 	doublewrite = page + TRX_SYS_DOUBLEWRITE;
 	
@@ -211,7 +213,9 @@ start_again:
 		/* fseg_create acquires a second latch on the page,
 		therefore we must declare it: */
 
+#ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(page2, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 
 		if (page2 == NULL) {
 			fprintf(stderr,
@@ -254,7 +258,9 @@ start_again:
 			
 			new_page = buf_page_get(TRX_SYS_SPACE, page_no,
 							RW_X_LATCH, &mtr);
+#ifdef UNIV_SYNC_DEBUG
 			buf_page_dbg_add_level(new_page, SYNC_NO_ORDER_CHECK);
+#endif /* UNIV_SYNC_DEBUG */
 
 			/* Make a dummy change to the page to ensure it will
 			be written to disk in a flush */
@@ -510,7 +516,9 @@ trx_in_trx_list(
 {
 	trx_t*	trx;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(kernel_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
 
@@ -537,14 +545,16 @@ trx_sys_flush_max_trx_id(void)
 	trx_sysf_t*	sys_header;
 	mtr_t		mtr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mtr_start(&mtr);
 
 	sys_header = trx_sysf_get(&mtr);
 
 	mlog_write_dulint(sys_header + TRX_SYS_TRX_ID_STORE,
-				trx_sys->max_trx_id, MLOG_8BYTES, &mtr);
+				trx_sys->max_trx_id, &mtr);
 	mtr_commit(&mtr);
 }
 
@@ -736,7 +746,9 @@ trx_sysf_rseg_find_free(
 	ulint		page_no;
 	ulint		i;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(kernel_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	sys_header = trx_sysf_get(mtr);
 
@@ -782,13 +794,15 @@ trx_sysf_create(
 					    				mtr);
 	ut_a(buf_frame_get_page_no(page) == TRX_SYS_PAGE_NO);
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(page, SYNC_TRX_SYS_HEADER);
+#endif /* UNIV_SYNC_DEBUG */
 
 	sys_header = trx_sysf_get(mtr);
 
 	/* Start counting transaction ids from number 1 up */
 	mlog_write_dulint(sys_header + TRX_SYS_TRX_ID_STORE,
-				ut_dulint_create(0, 1), MLOG_8BYTES, mtr);
+				ut_dulint_create(0, 1), mtr);
 
 	/* Reset the rollback segment slots */
 	for (i = 0; i < TRX_SYS_N_RSEGS; i++) {
@@ -843,8 +857,7 @@ trx_sys_init_at_db_start(void)
 	trx_sys->max_trx_id = ut_dulint_add(
 			      	ut_dulint_align_up(
 					mtr_read_dulint(sys_header
-						+ TRX_SYS_TRX_ID_STORE,
-						MLOG_8BYTES, &mtr),
+						+ TRX_SYS_TRX_ID_STORE, &mtr),
 					TRX_SYS_TRX_ID_WRITE_MARGIN),
 				2 * TRX_SYS_TRX_ID_WRITE_MARGIN);
 
diff --git a/innobase/trx/trx0trx.c b/innobase/trx/trx0trx.c
index 0197e5cc05f..b509d80e452 100644
--- a/innobase/trx/trx0trx.c
+++ b/innobase/trx/trx0trx.c
@@ -73,7 +73,9 @@ trx_create(
 {
 	trx_t*	trx;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	trx = mem_alloc(sizeof(trx_t));
 
@@ -171,8 +173,7 @@ trx_allocate_for_mysql(void)
 	/* Open a dummy session */
 
 	if (!trx_dummy_sess) {
-		trx_dummy_sess = sess_open(NULL, (byte*)"Dummy sess",
-					   ut_strlen((char *) "Dummy sess"));
+		trx_dummy_sess = sess_open();
 	}
 	
 	trx = trx_create(trx_dummy_sess);
@@ -205,8 +206,7 @@ trx_allocate_for_background(void)
 	/* Open a dummy session */
 
 	if (!trx_dummy_sess) {
-		trx_dummy_sess = sess_open(NULL, (byte*)"Dummy sess",
-						ut_strlen("Dummy sess"));
+		trx_dummy_sess = sess_open();
 	}
 	
 	trx = trx_create(trx_dummy_sess);
@@ -241,7 +241,9 @@ trx_free(
 {
         char      err_buf[1000];
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (trx->declared_to_be_inside_innodb) {
 	        ut_print_timestamp(stderr);
@@ -347,7 +349,9 @@ trx_list_insert_ordered(
 {
 	trx_t*	trx2;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	trx2 = UT_LIST_GET_FIRST(trx_sys->trx_list);
 
@@ -509,7 +513,9 @@ trx_assign_rseg(void)
 {
 	trx_rseg_t*	rseg	= trx_sys->latest_rseg;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 loop:
 	/* Get next rseg in a round-robin fashion */
 
@@ -546,7 +552,9 @@ trx_start_low(
 {
 	trx_rseg_t*	rseg;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(trx->rseg == NULL);
 
 	if (trx->type == TRX_PURGE) {
@@ -621,7 +629,9 @@ trx_commit_off_kernel(
 	ibool		must_flush_log	= FALSE;
 	mtr_t		mtr;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	rseg = trx->rseg;
 	
@@ -715,7 +725,9 @@ trx_commit_off_kernel(
 	}
 
 	ut_ad(trx->conc_state == TRX_ACTIVE);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	/* The following assignment makes the transaction committed in memory
 	and makes its changes to data visible to other transactions.
@@ -804,7 +816,7 @@ trx_commit_off_kernel(
 
                         log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
                 } else {
-                        ut_a(0);
+                        ut_error;
                 }
 
 		trx->commit_lsn = lsn;
@@ -895,7 +907,9 @@ trx_handle_commit_sig_off_kernel(
 	trx_sig_t*	sig;
 	trx_sig_t*	next_sig;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	trx->que_state = TRX_QUE_COMMITTING;
 
@@ -913,7 +927,7 @@ trx_handle_commit_sig_off_kernel(
 
 		if (sig->type == TRX_SIG_COMMIT) {
 
-			trx_sig_reply(trx, sig, next_thr);
+			trx_sig_reply(sig, next_thr);
 			trx_sig_remove(trx, sig);
 		}
 
@@ -935,7 +949,9 @@ trx_end_lock_wait(
 {
 	que_thr_t*	thr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(trx->que_state == TRX_QUE_LOCK_WAIT);
 	
 	thr = UT_LIST_GET_FIRST(trx->wait_thrs);
@@ -962,7 +978,9 @@ trx_lock_wait_to_suspended(
 {
 	que_thr_t*	thr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(trx->que_state == TRX_QUE_LOCK_WAIT);
 	
 	thr = UT_LIST_GET_FIRST(trx->wait_thrs);
@@ -990,7 +1008,9 @@ trx_sig_reply_wait_to_suspended(
 	trx_sig_t*	sig;
 	que_thr_t*	thr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	sig = UT_LIST_GET_FIRST(trx->reply_signals);
 
@@ -1002,7 +1022,6 @@ trx_sig_reply_wait_to_suspended(
 		thr->state = QUE_THR_SUSPENDED;
 
 		sig->receiver = NULL;
-		sig->reply = FALSE;
 	
 		UT_LIST_REMOVE(reply_signals, trx->reply_signals, sig);
 			
@@ -1024,7 +1043,9 @@ trx_sig_is_compatible(
 {
 	trx_sig_t*	sig;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (UT_LIST_GET_LEN(trx->signals) == 0) {
 
@@ -1096,13 +1117,9 @@ trx_sig_send(
 	ulint		type,		/* in: signal type */
 	ulint		sender,		/* in: TRX_SIG_SELF or
 					TRX_SIG_OTHER_SESS */
-	ibool		reply,		/* in: TRUE if the sender of the signal
-					wants reply after the operation induced
-					by the signal is completed; if type
-					is TRX_SIG_END_WAIT, this must be
-					FALSE */
 	que_thr_t*	receiver_thr,	/* in: query thread which wants the
-					reply, or NULL */
+					reply, or NULL; if type is
+					TRX_SIG_END_WAIT, this must be NULL */
 	trx_savept_t* 	savept,		/* in: possible rollback savepoint, or
 					NULL */
 	que_thr_t**	next_thr)	/* in/out: next query thread to run;
@@ -1116,13 +1133,15 @@ trx_sig_send(
 	trx_t*		receiver_trx;
 
 	ut_ad(trx);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (!trx_sig_is_compatible(trx, type, sender)) {
 		/* The signal is not compatible with the other signals in
 		the queue: do nothing */
 
-		ut_a(0);
+		ut_error;
 		
 		return(FALSE);
 	}
@@ -1146,7 +1165,6 @@ trx_sig_send(
 	sig->type = type;
 	sig->state = TRX_SIG_WAITING;
 	sig->sender = sender;
-	sig->reply = reply;
 	sig->receiver = receiver_thr;
 
 	if (savept) {
@@ -1171,7 +1189,7 @@ trx_sig_send(
 		signal to the end of the queue, if the session is not yet
 		in the error state: */
 
-		ut_a(0);
+		ut_error;
 	}
 
 	/* If there were no other signals ahead in the queue, try to start
@@ -1196,7 +1214,9 @@ trx_end_signal_handling(
 /*====================*/
 	trx_t*	trx)	/* in: trx */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(trx->handling_signals == TRUE);
 
 	trx->handling_signals = FALSE;
@@ -1230,7 +1250,9 @@ loop:
 	we can process immediately */
 
 	ut_ad(trx);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (trx->handling_signals && (UT_LIST_GET_LEN(trx->signals) == 0)) {
 
@@ -1305,7 +1327,7 @@ loop:
 
 	} else if (type == TRX_SIG_BREAK_EXECUTION) {
 
-		trx_sig_reply(trx, sig, next_thr);
+		trx_sig_reply(sig, next_thr);
 		trx_sig_remove(trx, sig);
 	} else {
 		ut_error;
@@ -1321,7 +1343,6 @@ handled. */
 void
 trx_sig_reply(
 /*==========*/
-	trx_t*		trx,		/* in: trx handle */
 	trx_sig_t*	sig,		/* in: signal */
 	que_thr_t**	next_thr)	/* in/out: next query thread to run;
 					if the value which is passed in is
@@ -1331,11 +1352,12 @@ trx_sig_reply(
 {
 	trx_t*	receiver_trx;
 
-	ut_ad(trx && sig);
+	ut_ad(sig);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
-	if (sig->reply && (sig->receiver != NULL)) {
-
+	if (sig->receiver != NULL) {
 		ut_ad((sig->receiver)->state == QUE_THR_SIG_REPLY_WAIT);
 
 		receiver_trx = thr_get_trx(sig->receiver);
@@ -1346,18 +1368,8 @@ trx_sig_reply(
 									
 		que_thr_end_wait(sig->receiver, next_thr);
 
-		sig->reply = FALSE;
-		sig->receiver = NULL;
-
-	} else if (sig->reply) {
-		/* In this case the reply should be sent to the client of
-		the session of the transaction */
-
-		sig->reply = FALSE;
 		sig->receiver = NULL;
 
-		sess_srv_msg_send_simple(trx->sess, SESS_SRV_SUCCESS,
-						SESS_NOT_RELEASE_KERNEL);
 	}
 }
 
@@ -1371,9 +1383,10 @@ trx_sig_remove(
 	trx_sig_t*	sig)	/* in, own: signal */
 {
 	ut_ad(trx && sig);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 
-	ut_ad(sig->reply == FALSE);
 	ut_ad(sig->receiver == NULL);
 
 	UT_LIST_REMOVE(signals, trx->signals, sig);
@@ -1435,8 +1448,7 @@ trx_commit_step(
 		/* Send the commit signal to the transaction */
 		
 		success = trx_sig_send(thr_get_trx(thr), TRX_SIG_COMMIT,
-					TRX_SIG_SELF, TRUE, thr, NULL,
-					&next_thr);
+					TRX_SIG_SELF, thr, NULL, &next_thr);
 		
 		mutex_exit(&kernel_mutex);
 
@@ -1522,7 +1534,7 @@ trx_commit_complete_for_mysql(
 
                 log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
         } else {
-                ut_a(0);
+                ut_error;
         }
 
 	trx->op_info = (char*)"";
diff --git a/innobase/trx/trx0undo.c b/innobase/trx/trx0undo.c
index f3f93734a49..f2b7227d84a 100644
--- a/innobase/trx/trx0undo.c
+++ b/innobase/trx/trx0undo.c
@@ -391,7 +391,9 @@ trx_undo_seg_create(
 	ibool		success;
 	
 	ut_ad(mtr && id && rseg_hdr);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(rseg->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 /*	
 	if (type == TRX_UNDO_INSERT) {
 		printf("Creating insert undo log segment\n");
@@ -431,7 +433,9 @@ trx_undo_seg_create(
 		return(NULL);
 	}
 
+#ifdef UNIV_SYNC_DEBUG
 	buf_page_dbg_add_level(undo_page, SYNC_TRX_UNDO_PAGE);
+#endif /* UNIV_SYNC_DEBUG */
 
 	page_hdr = undo_page + TRX_UNDO_PAGE_HDR;
 	seg_hdr = undo_page + TRX_UNDO_SEG_HDR;
@@ -737,13 +741,14 @@ trx_undo_add_page(
 	ulint		n_reserved;
 	ibool		success;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(trx->undo_mutex)));
 	ut_ad(!mutex_own(&kernel_mutex));
+	ut_ad(mutex_own(&(trx->rseg->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	rseg = trx->rseg;
 
-	ut_ad(mutex_own(&(rseg->mutex)));
-
 	if (rseg->curr_size == rseg->max_size) {
 
 		return(FIL_NULL);
@@ -813,8 +818,10 @@ trx_undo_free_page(
 
 	UT_NOT_USED(hdr_offset);
 	ut_a(hdr_page_no != page_no);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex));
 	ut_ad(mutex_own(&(rseg->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	
 	undo_page = trx_undo_page_get(space, page_no, mtr);
 
@@ -861,7 +868,9 @@ trx_undo_free_page_in_rollback(
 	ulint	last_page_no;
 
 	ut_ad(undo->hdr_page_no != page_no);
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(trx->undo_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	last_page_no = trx_undo_free_page(undo->rseg, FALSE, undo->space,
 					undo->hdr_page_no, undo->hdr_offset,
@@ -915,12 +924,13 @@ trx_undo_truncate_end(
 	trx_rseg_t*	rseg;
 	mtr_t		mtr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(trx->undo_mutex)));
+	ut_ad(mutex_own(&(trx->rseg->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	rseg = trx->rseg;		
 
-	ut_ad(mutex_own(&(rseg->mutex)));
-
  	for (;;) {
 		mtr_start(&mtr);
 
@@ -994,7 +1004,9 @@ trx_undo_truncate_start(
 	ulint		page_no;
 	mtr_t		mtr;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(rseg->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (0 == ut_dulint_cmp(limit, ut_dulint_zero)) {
 
@@ -1060,8 +1072,9 @@ trx_undo_seg_free(
 	while (!finished) {
 
 		mtr_start(&mtr);
-	
+#ifdef UNIV_SYNC_DEBUG
 		ut_ad(!mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 		mutex_enter(&(rseg->mutex));
 
 		seg_header = trx_undo_page_get(undo->space, undo->hdr_page_no,
@@ -1117,7 +1130,7 @@ trx_undo_mem_create_at_db_start(
 	if (id >= TRX_RSEG_N_SLOTS) {
 		fprintf(stderr,
 		"InnoDB: Error: undo->id is %lu\n", (ulong) id);
-		ut_a(0);
+		ut_error;
 	}
 
 	undo_page = trx_undo_page_get(rseg->space, page_no, mtr);
@@ -1134,8 +1147,7 @@ trx_undo_mem_create_at_db_start(
 	
 	undo_header = undo_page + offset;
 
-	trx_id = mtr_read_dulint(undo_header + TRX_UNDO_TRX_ID, MLOG_8BYTES,
-									mtr);
+	trx_id = mtr_read_dulint(undo_header + TRX_UNDO_TRX_ID, mtr);
 	mutex_enter(&(rseg->mutex));
 
 	undo = trx_undo_mem_create(rseg, id, type, trx_id, page_no, offset);
@@ -1145,8 +1157,7 @@ trx_undo_mem_create_at_db_start(
 	undo->dict_operation = mtr_read_ulint(
 				undo_header + TRX_UNDO_DICT_OPERATION,
 							MLOG_2BYTES, mtr);
-	undo->table_id = mtr_read_dulint(undo_header + TRX_UNDO_TABLE_ID,
-							MLOG_8BYTES, mtr);
+	undo->table_id = mtr_read_dulint(undo_header + TRX_UNDO_TABLE_ID, mtr);
 	undo->state = state;
 	undo->size = flst_get_len(seg_header + TRX_UNDO_PAGE_LIST, mtr);
 
@@ -1270,12 +1281,14 @@ trx_undo_mem_create(
 {
 	trx_undo_t*	undo;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(rseg->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (id >= TRX_RSEG_N_SLOTS) {
 		fprintf(stderr,
 		"InnoDB: Error: undo->id is %lu\n", (ulong) id);
-		ut_a(0);
+		ut_error;
 	}
 
 	undo = mem_alloc(sizeof(trx_undo_t));
@@ -1314,14 +1327,16 @@ trx_undo_mem_init_for_reuse(
 				is created */
 	ulint		offset)	/* in: undo log header byte offset on page */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&((undo->rseg)->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 	
  	if (undo->id >= TRX_RSEG_N_SLOTS) {
 		fprintf(stderr, "InnoDB: Error: undo->id is %lu\n",
 			(ulong) undo->id);
 
 		mem_analyze_corruption((byte*)undo);
-		ut_a(0);
+		ut_error;
 	}
 
 	undo->state = TRX_UNDO_ACTIVE;
@@ -1345,7 +1360,7 @@ trx_undo_mem_free(
 	if (undo->id >= TRX_RSEG_N_SLOTS) {
 		fprintf(stderr,
 		"InnoDB: Error: undo->id is %lu\n", (ulong) undo->id);
-		ut_a(0);
+		ut_error;
 	}
 
 	mem_free(undo);
@@ -1373,7 +1388,9 @@ trx_undo_create(
 	trx_undo_t*	undo;
 	page_t*		undo_page;
 	
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(rseg->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (rseg->curr_size == rseg->max_size) {
 
@@ -1424,7 +1441,9 @@ trx_undo_reuse_cached(
 	page_t*		undo_page;
 	ulint		offset;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(rseg->mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	if (type == TRX_UNDO_INSERT) {
 
@@ -1448,13 +1467,12 @@ trx_undo_reuse_cached(
 	}
 
 	ut_ad(undo->size == 1);
-	ut_ad(undo->hdr_page_no == undo->top_page_no);
 
 	if (undo->id >= TRX_RSEG_N_SLOTS) {
 		fprintf(stderr, "InnoDB: Error: undo->id is %lu\n",
 			(ulong) undo->id);
 		mem_analyze_corruption((byte*)undo);
-		ut_a(0);
+		ut_error;
 	}
 
 	undo_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr);
@@ -1495,7 +1513,7 @@ trx_undo_mark_as_dict_operation(
 			trx->dict_operation, MLOG_2BYTES, mtr);
 	
 	mlog_write_dulint(hdr_page + undo->hdr_offset + TRX_UNDO_TABLE_ID,
-			trx->table_id, MLOG_8BYTES, mtr);	
+			trx->table_id, mtr);	
 
 	undo->dict_operation = trx->dict_operation;
 	undo->table_id = trx->table_id;
@@ -1522,11 +1540,15 @@ trx_undo_assign_undo(
 
 	rseg = trx->rseg;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(trx->undo_mutex)));
+#endif /* UNIV_SYNC_DEBUG */
 
 	mtr_start(&mtr);
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(!mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	mutex_enter(&(rseg->mutex));
 
 	undo = trx_undo_reuse_cached(rseg, type, trx->id, &mtr);
@@ -1587,7 +1609,7 @@ trx_undo_set_state_at_finish(
 		fprintf(stderr, "InnoDB: Error: undo->id is %lu\n",
 			(ulong) undo->id);
 		mem_analyze_corruption((byte*)undo);
-		ut_a(0);
+		ut_error;
 	}
 
 	undo_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr);
@@ -1632,8 +1654,9 @@ trx_undo_update_cleanup(
 	undo = trx->update_undo;
 	rseg = trx->rseg;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(rseg->mutex)));
-	
+#endif /* UNIV_SYNC_DEBUG */
 	trx_purge_add_update_undo_to_history(trx, undo_page, mtr);
 
 	UT_LIST_REMOVE(undo_list, rseg->update_undo_list, undo);
@@ -1672,8 +1695,10 @@ trx_undo_update_cleanup_by_discard(
 	undo = trx->update_undo;
 	rseg = trx->rseg;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(rseg->mutex)));
 	ut_ad(mutex_own(&kernel_mutex));
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(undo->size == 1);
 	ut_ad(undo->del_marks == FALSE);	
 	ut_ad(UT_LIST_GET_LEN(trx_sys->view_list) == 1);
diff --git a/innobase/usr/usr0sess.c b/innobase/usr/usr0sess.c
index 1455a16057e..359c1552421 100644
--- a/innobase/usr/usr0sess.c
+++ b/innobase/usr/usr0sess.c
@@ -12,21 +12,7 @@ Created 6/25/1996 Heikki Tuuri
 #include "usr0sess.ic"
 #endif
 
-#include "ut0rnd.h"
-#include "mach0data.h"
-#include "ha0ha.h"
 #include "trx0trx.h"
-#include "que0que.h"
-#include "pars0pars.h"
-#include "pars0sym.h"
-#include "dict0dict.h"
-#include "dict0mem.h"
-#include "odbc0odbc.h"
-
-#define SESS_ERR_BUF_SIZE	8192
-
-/* The session system global data structure */
-sess_sys_t*	sess_sys	= NULL;
 
 /*************************************************************************
 Closes a session, freeing the memory occupied by it. */
@@ -35,247 +21,28 @@ void
 sess_close(
 /*=======*/
 	sess_t*		sess);	/* in, own: session object */
-/*************************************************************************
-Communicates an error message to the client. If sess->client_waits is not
-TRUE, puts the session to error state and does not try to send the error
-message. */
-static
-void
-sess_srv_msg_send_error(
-/*====================*/
-	sess_t*	sess);	/* in: session object */
-/*************************************************************************
-Copies error info to a session. Sends to the transaction a signal which will
-rollback the latest incomplete SQL statement and then send the error message
-to the client. NOTE: This function will take care of the freeing of the error
-string, thus the caller must supply a copy of the error string. */
-static
-void
-sess_error_low(
-/*===========*/
-	sess_t*	sess,	/* in: session object */
-	ulint	err_no,	/* in: error number */
-	char*	err_str);/* in, own: error string or NULL;
-			NOTE: the function will take care of freeing of the
-			string! */
-
-/*************************************************************************
-Folds a session id to a ulint. Because this function is used also in
-calculating a checksum for the id to write in the message, it is performs
-also a XOR operation to mix the values more thoroughly. */
-UNIV_INLINE
-ulint
-sess_id_fold(
-/*=========*/
-			/* out: folded value; can be used also as the checksum
-			for id */
-	dulint	id)	/* in: session id */
-{
-	return(ut_fold_dulint(id) ^ 2945794411U);
-}
-
-/*************************************************************************
-Sets the session id in a client message. */
-
-void
-sess_cli_msg_set_sess(
-/*==================*/
-	byte*	str,	/* in/out: message string */
-	dulint	sess_id)/* in: session id */
-{
-	ulint	fold;
-	
-	mach_write_to_8(str + SESS_CLI_MSG_SESS_ID, sess_id);	
-
-	fold = sess_id_fold(sess_id);
-
-	mach_write_to_4(str + SESS_CLI_MSG_SESS_ID_CHECK, fold);
-}
-
-/***************************************************************************
-Decrements the reference count of a session and closes it, if desired. */
-UNIV_INLINE
-void
-sess_refer_count_dec(
-/*=================*/
-	sess_t*	sess)	/* in: session */
-{
-	ut_ad(mutex_own(&kernel_mutex));
-	ut_ad(sess->refer_count > 0);
-
-	sess->refer_count--;
-
-	if (sess->disconnecting && (sess->refer_count == 0)) {
-
-	    	sess_close(sess);
-	}
-}
-
-/***************************************************************************
-Increments the reference count of a session. */
-UNIV_INLINE
-void
-sess_refer_count_inc(
-/*=================*/
-	sess_t*	sess)	/* in: session */
-{
-	ut_ad(mutex_own(&kernel_mutex));
-
-	sess->refer_count++;
-}
-
-/***************************************************************************
-Creates a session system at a database start. */
-
-void
-sess_sys_init_at_db_start(void)
-/*===========================*/
-{
-	sess_sys = mem_alloc(sizeof(sess_sys_t));
-
-	sess_sys->state = SESS_SYS_RUNNING;
-	sess_sys->free_sess_id = ut_dulint_create(0, 1);
-	sess_sys->hash = hash_create(SESS_HASH_SIZE);
-}
-
-/***************************************************************************
-Gets the message type of a message from client. */
-UNIV_INLINE
-ulint
-sess_cli_msg_get_type(
-/*==================*/
-			/* out: message type */
-	byte*	str)	/* in: message string */
-{
-	ut_ad(mutex_own(&kernel_mutex));
-
-	return(mach_read_from_4(str + SESS_CLI_MSG_TYPE));
-}
-
-/***************************************************************************
-Gets the message number of a message from client. */
-UNIV_INLINE
-dulint
-sess_cli_msg_get_msg_no(
-/*====================*/
-			/* out: message number */
-	byte*	str)	/* in: message string */
-{
-	ut_ad(mutex_own(&kernel_mutex));
-
-	return(mach_read_from_8(str + SESS_CLI_MSG_NO));
-}
-
-/***************************************************************************
-Gets the continue field of a message from client. */
-UNIV_INLINE
-ulint
-sess_cli_msg_get_continue(
-/*======================*/
-			/* out: SESS_MSG_SINGLE_PART, ... */
-	byte*	str)	/* in: message string */
-{
-	ut_ad(mutex_own(&kernel_mutex));
-
-	return(mach_read_from_4(str + SESS_CLI_MSG_CONTINUE));
-}
-
-/***************************************************************************
-Gets the size of a big message in kilobytes. */
-UNIV_INLINE
-ulint
-sess_cli_msg_get_cont_size(
-/*=======================*/
-			/* out: size in kilobytes */
-	byte*	str)	/* in: message string */
-{
-	ut_ad(mutex_own(&kernel_mutex));
-
-	return(mach_read_from_4(str + SESS_CLI_MSG_CONT_SIZE));
-}
-
-/*************************************************************************
-Checks the consistency of a message from a client. */
-UNIV_INLINE
-ibool
-sess_cli_msg_check_consistency(
-/*===========================*/
-			/* out: TRUE if ok */
-	byte*	str,	/* in: message string */
-	ulint	len)	/* in: message string length */
-{	
-	ulint	fold;
-
-	ut_ad(mutex_own(&kernel_mutex));
-
-	if (len < SESS_CLI_MSG_DATA) {
-
-		return(FALSE);
-	}
-
-	ut_ad(SESS_CLI_MSG_CHECKSUM == 0);
-
-	fold = ut_fold_binary(str + 4, len - 4);
-
-	if (mach_read_from_4(str + SESS_CLI_MSG_CHECKSUM) != fold) {
-
-		return(FALSE);
-	}
-
-	return(TRUE);
-}
 
 /*************************************************************************
 Opens a session. */
 
 sess_t*
-sess_open(
-/*======*/
+sess_open(void)
+/*===========*/
 					/* out, own: session object */
-	com_endpoint_t*	endpoint,	/* in: communication endpoint used
-					for receiving messages from the client,
-					or NULL if no client */
-	byte*		addr_buf,	/* in: client address (= user name) */
-	ulint		addr_len)	/* in: client address length */
 {	
 	sess_t*	sess;
-	ulint	fold;
 
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
-
+#endif /* UNIV_SYNC_DEBUG */
 	sess = mem_alloc(sizeof(sess_t));
 
-	sess->id = sess_sys->free_sess_id;
-	UT_DULINT_INC(sess_sys->free_sess_id);
-
 	sess->state = SESS_ACTIVE;
-	sess->disconnecting = FALSE;
-	sess->msgs_sent = ut_dulint_zero;
-	sess->msgs_recv = ut_dulint_zero;
-	sess->client_waits = TRUE;
-	sess->err_no = 0;
-	sess->err_str = NULL;
-	sess->error_count = ut_dulint_zero;
-	
-	sess->big_msg = NULL;
 
 	sess->trx = trx_create(sess);
 
-	sess->next_graph_id = 0;
-
 	UT_LIST_INIT(sess->graphs);
 
-	fold = sess_id_fold(sess->id);
-
-	HASH_INSERT(sess_t, hash, sess_sys->hash, fold, sess);
-							
-	sess->endpoint = endpoint;
-	sess->addr_buf = mem_alloc(addr_len);
-
-	ut_memcpy(sess->addr_buf, addr_buf, addr_len);
-
-	sess->addr_len = addr_len;
-	
 	return(sess);
 }
 
@@ -288,23 +55,11 @@ sess_close(
 /*=======*/
 	sess_t*	sess)	/* in, own: session object */
 {	
-	ulint	fold;
-
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
-	ut_ad(sess->disconnecting);
+#endif /* UNIV_SYNC_DEBUG */
 	ut_ad(sess->trx == NULL);
-	ut_ad(sess->refer_count == 0);
-
-	fold = ut_fold_dulint(sess->id);
-	HASH_DELETE(sess_t, hash, sess_sys->hash, fold, sess);
 
-/*	sess_reply_to_client_rel_kernel(sess); */
-	
-	if (sess->err_str != NULL) {
-		mem_free(sess->err_str);
-	}
-
-	mem_free(sess->addr_buf);
 	mem_free(sess);
 }
 
@@ -318,10 +73,10 @@ sess_try_close(
 			/* out: TRUE if closed */
 	sess_t*	sess)	/* in, own: session object */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&kernel_mutex));
-
-	if (sess->disconnecting && (UT_LIST_GET_LEN(sess->graphs) == 0)
-						&& (sess->refer_count == 0)) {
+#endif /* UNIV_SYNC_DEBUG */
+	if (UT_LIST_GET_LEN(sess->graphs) == 0) {
 		sess_close(sess);
 
 		return(TRUE);
@@ -329,259 +84,3 @@ sess_try_close(
 
 	return(FALSE);
 }
-
-/*************************************************************************
-Initializes the first fields of a message to client. */
-
-void
-sess_srv_msg_init(
-/*==============*/
-	sess_t*	sess,	/* in: session object */
-	byte*	buf,	/* in: message buffer, must be at least of size
-			SESS_SRV_MSG_DATA */
-	ulint	type)	/* in: message type */
-{
-	ut_ad(mutex_own(&kernel_mutex));
-
-	sess->msgs_sent = ut_dulint_add(sess->msgs_sent, 1);
-		
-	mach_write_to_8(buf + SESS_SRV_MSG_SESS_ID, sess->id);
-	mach_write_to_4(buf + SESS_SRV_MSG_TYPE, type);
-	mach_write_to_8(buf + SESS_SRV_MSG_NO, sess->msgs_sent);
-
-	ut_ad(com_endpoint_get_max_size(sess->endpoint) >= SESS_SRV_MSG_DATA);
-}		
-
-/*************************************************************************
-Sends a message to the client. */
-static
-ulint
-sess_srv_msg_send_low(
-/*==================*/
-			/* out: 0 if success, else error number */
-	sess_t*	sess,	/* in: session object */
-	byte*	buf,	/* in: message buffer */
-	ulint	len,	/* in: message length */
-	ulint	rel_ker)/* in: SESS_RELEASE_KERNEL if the kernel mutex should
-			be temporarily released in the call; otherwise
-			SESS_NOT_RELEASE_KERNEL */
-{
-	ulint	ret;
-
-	ut_ad((rel_ker == SESS_NOT_RELEASE_KERNEL)
-					|| (rel_ker == SESS_RELEASE_KERNEL));
-	ut_ad(mutex_own(&kernel_mutex));
-	ut_ad(len <= com_endpoint_get_max_size(sess->endpoint));
-	ut_ad(len >= SESS_SRV_MSG_DATA);
-
-	if (sess->client_waits == FALSE) {
-		sess_error_low(sess, SESS_ERR_EXTRANEOUS_SRV_MSG, NULL);
-		
-		return(1);
-	}
-	
-	/* The client will now receive an error message: if the session is
-	in the error state, we can reset it to the normal state */
-	
-	if (sess->state == SESS_ERROR) {
-		sess->state = SESS_ACTIVE;
-	}
-	
-	/* We reset the client_waits flag to FALSE, regardless of whether the
-	message gets delivered to the client or not. This convention makes
-	things simpler. */
-
-	sess->client_waits = FALSE;
-
-	if (rel_ker == SESS_RELEASE_KERNEL) {
-
-		mutex_exit(&kernel_mutex);
-	}
-
-	ret = com_sendto(sess->endpoint, buf, len, sess->addr_buf,
-							sess->addr_len);
-	if (rel_ker == SESS_RELEASE_KERNEL) {
-
-		mutex_enter(&kernel_mutex);
-	}
-
-	if (ret != 0) {
-		sess_error_low(sess, SESS_ERR_REPLY_FAILED, NULL);
-	}
-	
-	return(ret);
-}
-
-/*************************************************************************
-Sends a message to the client. If the session is in the error state, sends
-the error message instead of buf. */
-static
-ulint
-sess_srv_msg_send(
-/*==============*/
-			/* out: 0 if success, else error number */
-	sess_t*	sess,	/* in: session object */
-	byte*	buf,	/* in: message buffer */
-	ulint	len,	/* in: message length */
-	ulint	rel_ker)/* in: SESS_RELEASE_KERNEL if the kernel mutex should
-			be temporarily released in the call; otherwise
-			SESS_NOT_RELEASE_KERNEL */
-{
-	ulint	ret;
-
-	ut_ad(mutex_own(&kernel_mutex));
-
-	if (sess->state == SESS_ERROR) {
-
-		sess_srv_msg_send_error(sess);
-
-		return(2);
-	}
-
-	ret = sess_srv_msg_send_low(sess, buf, len, rel_ker);
-
-	return(ret);
-}
-
-/*************************************************************************
-Sends a simple message to client. */
-
-void
-sess_srv_msg_send_simple(
-/*=====================*/
-	sess_t*	sess,		/* in: session object */
-	ulint	type,		/* in: message type */
-	ulint	rel_kernel)	/* in: SESS_RELEASE_KERNEL or
-				SESS_NOT_RELEASE_KERNEL */
-{
-	byte	buf[SESS_SRV_MSG_DATA];
-
-	ut_ad(mutex_own(&kernel_mutex));
-
-	sess_srv_msg_init(sess, buf, type);
-
-	sess_srv_msg_send(sess, buf, SESS_SRV_MSG_DATA, rel_kernel);
-}
-
-/*************************************************************************
-Communicates an error message to the client. If sess->client_waits is not
-TRUE, puts the session to error state and does not try to send the error
-message. */
-static
-void
-sess_srv_msg_send_error(
-/*====================*/
-	sess_t*	sess)	/* in: session object */
-{
-	ulint	err_no;
-	byte*	err_str;
-	ulint	err_len;
-	ulint	max_len;
-	byte	buf[SESS_ERR_BUF_SIZE];
-	ulint	ret;
-	
-	ut_ad(sess->client_waits);
-	ut_ad(mutex_own(&kernel_mutex));
-	ut_ad(sess->state == SESS_ERROR);
-	ut_ad(!UT_LIST_GET_FIRST((sess->trx)->signals));
-
-	if (!sess->client_waits) {
-		/* Cannot send the error message now: leave the session to
-		the error state and send it later */
-
-		return;
-	}
-
-	err_no = sess->err_no;
-	err_str = (byte*)sess->err_str;
-	err_len = sess->err_len;
-
-	max_len = ut_min(SESS_ERR_BUF_SIZE,
-				com_endpoint_get_max_size(sess->endpoint));
-	
-	sess_srv_msg_init(sess, buf, SESS_SRV_ERROR);
-
-	if (err_len + SESS_SRV_MSG_DATA > max_len) {
-
-		err_len = max_len - SESS_SRV_MSG_DATA;
-	}
-
-	ut_memcpy(buf + SESS_SRV_MSG_DATA, err_str, err_len);
-
-	ret = sess_srv_msg_send_low(sess, buf, SESS_SRV_MSG_DATA + err_len,
-						SESS_NOT_RELEASE_KERNEL);
-}
-
-/*************************************************************************
-Copies error info to a session. Sends to the transaction a signal which will
-rollback the latest incomplete SQL statement and then send the error message
-to the client. NOTE: This function will take care of the freeing of the error
-string, thus the caller must supply a copy of the error string. */
-static
-void
-sess_error_low(
-/*===========*/
-	sess_t*	sess,	/* in: session object */
-	ulint	err_no,	/* in: error number */
-	char*	err_str)/* in, own: error string or NULL;
-			NOTE: the function will take care of freeing of the
-			string! */
-{
-	ut_ad(mutex_own(&kernel_mutex));
-
-	UT_DULINT_INC(sess->error_count);
-
-	printf("Error string::: %s\n", err_str);
-
-	if (sess->state == SESS_ERROR) {
-		/* Ignore the error because the session is already in the
-		error state */
-
-		if (err_str) {
-			mem_free(err_str);
-		}
-
-		return;
-	}
-	
-	sess->err_no = err_no;
-
-	if (sess->err_str) {
-		mem_free(sess->err_str);
-	}
-
-	sess->err_str = err_str;
-	sess->err_len = ut_strlen(err_str);
-	sess->state = SESS_ERROR;
-
-	if (sess->big_msg) {
-
-		mem_free(sess->big_msg);
-	}
-
-	/* Send a signal which will roll back the latest incomplete SQL
-	statement: the error message will be sent to the client by the error
-	handling mechanism after the rollback is completed. */
-	
-	trx_sig_send(sess->trx, TRX_SIG_ERROR_OCCURRED, TRX_SIG_SELF, FALSE,
-							NULL, NULL, NULL);
-}
-
-
-/***************************************************************************
-When a command has been completed, this function sends the message about it
-to the client. */
-
-void
-sess_command_completed_message(
-/*===========================*/
-	sess_t*	sess,	/* in: session */
-	byte*	msg,	/* in: message buffer */
-	ulint	len)	/* in: message data length */
-{
-	mutex_enter(&kernel_mutex);
-
-	sess_srv_msg_send(sess, msg, SESS_SRV_MSG_DATA + len,
-							SESS_RELEASE_KERNEL);
-	mutex_exit(&kernel_mutex);
-}
diff --git a/innobase/ut/ut0dbg.c b/innobase/ut/ut0dbg.c
index 534fdf072f1..3697e31050f 100644
--- a/innobase/ut/ut0dbg.c
+++ b/innobase/ut/ut0dbg.c
@@ -18,10 +18,16 @@ ibool	ut_dbg_stop_threads	= FALSE;
 /* Null pointer used to generate memory trap */
 
 ulint*	ut_dbg_null_ptr		= NULL;
+
 const char*	ut_dbg_msg_assert_fail =
 "InnoDB: Assertion failure in thread %lu in file %s line %lu\n";
 const char*	ut_dbg_msg_trap =
 "InnoDB: We intentionally generate a memory trap.\n"
-"InnoDB: Send a detailed bug report to mysql@lists.mysql.com.\n";
+"InnoDB: Send a detailed bug report to mysql@lists.mysql.com.\n"
+"InnoDB: If you get repeated assertion failures or crashes, even\n"
+"InnoDB: immediately after the mysqld startup, there may be\n"
+"InnoDB: corruption in the InnoDB tablespace. See section 6.1 of\n"
+"InnoDB: http://www.innodb.com/ibman.php about forcing recovery.\n";
+
 const char*	ut_dbg_msg_stop =
 "InnoDB: Thread %lu stopped in file %s line %lu\n";