Commit 80fe399f authored by unknown's avatar unknown
Browse files

InnoDB: send diagnostic output to stderr or files 

instead of stdout or fixed-size memory buffers


innobase/btr/btr0btr.c:
  Output to stderr; quote table and index names
innobase/btr/btr0cur.c:
  Output to stderr; quote table and index names
innobase/btr/btr0sea.c:
  Output to stderr
innobase/buf/buf0buf.c:
  Output to stderr; quote table and index names
innobase/buf/buf0flu.c:
  Output to stderr
innobase/buf/buf0lru.c:
  Output to stderr
innobase/buf/buf0rea.c:
  Output to stderr
innobase/data/data0data.c:
  Remove dtuple_validate() unless #ifdef UNIV_DEBUG
  Remove unnecessary sprintf() calls
  Output to stderr
innobase/data/data0type.c:
  Output to stderr
innobase/dict/dict0boot.c:
  Remove dummy call to printf()
innobase/dict/dict0crea.c:
  Output diagnostic information to stream, not to memory
innobase/dict/dict0dict.c:
  Output diagnostics to a file, not to a memory buffer
innobase/dict/dict0load.c:
  Output to stderr; quote table and index names
innobase/eval/eval0eval.c:
  Output to stderr
innobase/fil/fil0fil.c:
  Output to stderr
innobase/fsp/fsp0fsp.c:
  Output to stderr
  Avoid sprintf()
innobase/fut/fut0lst.c:
  Output to stderr
innobase/ha/ha0ha.c:
  Output to stream, not to memory buffer
innobase/ibuf/ibuf0ibuf.c:
  Output to stderr
  Avoid sprintf()
innobase/include/buf0buf.h:
  Output to stream, not to memory buffer
innobase/include/buf0buf.ic:
  Use %p for displaying pointers
innobase/include/data0data.h:
  Remove dtuple_sprintf()
innobase/include/dict0dict.h:
  Output to stream, not to memory buffer
innobase/include/ha0ha.h:
  Output to stream, not to memory buffer
innobase/include/ibuf0ibuf.h:
  Output to stream, not to memory buffer
innobase/include/lock0lock.h:
  Output to stream, not to memory buffer
innobase/include/log0log.h:
  Output to stream, not to memory buffer
innobase/include/mtr0log.ic:
  Output to stderr
  Display pointers with %p
innobase/include/os0file.h:
  Output to stream, not to memory buffer
innobase/include/rem0rec.h:
  Remove rec_sprintf()
innobase/include/rem0rec.ic:
  Output to stderr
innobase/include/row0sel.ic:
  Output to stderr
innobase/include/row0upd.ic:
  Quote table and index names
innobase/include/srv0srv.h:
  Remove srv_sprintf_innodb_monitor()
innobase/include/sync0arr.h:
  Output to stream, not to memory buffer
innobase/include/sync0sync.h:
  Output to stream, not to memory buffer
innobase/include/trx0sys.h:
  Output to stderr
innobase/include/trx0trx.h:
  Output to stream, not to memory buffer
innobase/include/ut0ut.h:
  Remove ut_sprintf_buf()
  Add ut_print_name(), ut_print_namel() and ut_copy_file()
innobase/lock/lock0lock.c:
  Output to stream, not to memory buffer
innobase/log/log0log.c:
  Output to stderr
innobase/log/log0recv.c:
  Output to stderr
innobase/mem/mem0dbg.c:
  Output to stderr
innobase/mtr/mtr0log.c:
  Display pointers with %p
innobase/mtr/mtr0mtr.c:
  Output to stderr
innobase/os/os0file.c:
  Output to stream, not to memory buffer
innobase/os/os0proc.c:
  Output to stderr
innobase/os/os0thread.c:
  Output to stderr
innobase/page/page0cur.c:
  Output to stderr
innobase/page/page0page.c:
  Avoid sprintf()
  Output to stderr instead of stdout
innobase/pars/pars0opt.c:
  Output to stderr instead of stdout
innobase/rem/rem0rec.c:
  Remove rec_sprintf()
  Output to stderr instead of stdout
innobase/row/row0ins.c:
  Output diagnostics to stream instead of memory buffer
innobase/row/row0mysql.c:
  Output to stderr instead of stdout
  Quote table and index names
innobase/row/row0purge.c:
  Output to stderr instead of stdout
innobase/row/row0row.c:
  Quote table and index names
innobase/row/row0sel.c:
  Output to stderr instead of stdout
  Quote table and index names
innobase/row/row0umod.c:
  Avoid sprintf()
  Quote table and index names
innobase/row/row0undo.c:
  Output to stderr instead of stdout
innobase/row/row0upd.c:
  Avoid sprintf()
innobase/srv/srv0srv.c:
  Output to stderr instead of stdout
innobase/srv/srv0start.c:
  Handle srv_monitor_file
  Make some global variables static
innobase/sync/sync0arr.c:
  Output to stderr instead of stdout
  Output to stream instead of memory buffer
innobase/sync/sync0rw.c:
  Output to stderr instead of stdout
innobase/sync/sync0sync.c:
  Output to stderr instead of stdout
  Output to stream instead of memory buffer
innobase/trx/trx0purge.c:
  Output to stderr instead of stdout
innobase/trx/trx0rec.c:
  Quote index and table names
  Avoid sprintf()
innobase/trx/trx0roll.c:
  Quote identifier names
  Output to stderr instead of stdout
innobase/trx/trx0sys.c:
  Output to stderr instead of stdout
innobase/trx/trx0trx.c:
  Output to stream instead of memory buffer
innobase/trx/trx0undo.c:
  Output to stderr instead of stdout
innobase/ut/ut0ut.c:
  Declare mysql_get_identifier_quote_char()
  Remove ut_sprintf_buf()
  Add ut_print_name() and ut_print_namel()
  Add ut_copy_file()
sql/ha_innodb.cc:
  innobase_mysql_print_thd(): output to stream, not to memory buffer
  Add mysql_get_identifier_quote_char()
  Remove unused function innobase_print_error()
  Display pointers with %p
  Buffer InnoDB output via files, not via statically allocated memory
parent d809c441

innobase/btr/btr0btr.c

+141 −117
Original line number Diff line number Diff line
@@ -588,28 +588,29 @@ btr_page_get_father_for_rec( 


	if (btr_node_ptr_get_child_page_no(node_ptr) !=

                                                buf_frame_get_page_no(page)) {

		fprintf(stderr,

"InnoDB: Dump of the child page:\n");

		fputs("InnoDB: Dump of the child page:\n", stderr);

		buf_page_print(buf_frame_align(page));

		fprintf(stderr,

"InnoDB: Dump of the parent page:\n");

		fputs("InnoDB: Dump of the parent page:\n", stderr);

		buf_page_print(buf_frame_align(node_ptr));



      		fprintf(stderr,

"InnoDB: Corruption of an index tree: table %s, index %s,\n"

		fputs("InnoDB: Corruption of an index tree: table ", stderr);

		ut_print_name(stderr,

			UT_LIST_GET_FIRST(tree->tree_indexes)->table_name);

		fputs(", index ", stderr);

		ut_print_name(stderr,

			UT_LIST_GET_FIRST(tree->tree_indexes)->name);

		fprintf(stderr, ",\n"

"InnoDB: father ptr page no %lu, child page no %lu\n",

                    (UT_LIST_GET_FIRST(tree->tree_indexes))->table_name,

                    (UT_LIST_GET_FIRST(tree->tree_indexes))->name,

			btr_node_ptr_get_child_page_no(node_ptr),

			buf_frame_get_page_no(page));

     		page_rec_print(page_rec_get_next(page_get_infimum_rec(page)));

     		page_rec_print(node_ptr);



      		fprintf(stderr,

		fputs(

"InnoDB: You should dump + drop + reimport the table to fix the\n"

"InnoDB: corruption. If the crash happens at the database startup, see\n"

"InnoDB: section 6.1 of http://www.innodb.com/ibman.html about forcing\n"

"InnoDB: recovery. Then dump + drop + reimport.\n");

"InnoDB: section 6.1 of http://www.innodb.com/ibman.php about forcing\n"

"InnoDB: recovery. Then dump + drop + reimport.\n", stderr);

	}



	ut_a(btr_node_ptr_get_child_page_no(node_ptr) ==
@@ -1050,7 +1051,7 @@ btr_root_raise_and_insert( 


	/* We play safe and reset the free bits for the new page */



/*	printf("Root raise new page no %lu\n",

/*	fprintf(stderr, "Root raise new page no %lu\n",

					buf_frame_get_page_no(new_page)); */



	ibuf_reset_free_bits(UT_LIST_GET_FIRST(tree->tree_indexes),
@@ -1599,7 +1600,7 @@ btr_page_split_and_insert( 


	/* 5. Move then the records to the new page */

	if (direction == FSP_DOWN) {

/*		printf("Split left\n"); */

/*		fputs("Split left\n", stderr); */



		page_move_rec_list_start(new_page, page, move_limit, mtr);

		left_page = new_page;
@@ -1607,7 +1608,7 @@ btr_page_split_and_insert( 


		lock_update_split_left(right_page, left_page);

	} else {

/*		printf("Split right\n"); */

/*		fputs("Split right\n", stderr); */



		page_move_rec_list_end(new_page, page, move_limit, mtr);

		left_page = page;
@@ -1643,7 +1644,7 @@ btr_page_split_and_insert( 
		ibuf_update_free_bits_for_two_pages_low(cursor->index,

							left_page,

							right_page, mtr);

		/* printf("Split and insert done %lu %lu\n",

		/* fprintf(stderr, "Split and insert done %lu %lu\n",

				buf_frame_get_page_no(left_page),

				buf_frame_get_page_no(right_page)); */

		return(rec);
@@ -1663,7 +1664,7 @@ btr_page_split_and_insert( 
		/* We play safe and reset the free bits for new_page */

		ibuf_reset_free_bits(cursor->index, new_page);



		/* printf("Split second round %lu\n",

		/* fprintf(stderr, "Split second round %lu\n",

					buf_frame_get_page_no(page)); */

		n_iterations++;

		ut_ad(n_iterations < 2);
@@ -1677,7 +1678,7 @@ btr_page_split_and_insert( 


	ibuf_update_free_bits_for_two_pages_low(cursor->index, left_page,

							right_page, mtr);

	/* printf("Split and insert done %lu %lu\n",

	/* fprintf(stderr, "Split and insert done %lu %lu\n",

				buf_frame_get_page_no(left_page),

				buf_frame_get_page_no(right_page)); */
@@ -1924,7 +1925,7 @@ btr_compress( 
	left_page_no = btr_page_get_prev(page, mtr);

	right_page_no = btr_page_get_next(page, mtr);



/*	printf("Merge left page %lu right %lu \n", left_page_no,

/*	fprintf(stderr, "Merge left page %lu right %lu \n", left_page_no,

							right_page_no); */



	node_ptr = btr_page_get_father_node_ptr(tree, page, mtr);
@@ -2174,8 +2175,9 @@ btr_print_size( 
	mtr_t		mtr;



	if (tree->type & DICT_IBUF) {

		printf(

	"Sorry, cannot print info of an ibuf tree: use ibuf functions\n");

		fputs(

	"Sorry, cannot print info of an ibuf tree: use ibuf functions\n",

			stderr);



		return;

	}
@@ -2186,14 +2188,14 @@ btr_print_size( 


	seg = root + PAGE_HEADER + PAGE_BTR_SEG_TOP;



	printf("INFO OF THE NON-LEAF PAGE SEGMENT\n");

	fputs("INFO OF THE NON-LEAF PAGE SEGMENT\n", stderr);

	fseg_print(seg, &mtr);



	if (!(tree->type & DICT_UNIVERSAL)) {



		seg = root + PAGE_HEADER + PAGE_BTR_SEG_LEAF;



		printf("INFO OF THE LEAF PAGE SEGMENT\n");

		fputs("INFO OF THE LEAF PAGE SEGMENT\n", stderr);

		fseg_print(seg, &mtr);

	}
@@ -2221,7 +2223,7 @@ btr_print_recursive( 
	

	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),

							MTR_MEMO_PAGE_X_FIX));

	printf("NODE ON LEVEL %lu page number %lu\n",

	fprintf(stderr, "NODE ON LEVEL %lu page number %lu\n",

		btr_page_get_level(page, mtr), buf_frame_get_page_no(page));

	

	page_print(page, width, width);
@@ -2267,8 +2269,8 @@ btr_print_tree( 
	mtr_t	mtr;

	page_t*	root;



	printf("--------------------------\n");

	printf("INDEX TREE PRINT\n");

	fputs("--------------------------\n"

		"INDEX TREE PRINT\n", stderr);



	mtr_start(&mtr);
@@ -2324,6 +2326,22 @@ btr_check_node_ptr( 
	return(TRUE);

}



/****************************************************************

Display identification information for a record. */

static

void

btr_index_rec_validate_report(

/*==========================*/

	page_t*		page,	/* in: index page */

	rec_t*		rec,	/* in: index record */

	dict_index_t*	index)	/* in: index */

{

	fputs("InnoDB: Record in ", stderr);

	dict_index_name_print(stderr, index);

	fprintf(stderr, ", page %lu, at offset %lu\n",

		buf_frame_get_page_no(page), (ulint)(rec - page));

}



/****************************************************************

Checks the size and number of fields in a record based on the definition of

the index. */
@@ -2338,13 +2356,10 @@ btr_index_rec_validate( 
					should print hex dump of record

					and page on error */

{

	dtype_t* type;

	byte*	data;

	ulint	len;

	ulint	n;

	ulint	i;

	page_t*	page;

	char	err_buf[1000];



	page = buf_frame_align(rec);
@@ -2359,11 +2374,8 @@ btr_index_rec_validate( 
	n = dict_index_get_n_fields(index);



	if (rec_get_n_fields(rec) != n) {

		fprintf(stderr,

"InnoDB: Record in index %s in table %s, page %lu, at offset %lu\n"

"InnoDB: has %lu fields, should have %lu\n",

			index->name, index->table_name,

			buf_frame_get_page_no(page), (ulint)(rec - page),

		btr_index_rec_validate_report(page, rec, index);

		fprintf(stderr, "InnoDB: has %lu fields, should have %lu\n",

			rec_get_n_fields(rec), n);



		if (!dump_on_error) {
@@ -2373,16 +2385,17 @@ btr_index_rec_validate( 


		buf_page_print(page);



		rec_sprintf(err_buf, 900, rec);

	  	fprintf(stderr, "InnoDB: corrupt record %s\n", err_buf);

		fputs("InnoDB: corrupt record ", stderr);

		rec_print(stderr, rec);

		putc('\n', stderr);



		return(FALSE);

	}



	for (i = 0; i < n; i++) {

		data = rec_get_nth_field(rec, i, &len);

		dtype_t*	type = dict_index_get_nth_type(index, i);



		type = dict_index_get_nth_type(index, i);

		rec_get_nth_field(rec, i, &len);

		

		if ((dict_index_get_nth_field(index, i)->prefix_len == 0

		    && len != UNIV_SQL_NULL && dtype_is_fixed_size(type)
@@ -2393,12 +2406,9 @@ btr_index_rec_validate( 
		    && len !=

			   dict_index_get_nth_field(index, i)->prefix_len)) {



			btr_index_rec_validate_report(page, rec, index);

			fprintf(stderr,

"InnoDB: Record in index %s in table %s, page %lu, at offset %lu\n"

"InnoDB: field %lu len is %lu, should be %lu\n",

				index->name, index->table_name,

				buf_frame_get_page_no(page),

				(ulint)(rec - page),

				i, len, dtype_get_fixed_size(type));



			if (!dump_on_error) {
@@ -2408,9 +2418,9 @@ btr_index_rec_validate( 


			buf_page_print(page);



			rec_sprintf(err_buf, 900, rec);

	  		fprintf(stderr,

                             "InnoDB: corrupt record %s\n", err_buf);

			fputs("InnoDB: corrupt record ", stderr);

			rec_print(stderr, rec);

			putc('\n', stderr);



			return(FALSE);

		}
@@ -2430,7 +2440,6 @@ btr_index_page_validate( 
	page_t*		page,	/* in: index page */

	dict_index_t*	index)	/* in: index */

{

	rec_t*		rec;

	page_cur_t 	cur;

	ibool		ret	= TRUE;
@@ -2438,14 +2447,12 @@ btr_index_page_validate( 
	page_cur_move_to_next(&cur);



	for (;;) {

		rec = (&cur)->rec;



		if (page_cur_is_after_last(&cur)) {



			break;

		}



		if (!btr_index_rec_validate(rec, index, TRUE)) {

		if (!btr_index_rec_validate(cur.rec, index, TRUE)) {



			return(FALSE);

		}
@@ -2456,6 +2463,46 @@ btr_index_page_validate( 
	return(ret);	

}



/****************************************************************

Report an error on one page of an index tree. */

static

void

btr_validate_report1(

				/* out: TRUE if ok */

	dict_index_t*	index,	/* in: index */

	ulint		level,	/* in: B-tree level */

	page_t*		page)	/* in: index page */

{

	fprintf(stderr, "InnoDB: Error in page %lu of ",

		buf_frame_get_page_no(page));

	dict_index_name_print(stderr, index);

	if (level) {

		fprintf(stderr, ", index tree level %lu", level);

	}

	putc('\n', stderr);

}



/****************************************************************

Report an error on two pages of an index tree. */

static

void

btr_validate_report2(

				/* out: TRUE if ok */

	dict_index_t*	index,	/* in: index */

	ulint		level,	/* in: B-tree level */

	page_t*		page1,	/* in: first index page */

	page_t*		page2)	/* in: second index page */

{

	fprintf(stderr, "InnoDB: Error in pages %lu and %lu of ",

		buf_frame_get_page_no(page1),

		buf_frame_get_page_no(page2));

	dict_index_name_print(stderr, index);

	if (level) {

		fprintf(stderr, ", index tree level %lu", level);

	}

	putc('\n', stderr);

}



/****************************************************************

Validates index tree level. */

static
@@ -2481,7 +2528,6 @@ btr_validate_level( 
	ibool		ret	= TRUE;

	dict_index_t*	index;

	mtr_t		mtr;

	char		err_buf[1000];

	

	mtr_start(&mtr);
@@ -2512,10 +2558,7 @@ btr_validate_level( 
	/* Check ordering etc. of records */



	if (!page_validate(page, index)) {

		fprintf(stderr,

"InnoDB: Error in page %lu in index %s table %s, index tree level %lu\n",

			buf_frame_get_page_no(page), index->name,

			index->table_name, level);

		btr_validate_report1(index, level, page);



		ret = FALSE;

	} else if (level == 0) {
@@ -2545,25 +2588,22 @@ btr_validate_level( 
			page_rec_get_next(page_get_infimum_rec(right_page)),

			UT_LIST_GET_FIRST(tree->tree_indexes)) >= 0) {



 			fprintf(stderr,

		"InnoDB: Error on pages %lu and %lu in index %s table %s\n",

				buf_frame_get_page_no(page),

				right_page_no,

				index->name, index->table_name);

			btr_validate_report2(index, level, page, right_page);



			fprintf(stderr,

			"InnoDB: records in wrong order on adjacent pages\n");

			fputs("InnoDB: records in wrong order"

				" on adjacent pages\n", stderr);



			buf_page_print(page);

			buf_page_print(right_page);



			rec_sprintf(err_buf, 900,

				page_rec_get_prev(page_get_supremum_rec(page)));

	  		fprintf(stderr, "InnoDB: record %s\n", err_buf);



			rec_sprintf(err_buf, 900,

			page_rec_get_next(page_get_infimum_rec(right_page)));

	  		fprintf(stderr, "InnoDB: record %s\n", err_buf);

			fputs("InnoDB: record ", stderr);

			rec_print(stderr, page_rec_get_prev(

				page_get_supremum_rec(page)));

			putc('\n', stderr);

			fputs("InnoDB: record ", stderr);

			rec_print(stderr, page_rec_get_next(

				page_get_infimum_rec(right_page)));

			putc('\n', stderr);



	  		ret = FALSE;

	  	}
@@ -2586,32 +2626,27 @@ btr_validate_level( 
		   || node_ptr != btr_page_get_father_for_rec(tree, page,

		   	page_rec_get_prev(page_get_supremum_rec(page)),

								&mtr)) {

 			fprintf(stderr,

			"InnoDB: Error on page %lu in index %s table %s\n",

				buf_frame_get_page_no(page),

				index->name, index->table_name);

			btr_validate_report1(index, level, page);



			fprintf(stderr,

			"InnoDB: node pointer to the page is wrong\n");

			fputs("InnoDB: node pointer to the page is wrong\n",

				stderr);



			buf_page_print(father_page);

			buf_page_print(page);



			rec_sprintf(err_buf, 900, node_ptr);

				

	  		fprintf(stderr, "InnoDB: node ptr %s\n", err_buf);

			fputs("InnoDB: node ptr ", stderr);

			rec_print(stderr, node_ptr);



			fprintf(stderr,

			fprintf(stderr, "\n"

				"InnoDB: node ptr child page n:o %lu\n",

				btr_node_ptr_get_child_page_no(node_ptr));



			rec_sprintf(err_buf, 900,

			fputs("InnoDB: record on page ", stderr);

			rec_print(stderr,

			 	btr_page_get_father_for_rec(tree, page,

		   	 	page_rec_get_prev(page_get_supremum_rec(page)),

					&mtr));



	  		fprintf(stderr, "InnoDB: record on page %s\n",

								err_buf);

			putc('\n', stderr);

		   	ret = FALSE;



		   	goto node_ptr_fails;
@@ -2629,27 +2664,19 @@ btr_validate_level( 


			if (cmp_dtuple_rec(node_ptr_tuple, node_ptr) != 0) {



	 			fprintf(stderr,

			"InnoDB: Error on page %lu in index %s table %s\n",

					buf_frame_get_page_no(page),

					index->name, index->table_name);

				btr_validate_report1(index, level, page);



				buf_page_print(father_page);

				buf_page_print(page);



	  			fprintf(stderr,

                	"InnoDB: Error: node ptrs differ on levels > 0\n");

							

				rec_sprintf(err_buf, 900, node_ptr);

				

	  			fprintf(stderr, "InnoDB: node ptr %s\n",

								err_buf);

				rec_sprintf(err_buf, 900,

				  page_rec_get_next(

				fputs("InnoDB: Error: node ptrs differ"

					" on levels > 0\n"

					"InnoDB: node ptr ", stderr);

				rec_print(stderr, node_ptr);

				fputs("InnoDB: first rec ", stderr);

				rec_print(stderr, page_rec_get_next(

					page_get_infimum_rec(page)));

				

	  			fprintf(stderr, "InnoDB: first rec %s\n",

								err_buf);

				putc('\n', stderr);

		   		ret = FALSE;

				mem_heap_free(heap);
@@ -2681,13 +2708,12 @@ btr_validate_level( 
				if (right_node_ptr !=

						page_rec_get_next(node_ptr)) {

					ret = FALSE;

					fprintf(stderr,

			"InnoDB: node pointer to the right page is wrong\n");

					fputs(

			"InnoDB: node pointer to the right page is wrong\n",

					stderr);



	 				fprintf(stderr,

			"InnoDB: Error on page %lu in index %s table %s\n",

					buf_frame_get_page_no(page),

					index->name, index->table_name);

					btr_validate_report1(index, level,

						page);



					buf_page_print(father_page);

					buf_page_print(page);
@@ -2701,13 +2727,12 @@ btr_validate_level( 
					   		page_get_infimum_rec(

							right_father_page))) {

					ret = FALSE;

					fprintf(stderr,

			"InnoDB: node pointer 2 to the right page is wrong\n");

					fputs(

			"InnoDB: node pointer 2 to the right page is wrong\n",

					stderr);



	 				fprintf(stderr,

			"InnoDB: Error on page %lu in index %s table %s\n",

					buf_frame_get_page_no(page),

					index->name, index->table_name);

					btr_validate_report1(index, level,

						page);



					buf_page_print(father_page);

					buf_page_print(right_father_page);
@@ -2719,13 +2744,12 @@ btr_validate_level( 
				   != btr_page_get_next(father_page, &mtr)) {



					ret = FALSE;

					fprintf(stderr,

			"InnoDB: node pointer 3 to the right page is wrong\n");

					fputs(

			"InnoDB: node pointer 3 to the right page is wrong\n",

					stderr);



	 				fprintf(stderr,

			"InnoDB: Error on page %lu in index %s table %s\n",

					buf_frame_get_page_no(page),

					index->name, index->table_name);

					btr_validate_report1(index, level,

						page);



					buf_page_print(father_page);

					buf_page_print(right_father_page);

innobase/btr/btr0cur.c

+41 −47
Original line number Diff line number Diff line
@@ -830,6 +830,24 @@ btr_cur_ins_lock_and_undo( 
	return(DB_SUCCESS);

}



/*****************************************************************

Report information about a transaction. */

static

void

btr_cur_trx_report(

/*===============*/

	const trx_t*		trx,	/* in: transaction */

	const dict_index_t*	index,	/* in: index */

	const char*		op)	/* in: operation */

{

	fprintf(stderr, "Trx with id %lu %lu going to ",

		ut_dulint_get_high(trx->id),

		ut_dulint_get_low(trx->id));

	fputs(op, stderr);

	dict_index_name_print(stderr, index);

	putc('\n', stderr);

}



/*****************************************************************

Tries to perform an insert to a page in an index tree, next to cursor.

It is assumed that mtr holds an x-latch on the page. The operation does
@@ -877,18 +895,13 @@ btr_cur_optimistic_insert( 
	index = cursor->index;



	if (!dtuple_check_typed_no_assert(entry)) {

		fprintf(stderr,

"InnoDB: Error in a tuple to insert into table %s index %s\n",

					index->table_name, index->name);

		fputs("InnoDB: Error in a tuple to insert into ", stderr);

		dict_index_name_print(stderr, index);

	}

	

	if (btr_cur_print_record_ops && thr) {

		printf(

	"Trx with id %lu %lu going to insert to table %s index %s\n",

		ut_dulint_get_high(thr_get_trx(thr)->id),

		ut_dulint_get_low(thr_get_trx(thr)->id),

		index->table_name, index->name);

		dtuple_print(entry);

		btr_cur_trx_report(thr_get_trx(thr), index, "insert into ");

		dtuple_print(stderr, entry);

	}

	

	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
@@ -981,20 +994,15 @@ btr_cur_optimistic_insert( 


		*rec = page_cur_tuple_insert(page_cursor, entry, mtr);



		if (!(*rec)) {

			char* err_buf = mem_alloc(1000);



			dtuple_sprintf(err_buf, 900, entry);

			

			fprintf(stderr,

	"InnoDB: Error: cannot insert tuple %s to index %s of table %s\n"

	"InnoDB: max insert size %lu\n",

			err_buf, index->name, index->table->name, max_size);



			mem_free(err_buf);

		if (!*rec) {

			fputs("InnoDB: Error: cannot insert tuple ", stderr);

			dtuple_print(stderr, entry);

			fputs(" into ", stderr);

			dict_index_name_print(stderr, index);

			fprintf(stderr, "\nInnoDB: max insert size %lu\n",

				max_size);

			ut_error;

		}

		

		ut_a(*rec); /* <- We calculated above the record would fit */

	}



#ifdef BTR_CUR_HASH_ADAPT
@@ -1010,7 +1018,8 @@ btr_cur_optimistic_insert( 
		lock_update_insert(*rec);

	}



/*	printf("Insert to page %lu, max ins size %lu, rec %lu ind type %lu\n",

/*	fprintf(stderr, "Insert into page %lu, max ins size %lu,"

		" rec %lu ind type %lu\n",

			buf_frame_get_page_no(page), max_size,

					rec_size + PAGE_DIR_SLOT_SIZE, type);

*/
@@ -1361,12 +1370,8 @@ btr_cur_update_in_place( 
	trx = thr_get_trx(thr);

	

	if (btr_cur_print_record_ops && thr) {

		printf(

	"Trx with id %lu %lu going to update table %s index %s\n",

		ut_dulint_get_high(thr_get_trx(thr)->id),

		ut_dulint_get_low(thr_get_trx(thr)->id),

		index->table_name, index->name);

		rec_print(rec);

		btr_cur_trx_report(trx, index, "update ");

		rec_print(stderr, rec);

	}



	/* Do lock checking and undo logging */
@@ -1465,12 +1470,8 @@ btr_cur_optimistic_update( 
	index = cursor->index;

	

	if (btr_cur_print_record_ops && thr) {

		printf(

	"Trx with id %lu %lu going to update table %s index %s\n",

		ut_dulint_get_high(thr_get_trx(thr)->id),

		ut_dulint_get_low(thr_get_trx(thr)->id),

		index->table_name, index->name);

		rec_print(rec);

		btr_cur_trx_report(thr_get_trx(thr), index, "update ");

		rec_print(stderr, rec);

	}



	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
@@ -2012,12 +2013,8 @@ btr_cur_del_mark_set_clust_rec( 
	index = cursor->index;

	

	if (btr_cur_print_record_ops && thr) {

		printf(

	"Trx with id %lu %lu going to del mark table %s index %s\n",

		ut_dulint_get_high(thr_get_trx(thr)->id),

		ut_dulint_get_low(thr_get_trx(thr)->id),

		index->table_name, index->name);

		rec_print(rec);

		btr_cur_trx_report(thr_get_trx(thr), index, "del mark ");

		rec_print(stderr, rec);

	}



	ut_ad(index->type & DICT_CLUSTERED);
@@ -2152,12 +2149,9 @@ btr_cur_del_mark_set_sec_rec( 
	rec = btr_cur_get_rec(cursor);



	if (btr_cur_print_record_ops && thr) {

		printf(

	"Trx with id %lu %lu going to del mark table %s index %s\n",

		ut_dulint_get_high(thr_get_trx(thr)->id),

		ut_dulint_get_low(thr_get_trx(thr)->id),

		cursor->index->table_name, cursor->index->name);

		rec_print(rec);

		btr_cur_trx_report(thr_get_trx(thr), cursor->index,

				"del mark ");

		rec_print(stderr, rec);

	}



	err = lock_sec_rec_modify_check_and_lock(flags, rec, cursor->index,

innobase/btr/btr0sea.c

+13 −17
Original line number Diff line number Diff line
@@ -803,7 +803,7 @@ btr_search_guess_on_hash( 


		success = FALSE;

/*

		printf("Tree id %lu, page index id %lu fold %lu\n",

		fprintf(stderr, "Tree id %lu, page index id %lu fold %lu\n",

				ut_dulint_get_low(tree_id),

				ut_dulint_get_low(btr_page_get_index_id(page)),

				fold);
@@ -1045,7 +1045,7 @@ btr_search_drop_page_hash_when_freed( 
	/* We assume that if the caller has a latch on the page,

	then the caller has already dropped the hash index for the page,

	and we never get here. Therefore we can acquire the s-latch to

	the page without fearing a deadlock. */

	the page without having to fear a deadlock. */

	

	page = buf_page_get(space, page_no, RW_S_LATCH, &mtr);
@@ -1515,8 +1515,9 @@ btr_search_update_hash_on_insert( 


			ha_insert_for_fold(table, ins_fold, ins_rec);

/*

			printf("Hash insert for %s, fold %lu\n",

					cursor->index->name, ins_fold);

			fputs("Hash insert for ", stderr);

			dict_index_name_print(stderr, cursor->index);

			fprintf(stderr, " fold %lu\n", ins_fold);

*/

		} else {

			ha_insert_for_fold(table, next_fold, next_rec);
@@ -1543,7 +1544,6 @@ btr_search_validate(void) 
	ulint		n_page_dumps	= 0;

	ibool		ok		= TRUE;

	ulint		i;

	char		rec_str[500];

	

	rw_lock_x_lock(&btr_search_latch);
@@ -1564,9 +1564,9 @@ btr_search_validate(void) 


				fprintf(stderr,

"  InnoDB: Error in an adaptive hash index pointer to page %lu\n"

"ptr mem address %lu index id %lu %lu, node fold %lu, rec fold %lu\n",

"ptr mem address %p index id %lu %lu, node fold %lu, rec fold %lu\n",

					buf_frame_get_page_no(page),

				(ulint)(node->data),

					node->data,

			ut_dulint_get_high(btr_page_get_index_id(page)),

			ut_dulint_get_low(btr_page_get_index_id(page)),

			node->fold, rec_fold((rec_t*)(node->data),
@@ -1574,16 +1574,12 @@ btr_search_validate(void) 
					block->curr_n_bytes,

					btr_page_get_index_id(page)));



				rec_sprintf(rec_str, 450, (rec_t*)(node->data));



	  			fprintf(stderr,

					"InnoDB: Record %s\n"

					"InnoDB: on that page.", rec_str);



				fprintf(stderr,

"Page mem address %lu, is hashed %lu, n fields %lu, n bytes %lu\n"

				fputs("InnoDB: Record ", stderr);

				rec_print(stderr, (rec_t*)(node->data));

				fprintf(stderr, "\nInnoDB: on that page."

"Page mem address %p, is hashed %lu, n fields %lu, n bytes %lu\n"

"side %lu\n",

			(ulint)page, block->is_hashed, block->curr_n_fields,

			page, block->is_hashed, block->curr_n_fields,

			block->curr_n_bytes, block->curr_side);



				if (n_page_dumps < 20) {

innobase/buf/buf0buf.c

+73 −106

File changed.

Preview size limit exceeded, changes collapsed.

innobase/buf/buf0flu.c

+15 −17
Original line number Diff line number Diff line
@@ -189,7 +189,7 @@ buf_flush_write_complete( 
		buf_pool->LRU_flush_ended++;

	}



	/* 	printf("n pending flush %lu\n",

	/* fprintf(stderr, "n pending flush %lu\n",

		buf_pool->n_flush[block->flush_type]); */



	if ((buf_pool->n_flush[block->flush_type] == 0)
@@ -411,8 +411,8 @@ buf_flush_write_block_low( 
	ut_ad(!ut_dulint_is_zero(block->newest_modification));



#ifdef UNIV_LOG_DEBUG

	printf(

	"Warning: cannot force log to disk in the log debug version!\n");

	fputs("Warning: cannot force log to disk in the log debug version!\n",

		stderr);

#else

	/* Force the log to the disk before writing the modified block */

	log_write_up_to(block->newest_modification, LOG_WAIT_ALL_GROUPS, TRUE);
@@ -489,7 +489,8 @@ buf_flush_try_page( 
		}



		if (buf_debug_prints) {

			printf("Flushing page space %lu, page no %lu \n",

			fprintf(stderr,

				"Flushing page space %lu, page no %lu \n",

				block->space, block->offset);

		}
@@ -548,7 +549,7 @@ buf_flush_try_page( 
		rw_lock_s_lock_gen(&(block->lock), BUF_IO_WRITE);



		if (buf_debug_prints) {

			printf(

			fprintf(stderr,

			"Flushing single page space %lu, page no %lu \n",

						block->space, block->offset);

		}
@@ -592,7 +593,7 @@ buf_flush_try_neighbors( 
		high = offset + 1;

	}



	/* printf("Flush area: low %lu high %lu\n", low, high); */

	/* fprintf(stderr, "Flush area: low %lu high %lu\n", low, high); */

	

	if (high > fil_space_get_size(space)) {

		high = fil_space_get_size(space);
@@ -739,7 +740,7 @@ buf_flush_batch( 
				page_count +=

					buf_flush_try_neighbors(space, offset,

								flush_type);

				/* printf(

				/* fprintf(stderr,

				"Flush type %lu, page no %lu, neighb %lu\n",

				flush_type, offset,

				page_count - old_page_count); */
@@ -779,15 +780,12 @@ buf_flush_batch( 
	buf_flush_buffered_writes();



	if (buf_debug_prints && page_count > 0) {

		if (flush_type == BUF_FLUSH_LRU) {

			printf("Flushed %lu pages in LRU flush\n",

						page_count);

		} else if (flush_type == BUF_FLUSH_LIST) {

			printf("Flushed %lu pages in flush list flush\n",

		ut_a(flush_type == BUF_FLUSH_LRU

			|| flush_type == BUF_FLUSH_LIST);

		fprintf(stderr, flush_type == BUF_FLUSH_LRU

			? "Flushed %lu pages in LRU flush\n"

			: "Flushed %lu pages in flush list flush\n",

			page_count);

		} else {

			ut_error;

		}

	}

	

	return(page_count);