Merge marko@build.mysql.com:/home/bk/mysql-4.1

into hundin.mysql.fi:/home/marko/j/mysql-4.1

innobase/btr/btr0cur.c

@@ -399,7 +399,7 @@ btr_cur_search_to_nth_level(
 retry_page_get:		
 		page = buf_page_get_gen(space, page_no, rw_latch, guess,
 					buf_mode,
-					IB__FILE__, __LINE__,
+					__FILE__, __LINE__,
 					mtr);
 		if (page == NULL) {
 			/* This must be a search to perform an insert;
@@ -580,7 +580,7 @@ btr_cur_open_at_index_side(
 	for (;;) {
 		page = buf_page_get_gen(space, page_no, RW_NO_LATCH, NULL,
 					BUF_GET,
-					IB__FILE__, __LINE__,
+					__FILE__, __LINE__,
 					mtr);
 		ut_ad(0 == ut_dulint_cmp(tree->id,
 						btr_page_get_index_id(page)));
@@ -689,7 +689,7 @@ btr_cur_open_at_rnd_pos(
 	for (;;) {
 		page = buf_page_get_gen(space, page_no, RW_NO_LATCH, NULL,
 					BUF_GET,
-					IB__FILE__, __LINE__,
+					__FILE__, __LINE__,
 					mtr);
 		ut_ad(0 == ut_dulint_cmp(tree->id,
 						btr_page_get_index_id(page)));

innobase/btr/btr0sea.c

@@ -764,7 +764,7 @@ btr_search_guess_on_hash(
 
 		success = buf_page_get_known_nowait(latch_mode, page,
 						BUF_MAKE_YOUNG,
-						IB__FILE__, __LINE__,
+						__FILE__, __LINE__,
 						mtr);
 
 		rw_lock_s_unlock(&btr_search_latch);
@@ -1048,7 +1048,7 @@ btr_search_drop_page_hash_when_freed(
 	having to fear a deadlock. */
 	
 	page = buf_page_get_gen(space, page_no, RW_S_LATCH, NULL,
-				BUF_GET_IF_IN_POOL, IB__FILE__, __LINE__,
+				BUF_GET_IF_IN_POOL, __FILE__, __LINE__,
 				&mtr);
 
 #ifdef UNIV_SYNC_DEBUG

innobase/buf/buf0buf.c

@@ -1048,7 +1048,7 @@ buf_page_get_gen(
 	buf_frame_t*	guess,	/* in: guessed frame or NULL */
 	ulint		mode,	/* in: BUF_GET, BUF_GET_IF_IN_POOL,
 				BUF_GET_NO_LATCH, BUF_GET_NOWAIT */
-	char*		file,	/* in: file name */
+	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line where called */
 	mtr_t*		mtr)	/* in: mini-transaction */
 {
@@ -1257,7 +1257,7 @@ buf_page_optimistic_get_func(
 				frames */
 	dulint		modify_clock,/* in: modify clock value if mode is
 				..._GUESS_ON_CLOCK */
-	char*		file,	/* in: file name */
+	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line where called */
 	mtr_t*		mtr)	/* in: mini-transaction */
 {
@@ -1382,7 +1382,7 @@ buf_page_get_known_nowait(
 	ulint		rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
 	buf_frame_t*	guess,	/* in: the known page frame */
 	ulint		mode,	/* in: BUF_MAKE_YOUNG or BUF_KEEP_OLD */
-	char*		file,	/* in: file name */
+	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line where called */
 	mtr_t*		mtr)	/* in: mini-transaction */
 {
@@ -1742,7 +1742,7 @@ buf_page_create(
 	buf_LRU_add_block(block, FALSE);
 		
 #ifdef UNIV_SYNC_DEBUG
-	buf_block_buf_fix_inc_debug(block, IB__FILE__, __LINE__);
+	buf_block_buf_fix_inc_debug(block, __FILE__, __LINE__);
 #else
 	buf_block_buf_fix_inc(block);
 #endif

innobase/ibuf/ibuf0ibuf.c

@@ -3042,7 +3042,7 @@ loop:
 	if (page) {
 		ibool success = buf_page_get_known_nowait(RW_X_LATCH, page,
 					BUF_KEEP_OLD,
-					IB__FILE__, __LINE__,
+					__FILE__, __LINE__,
 					&mtr);
 		ut_a(success);
 #ifdef UNIV_SYNC_DEBUG

innobase/include/buf0buf.h

@@ -132,7 +132,7 @@ to improve debugging. Only values RW_S_LATCH and RW_X_LATCH are allowed
 in LA! */
 #define buf_page_get(SP, OF, LA, MTR)    buf_page_get_gen(\
 				SP, OF, LA, NULL,\
-				BUF_GET, IB__FILE__, __LINE__, MTR)
+				BUF_GET, __FILE__, __LINE__, MTR)
 /******************************************************************
 Use these macros to bufferfix a page with no latching. Remember not to
 read the contents of the page unless you know it is safe. Do not modify
@@ -141,19 +141,19 @@ error-prone programming not to set a latch, and it should be used
 with care. */
 #define buf_page_get_with_no_latch(SP, OF, MTR)    buf_page_get_gen(\
 				SP, OF, RW_NO_LATCH, NULL,\
-				BUF_GET_NO_LATCH, IB__FILE__, __LINE__, MTR)
+				BUF_GET_NO_LATCH, __FILE__, __LINE__, MTR)
 /******************************************************************
 NOTE! The following macros should be used instead of buf_page_get_gen, to
 improve debugging. Only values RW_S_LATCH and RW_X_LATCH are allowed as LA! */
 #define buf_page_get_nowait(SP, OF, LA, MTR)    buf_page_get_gen(\
 				SP, OF, LA, NULL,\
-				BUF_GET_NOWAIT, IB__FILE__, __LINE__, MTR)
+				BUF_GET_NOWAIT, __FILE__, __LINE__, MTR)
 /******************************************************************
 NOTE! The following macros should be used instead of
 buf_page_optimistic_get_func, to improve debugging. Only values RW_S_LATCH and
 RW_X_LATCH are allowed as LA! */
 #define buf_page_optimistic_get(LA, BL, G, MC, MTR) buf_page_optimistic_get_func(\
-				LA, BL, G, MC, IB__FILE__, __LINE__, MTR)
+				LA, BL, G, MC, __FILE__, __LINE__, MTR)
 /************************************************************************
 This is the general function used to get optimistic access to a database
 page. */
@@ -168,7 +168,7 @@ buf_page_optimistic_get_func(
 				frames */
 	dulint		modify_clock,/* in: modify clock value if mode is
 				..._GUESS_ON_CLOCK */
-	char*		file,	/* in: file name */
+	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line where called */
 	mtr_t*		mtr);	/* in: mini-transaction */
 /************************************************************************
@@ -201,7 +201,7 @@ buf_page_get_known_nowait(
 	ulint		rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
 	buf_frame_t*	guess,	/* in: the known page frame */
 	ulint		mode,	/* in: BUF_MAKE_YOUNG or BUF_KEEP_OLD */
-	char*		file,	/* in: file name */
+	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line where called */
 	mtr_t*		mtr);	/* in: mini-transaction */
 /************************************************************************
@@ -217,7 +217,7 @@ buf_page_get_gen(
 	buf_frame_t*	guess,	/* in: guessed frame or NULL */
 	ulint		mode,	/* in: BUF_GET, BUF_GET_IF_IN_POOL,
 				BUF_GET_NO_LATCH */
-	char*		file,	/* in: file name */
+	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line where called */
 	mtr_t*		mtr);	/* in: mini-transaction */
 /************************************************************************

innobase/include/buf0buf.ic

@@ -585,7 +585,7 @@ buf_page_get_release_on_io(
 
 	frame = buf_page_get_gen(space, offset, rw_latch, guess,
 				BUF_GET_IF_IN_POOL,
-				IB__FILE__, __LINE__,
+				__FILE__, __LINE__,
 				mtr);
 	if (frame != NULL) {
 

innobase/include/mem0mem.h

@@ -64,14 +64,14 @@ heap creation. */
 
 #define mem_heap_create(N)    mem_heap_create_func(\
 						(N), NULL, MEM_HEAP_DYNAMIC,\
-						IB__FILE__, __LINE__)
+						__FILE__, __LINE__)
 /******************************************************************
 Use this macro instead of the corresponding function! Macro for memory
 heap creation. */
 
 #define mem_heap_create_in_buffer(N)	mem_heap_create_func(\
 						(N), NULL, MEM_HEAP_BUFFER,\
-						IB__FILE__, __LINE__)
+						__FILE__, __LINE__)
 /******************************************************************
 Use this macro instead of the corresponding function! Macro for memory
 heap creation. */
@@ -79,7 +79,7 @@ heap creation. */
 #define mem_heap_create_in_btr_search(N) mem_heap_create_func(\
 					(N), NULL, MEM_HEAP_BTR_SEARCH |\
 						MEM_HEAP_BUFFER,\
-						IB__FILE__, __LINE__)
+						__FILE__, __LINE__)
 /******************************************************************
 Use this macro instead of the corresponding function! Macro for fast
 memory heap creation. An initial block of memory B is given by the
@@ -88,14 +88,14 @@ mem_heap_free. See the parameter comment in mem_heap_create_func below. */
 
 #define mem_heap_fast_create(N, B)	mem_heap_create_func(\
 						(N), (B), MEM_HEAP_DYNAMIC,\
-						IB__FILE__, __LINE__)
+						__FILE__, __LINE__)
 
 /******************************************************************
 Use this macro instead of the corresponding function! Macro for memory
 heap freeing. */
 
 #define mem_heap_free(heap) mem_heap_free_func(\
-					  (heap), IB__FILE__, __LINE__)
+					  (heap), __FILE__, __LINE__)
 /*********************************************************************
 NOTE: Use the corresponding macros instead of this function. Creates a
 memory heap which allocates memory from dynamic space. For debugging
@@ -105,26 +105,27 @@ UNIV_INLINE
 mem_heap_t*
 mem_heap_create_func(
 /*=================*/
-				/* out, own: memory heap */
-	ulint	n,		/* in: desired start block size,
-				this means that a single user buffer
-				of size n will fit in the block, 
-				0 creates a default size block;
-				if init_block is not NULL, n tells
-				its size in bytes */
-	void*	init_block,	/* in: if very fast creation is
-				wanted, the caller can reserve some
-				memory from its stack, for example,
-				and pass it as the the initial block
-				to the heap: then no OS call of malloc
-				is needed at the creation. CAUTION:
-				the caller must make sure the initial
-				block is not unintentionally erased
-				(if allocated in the stack), before
-				the memory heap is explicitly freed. */
-	ulint	type,		/* in: MEM_HEAP_DYNAMIC or MEM_HEAP_BUFFER */ 
-	char*   file_name,	/* in: file name where created */
-	ulint	line		/* in: line where created */
+					/* out, own: memory heap */
+	ulint		n,		/* in: desired start block size,
+					this means that a single user buffer
+					of size n will fit in the block, 
+					0 creates a default size block;
+					if init_block is not NULL, n tells
+					its size in bytes */
+	void*		init_block,	/* in: if very fast creation is
+					wanted, the caller can reserve some
+					memory from its stack, for example,
+					and pass it as the the initial block
+					to the heap: then no OS call of malloc
+					is needed at the creation. CAUTION:
+					the caller must make sure the initial
+					block is not unintentionally erased
+					(if allocated in the stack), before
+					the memory heap is explicitly freed. */
+	ulint		type,		/* in: MEM_HEAP_DYNAMIC
+					or MEM_HEAP_BUFFER */ 
+	const char*	file_name,	/* in: file name where created */
+	ulint		line		/* in: line where created */
 	);
 /*********************************************************************
 NOTE: Use the corresponding macro instead of this function. Frees the space
@@ -135,7 +136,7 @@ void
 mem_heap_free_func(
 /*===============*/
 	mem_heap_t*   	heap,  		/* in, own: heap to be freed */
-	char*  		file_name __attribute__((unused)),
+	const char*	file_name __attribute__((unused)),
 					/* in: file name where freed */
 	ulint    	line  __attribute__((unused)));
 					/* in: line where freed */
@@ -206,13 +207,13 @@ mem_heap_get_size(
 Use this macro instead of the corresponding function!
 Macro for memory buffer allocation */
 
-#define mem_alloc(N)    mem_alloc_func((N), IB__FILE__, __LINE__)
+#define mem_alloc(N)    mem_alloc_func((N), __FILE__, __LINE__)
 /******************************************************************
 Use this macro instead of the corresponding function!
 Macro for memory buffer allocation */
 
 #define mem_alloc_noninline(N)    mem_alloc_func_noninline(\
-					  (N), IB__FILE__, __LINE__)
+					  (N), __FILE__, __LINE__)
 /*******************************************************************
 NOTE: Use the corresponding macro instead of this function.
 Allocates a single buffer of memory from the dynamic memory of
@@ -222,11 +223,11 @@ UNIV_INLINE
 void*
 mem_alloc_func(
 /*===========*/
-				/* out, own: free storage, NULL
-				if did not succeed */
-	ulint 	n,              /* in: desired number of bytes */
-	char*  	file_name,  	/* in: file name where created */
-	ulint 	line            /* in: line where created */
+					/* out, own: free storage, NULL
+					if did not succeed */
+	ulint		n,		/* in: desired number of bytes */
+	const char*	file_name,	/* in: file name where created */
+	ulint		line		/* in: line where created */
 );
 /*******************************************************************
 NOTE: Use the corresponding macro instead of this function.
@@ -237,17 +238,17 @@ with mem_free. */
 void*
 mem_alloc_func_noninline(
 /*=====================*/
-				/* out, own: free storage, NULL if did not
-				succeed */
-	ulint   n,              /* in: desired number of bytes */
-	char*  	file_name,	/* in: file name where created */
-	ulint   line		/* in: line where created */
+					/* out, own: free storage,
+					NULL if did not succeed */
+	ulint		n,		/* in: desired number of bytes */
+	const char*	file_name,	/* in: file name where created */
+	ulint		line		/* in: line where created */
 	);
 /******************************************************************
 Use this macro instead of the corresponding function!
 Macro for memory buffer freeing */
 
-#define mem_free(PTR)   mem_free_func((PTR), IB__FILE__, __LINE__)
+#define mem_free(PTR)   mem_free_func((PTR), __FILE__, __LINE__)
 /*******************************************************************
 NOTE: Use the corresponding macro instead of this function.
 Frees a single buffer of storage from
@@ -256,9 +257,9 @@ UNIV_INLINE
 void
 mem_free_func(
 /*==========*/
-	void*   ptr,    	/* in, own: buffer to be freed */
-	char*  	file_name,  	/* in: file name where created */
-	ulint 	line            /* in: line where created */
+	void*		ptr,		/* in, own: buffer to be freed */
+	const char*	file_name,	/* in: file name where created */
+	ulint		line		/* in: line where created */
 );
 /*******************************************************************
 Implements realloc. */
@@ -266,11 +267,12 @@ UNIV_INLINE
 void*
 mem_realloc(
 /*========*/
-			/* out, own: free storage, NULL if did not succeed */
-	void*	buf,	/* in: pointer to an old buffer */
-	ulint   n,	/* in: desired number of bytes */
-	char*  	file_name,/* in: file name where called */
-	ulint 	line);  /* in: line where called */
+					/* out, own: free storage,
+					NULL if did not succeed */
+	void*		buf,		/* in: pointer to an old buffer */
+	ulint		n,		/* in: desired number of bytes */
+	const char*	file_name,	/* in: file name where called */
+	ulint		line);		/* in: line where called */
 
 /**************************************************************************
 Duplicates a NUL-terminated string. */

innobase/include/mem0mem.ic

@@ -16,18 +16,18 @@ Creates a memory heap block where data can be allocated. */
 mem_block_t*
 mem_heap_create_block(
 /*==================*/
-			/* out, own: memory heap block, NULL if did not
-			succeed */
-	mem_heap_t* heap,/* in: memory heap or NULL if first block should
-			be created */
-	ulint	n,	/* in: number of bytes needed for user data, or
-			if init_block is not NULL, its size in bytes */
-	void*	init_block, /* in: init block in fast create, type must be
-			MEM_HEAP_DYNAMIC */
-	ulint 	type,	/* in: type of heap: MEM_HEAP_DYNAMIC or
-			MEM_HEAP_BUFFER */
-	char*  	file_name,/* in: file name where created */
-	ulint 	line);   /* in: line where created */
+				/* out, own: memory heap block,
+				NULL if did not succeed */
+	mem_heap_t*	heap,	/* in: memory heap or NULL if first block
+				should be created */
+	ulint		n,	/* in: number of bytes needed for user data, or
+				if init_block is not NULL, its size in bytes */
+	void*		init_block, /* in: init block in fast create,
+				type must be MEM_HEAP_DYNAMIC */
+	ulint		type,	/* in: type of heap: MEM_HEAP_DYNAMIC or
+				MEM_HEAP_BUFFER */
+	const char*	file_name,/* in: file name where created */
+	ulint		line);	/* in: line where created */
 /**********************************************************************
 Frees a block from a memory heap. */
 
@@ -377,27 +377,27 @@ UNIV_INLINE
 mem_heap_t*
 mem_heap_create_func(
 /*=================*/
-				/* out, own: memory heap */
-	ulint	n,		/* in: desired start block size,
-				this means that a single user buffer
-				of size n will fit in the block, 
-				0 creates a default size block;
-				if init_block is not NULL, n tells
-				its size in bytes */
-	void*	init_block,	/* in: if very fast creation is
-				wanted, the caller can reserve some
-				memory from its stack, for example,
-				and pass it as the the initial block
-				to the heap: then no OS call of malloc
-				is needed at the creation. CAUTION:
-				the caller must make sure the initial
-				block is not unintentionally erased
-				(if allocated in the stack), before
-				the memory heap is explicitly freed. */
-	ulint	type,		/* in: MEM_HEAP_DYNAMIC, or MEM_HEAP_BUFFER
-				possibly ORed to MEM_HEAP_BTR_SEARCH */
-	char*  	file_name,	/* in: file name where created */
-	ulint	line		/* in: line where created */
+					/* out, own: memory heap */
+	ulint		n,		/* in: desired start block size,
+					this means that a single user buffer
+					of size n will fit in the block, 
+					0 creates a default size block;
+					if init_block is not NULL, n tells
+					its size in bytes */
+	void*		init_block,	/* in: if very fast creation is
+					wanted, the caller can reserve some
+					memory from its stack, for example,
+					and pass it as the the initial block
+					to the heap: then no OS call of malloc
+					is needed at the creation. CAUTION:
+					the caller must make sure the initial
+					block is not unintentionally erased
+					(if allocated in the stack), before
+					the memory heap is explicitly freed. */
+	ulint		type,		/* in: MEM_HEAP_DYNAMIC
+					or MEM_HEAP_BUFFER */ 
+	const char*	file_name,	/* in: file name where created */
+	ulint		line		/* in: line where created */
 	)
 {
 	mem_block_t*   block; 
@@ -440,10 +440,9 @@ void
 mem_heap_free_func(
 /*===============*/
 	mem_heap_t*   	heap,  		/* in, own: heap to be freed */
-	char*  		file_name __attribute__((unused)),
+	const char*	file_name __attribute__((unused)),
 					/* in: file name where freed */
 	ulint    	line  __attribute__((unused)))
-					/* in: line where freed */
 {
 	mem_block_t*	block;
 	mem_block_t*	prev_block;
@@ -486,11 +485,11 @@ UNIV_INLINE
 void*
 mem_alloc_func(
 /*===========*/
-				/* out, own: free storage, NULL if did not
-				succeed */
-	ulint   n,              /* in: desired number of bytes */
-	char*  	file_name,	/* in: file name where created */
-	ulint   line		/* in: line where created */
+					/* out, own: free storage, NULL
+					if did not succeed */
+	ulint		n,		/* in: desired number of bytes */
+	const char*	file_name,	/* in: file name where created */
+	ulint		line		/* in: line where created */
 	)
 {
 	mem_heap_t*   	heap; 
@@ -523,9 +522,9 @@ UNIV_INLINE
 void
 mem_free_func(
 /*==========*/
-	void*   ptr,       	/* in, own: buffer to be freed */
-	char*  	file_name,      /* in: file name where created */
-	ulint   line            /* in: line where created */
+	void*		ptr,		/* in, own: buffer to be freed */
+	const char*	file_name,	/* in: file name where created */
+	ulint		line		/* in: line where created */
 	)
 {
 	mem_heap_t*   heap; 
@@ -569,11 +568,12 @@ UNIV_INLINE
 void*
 mem_realloc(
 /*========*/
-			/* out, own: free storage, NULL if did not succeed */
-	void*	buf,	/* in: pointer to an old buffer */
-	ulint   n,	/* in: desired number of bytes */
-	char*  	file_name,/* in: file name where called */
-	ulint 	line)  	/* in: line where called */
+					/* out, own: free storage,
+					NULL if did not succeed */
+	void*		buf,		/* in: pointer to an old buffer */
+	ulint		n,		/* in: desired number of bytes */
+	const char*	file_name,	/* in: file name where called */
+	ulint		line)		/* in: line where called */
 {
 	mem_free(buf);
 

innobase/include/mtr0mtr.h

@@ -198,11 +198,11 @@ mtr_read_dulint(
 	mtr_t*	mtr);	/* in: mini-transaction handle */
 /*************************************************************************
 This macro locks an rw-lock in s-mode. */
-#define mtr_s_lock(B, MTR)	mtr_s_lock_func((B), IB__FILE__, __LINE__,\
+#define mtr_s_lock(B, MTR)	mtr_s_lock_func((B), __FILE__, __LINE__,\
 						(MTR))
 /*************************************************************************
 This macro locks an rw-lock in x-mode. */
-#define mtr_x_lock(B, MTR)	mtr_x_lock_func((B), IB__FILE__, __LINE__,\
+#define mtr_x_lock(B, MTR)	mtr_x_lock_func((B), __FILE__, __LINE__,\
 						(MTR))
 /*************************************************************************
 NOTE! Use the macro above!
@@ -212,7 +212,7 @@ void
 mtr_s_lock_func(
 /*============*/
 	rw_lock_t*	lock,	/* in: rw-lock */
-	char*		file,	/* in: file name */
+	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line number */
 	mtr_t*		mtr);	/* in: mtr */
 /*************************************************************************
@@ -223,7 +223,7 @@ void
 mtr_x_lock_func(
 /*============*/
 	rw_lock_t*	lock,	/* in: rw-lock */
-	char*		file,	/* in: file name */
+	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line number */
 	mtr_t*		mtr);	/* in: mtr */
 

innobase/include/mtr0mtr.ic

@@ -217,7 +217,7 @@ void
 mtr_s_lock_func(
 /*============*/
 	rw_lock_t*	lock,	/* in: rw-lock */
-	char*		file,	/* in: file name */
+	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line number */
 	mtr_t*		mtr)	/* in: mtr */
 {
@@ -236,7 +236,7 @@ void
 mtr_x_lock_func(
 /*============*/
 	rw_lock_t*	lock,	/* in: rw-lock */
-	char*		file,	/* in: file name */
+	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line number */
 	mtr_t*		mtr)	/* in: mtr */
 {

innobase/include/pars0pars.h

@@ -92,7 +92,7 @@ Called by yyparse on error. */
 void
 yyerror(
 /*====*/
-        char*	s);	/* in: error message string */
+	const char*	s);	/* in: error message string */
 /*************************************************************************
 Parses a variable declaration. */
 

innobase/include/sync0arr.h

@@ -51,7 +51,7 @@ sync_array_reserve_cell(
         sync_array_t*	arr,	/* in: wait array */
         void*   	object, /* in: pointer to the object to wait for */
         ulint		type,	/* in: lock request type */
-        char*		file,	/* in: file where requested */
+	const char*	file,	/* in: file where requested */
         ulint		line,	/* in: line where requested */
         ulint*   	index); /* out: index of the reserved cell */
 /**********************************************************************

innobase/include/sync0ipm.ic

@@ -92,7 +92,7 @@ loop:
 	loop_count++;
 	ut_ad(loop_count < 15);
 
-	if (mutex_enter_nowait(mutex, IB__FILE__, __LINE__) == 0) {
+	if (mutex_enter_nowait(mutex, __FILE__, __LINE__) == 0) {
 		/* Succeeded! */
 
 		return(0);
@@ -105,7 +105,7 @@ loop:
 	/* Order is important here: FIRST reset event, then set waiters */
 	ip_mutex_set_waiters(ip_mutex, 1);
 
-	if (mutex_enter_nowait(mutex, IB__FILE__, __LINE__) == 0) {
+	if (mutex_enter_nowait(mutex, __FILE__, __LINE__) == 0) {
 		/* Succeeded! */
 
 		return(0);

innobase/include/sync0rw.h

@@ -62,7 +62,7 @@ location (which must be appropriately aligned). The rw-lock is initialized
 to the non-locked state. Explicit freeing of the rw-lock with rw_lock_free
 is necessary only if the memory block containing it is freed. */
 
-#define rw_lock_create(L)	rw_lock_create_func((L), IB__FILE__, __LINE__)
+#define rw_lock_create(L)	rw_lock_create_func((L), __FILE__, __LINE__)
 /*=====================*/
 /**********************************************************************
 Creates, or rather, initializes an rw-lock object in a specified memory
@@ -74,7 +74,7 @@ void
 rw_lock_create_func(
 /*================*/
 	rw_lock_t*	lock,		/* in: pointer to memory */
-	char*		cfile_name,	/* in: file name where created */
+	const char*	cfile_name,	/* in: file name where created */
 	ulint		cline);		/* in: file line where created */
 /**********************************************************************
 Calling this function is obligatory only if the memory buffer containing
@@ -100,19 +100,19 @@ NOTE! The following macros should be used in rw s-locking, not the
 corresponding function. */
 
 #define rw_lock_s_lock(M)    rw_lock_s_lock_func(\
-					  (M), 0, IB__FILE__, __LINE__)
+					  (M), 0, __FILE__, __LINE__)
 /******************************************************************
 NOTE! The following macros should be used in rw s-locking, not the
 corresponding function. */
 
 #define rw_lock_s_lock_gen(M, P)    rw_lock_s_lock_func(\
-					  (M), (P), IB__FILE__, __LINE__)
+					  (M), (P), __FILE__, __LINE__)
 /******************************************************************
 NOTE! The following macros should be used in rw s-locking, not the
 corresponding function. */
 
 #define rw_lock_s_lock_nowait(M)    rw_lock_s_lock_func_nowait(\
-					     (M), IB__FILE__, __LINE__)
+					     (M), __FILE__, __LINE__)
 /**********************************************************************
 NOTE! Use the corresponding macro, not directly this function, except if
 you supply the file name and line number. Lock an rw-lock in shared mode
@@ -127,7 +127,7 @@ rw_lock_s_lock_func(
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
 	ulint		pass,	/* in: pass value; != 0, if the lock will
 				be passed to another thread to unlock */
-	char*		file_name,/* in: file name where lock requested */
+	const char*	file_name,/* in: file name where lock requested */
 	ulint		line);	/* in: line where requested */
 /**********************************************************************
 NOTE! Use the corresponding macro, not directly this function, except if
@@ -139,7 +139,7 @@ rw_lock_s_lock_func_nowait(
 /*=======================*/
 				/* out: TRUE if success */
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
-	char*		file_name,/* in: file name where lock requested */
+	const char*	file_name,/* in: file name where lock requested */
 	ulint		line);	/* in: line where requested */
 /**********************************************************************
 NOTE! Use the corresponding macro, not directly this function! Lock an
@@ -151,7 +151,7 @@ rw_lock_x_lock_func_nowait(
 /*=======================*/
 				/* out: TRUE if success */
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
-	char*		file_name,/* in: file name where lock requested */
+	const char*	file_name,/* in: file name where lock requested */
 	ulint		line);	/* in: line where requested */
 /**********************************************************************
 Releases a shared mode lock. */
@@ -186,19 +186,19 @@ NOTE! The following macro should be used in rw x-locking, not the
 corresponding function. */
 
 #define rw_lock_x_lock(M)    rw_lock_x_lock_func(\
-					  (M), 0, IB__FILE__, __LINE__)
+					  (M), 0, __FILE__, __LINE__)
 /******************************************************************
 NOTE! The following macro should be used in rw x-locking, not the
 corresponding function. */
 
 #define rw_lock_x_lock_gen(M, P)    rw_lock_x_lock_func(\
-					  (M), (P), IB__FILE__, __LINE__)
+					  (M), (P), __FILE__, __LINE__)
 /******************************************************************
 NOTE! The following macros should be used in rw x-locking, not the
 corresponding function. */
 
 #define rw_lock_x_lock_nowait(M)    rw_lock_x_lock_func_nowait(\
-					     (M), IB__FILE__, __LINE__)
+					     (M), __FILE__, __LINE__)
 /**********************************************************************
 NOTE! Use the corresponding macro, not directly this function! Lock an
 rw-lock in exclusive mode for the current thread. If the rw-lock is locked
@@ -215,7 +215,7 @@ rw_lock_x_lock_func(
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
 	ulint		pass,	/* in: pass value; != 0, if the lock will
 				be passed to another thread to unlock */
-	char*		file_name,/* in: file name where lock requested */
+	const char*	file_name,/* in: file name where lock requested */
 	ulint		line);	/* in: line where requested */
 /**********************************************************************
 Releases an exclusive mode lock. */
@@ -253,9 +253,9 @@ UNIV_INLINE
 void
 rw_lock_s_lock_direct(
 /*==================*/
-        rw_lock_t*   	lock  	/* in: pointer to rw-lock */
-	,char*		file_name, /* in: file name where lock requested */
-	ulint		line	/* in: line where requested */
+	rw_lock_t*	lock,		/* in: pointer to rw-lock */
+	const char*	file_name,	/* in: file name where requested */
+	ulint		line		/* in: line where lock requested */
 );
 /**********************************************************************
 Low-level function which locks an rw-lock in x-mode when we know that it
@@ -265,9 +265,9 @@ UNIV_INLINE
 void
 rw_lock_x_lock_direct(
 /*==================*/
-        rw_lock_t*   	lock  	/* in: pointer to rw-lock */
-	,char*		file_name, /* in: file name where lock requested */
-	ulint		line	/* in: line where requested */
+	rw_lock_t*	lock,		/* in: pointer to rw-lock */
+	const char*	file_name,	/* in: file name where requested */
+	ulint		line		/* in: line where lock requested */
 );
 /**********************************************************************
 This function is used in the insert buffer to move the ownership of an
@@ -451,10 +451,10 @@ struct rw_lock_struct {
 #endif /* UNIV_SYNC_DEBUG */
 	ulint	level;		/* Level in the global latching
 				order; default SYNC_LEVEL_NONE */
-	char*	cfile_name;	/* File name where lock created */
+	const char*	cfile_name;/* File name where lock created */
 	ulint	cline;		/* Line where created */
-	char*	last_s_file_name;/* File name where last time s-locked */
-	char*	last_x_file_name;/* File name where last time x-locked */
+	const char*	last_s_file_name;/* File name where last s-locked */
+	const char*	last_x_file_name;/* File name where last x-locked */
 	ulint	last_s_line;	/* Line number where last time s-locked */
 	ulint	last_x_line;	/* Line number where last time x-locked */
 	ulint	magic_n;
@@ -471,7 +471,7 @@ struct	rw_lock_debug_struct {
 	ulint	pass;		/* Pass value given in the lock operation */
 	ulint	lock_type;	/* Type of the lock: RW_LOCK_EX,
 				RW_LOCK_SHARED, RW_LOCK_WAIT_EX */
-	char*	file_name;	/* File name where the lock was obtained */
+	const char*	file_name;/* File name where the lock was obtained */
 	ulint	line;		/* Line where the rw-lock was locked */
 	UT_LIST_NODE_T(rw_lock_debug_t) list;
 				/* Debug structs are linked in a two-way

innobase/include/sync0rw.ic

@@ -18,7 +18,7 @@ rw_lock_s_lock_spin(
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
 	ulint		pass,	/* in: pass value; != 0, if the lock will
 				be passed to another thread to unlock */
-	char*		file_name,/* in: file name where lock requested */
+	const char*	file_name,/* in: file name where lock requested */
 	ulint		line);	/* in: line where requested */
 #ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
@@ -130,7 +130,7 @@ rw_lock_s_lock_low(
 	ulint		pass __attribute__((unused)),
                                 /* in: pass value; != 0, if the lock will be
 				passed to another thread to unlock */
-	char*		file_name, /* in: file name where lock requested */
+	const char*	file_name, /* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
 #ifdef UNIV_SYNC_DEBUG
@@ -163,9 +163,9 @@ UNIV_INLINE
 void
 rw_lock_s_lock_direct(
 /*==================*/
-        rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
-	char*		file_name,/* in: file name where lock requested */
-	ulint		line)	/* in: line where requested */
+	rw_lock_t*	lock,		/* in: pointer to rw-lock */
+	const char*	file_name,	/* in: file name where requested */
+	ulint		line)		/* in: line where lock requested */
 {
 	ut_ad(lock->writer == RW_LOCK_NOT_LOCKED);
 	ut_ad(rw_lock_get_reader_count(lock) == 0);
@@ -189,9 +189,9 @@ UNIV_INLINE
 void
 rw_lock_x_lock_direct(
 /*==================*/
-        rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
-	char*		file_name, /* in: file name where lock requested */
-	ulint		line)	/* in: line where requested */
+	rw_lock_t*	lock,		/* in: pointer to rw-lock */
+	const char*	file_name,	/* in: file name where requested */
+	ulint		line)		/* in: line where lock requested */
 {
         ut_ad(rw_lock_validate(lock));
 	ut_ad(rw_lock_get_reader_count(lock) == 0);
@@ -223,7 +223,7 @@ rw_lock_s_lock_func(
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
 	ulint		pass,	/* in: pass value; != 0, if the lock will
 				be passed to another thread to unlock */
-	char*		file_name, /* in: file name where lock requested */
+	const char*	file_name,/* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
 	/* NOTE: As we do not know the thread ids for threads which have
@@ -267,7 +267,7 @@ rw_lock_s_lock_func_nowait(
 /*=======================*/
 				/* out: TRUE if success */
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
-	char*		file_name,/* in: file name where lock requested */
+	const char*	file_name,/* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
 	ibool	success	= FALSE;
@@ -304,7 +304,7 @@ rw_lock_x_lock_func_nowait(
 /*=======================*/
 				/* out: TRUE if success */
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
-	char*		file_name, /* in: file name where lock requested */
+	const char*	file_name,/* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
 	ibool	success	= FALSE;

innobase/include/sync0sync.h

@@ -36,7 +36,7 @@ in the reset state. Explicit freeing of the mutex with mutex_free is
 necessary only if the memory block containing it is freed. */
 
 
-#define mutex_create(M)	mutex_create_func((M), IB__FILE__, __LINE__)
+#define mutex_create(M)	mutex_create_func((M), __FILE__, __LINE__)
 /*===================*/
 /**********************************************************************
 Creates, or rather, initializes a mutex object in a specified memory
@@ -48,7 +48,7 @@ void
 mutex_create_func(
 /*==============*/
 	mutex_t*	mutex,		/* in: pointer to memory */
-	char*		cfile_name,	/* in: file name where created */
+	const char*	cfile_name,	/* in: file name where created */
 	ulint		cline);		/* in: file line where created */
 /**********************************************************************
 Calling this function is obligatory only if the memory buffer containing
@@ -64,7 +64,7 @@ mutex_free(
 NOTE! The following macro should be used in mutex locking, not the
 corresponding function. */
 
-#define mutex_enter(M)    mutex_enter_func((M), IB__FILE__, __LINE__)
+#define mutex_enter(M)    mutex_enter_func((M), __FILE__, __LINE__)
 /**********************************************************************
 A noninlined function that reserves a mutex. In ha_innodb.cc we have disabled
 inlining of InnoDB functions, and no inlined functions should be called from
@@ -80,7 +80,7 @@ corresponding function. */
 
 /* NOTE! currently same as mutex_enter! */
 
-#define mutex_enter_fast(M)    	mutex_enter_func((M), IB__FILE__, __LINE__)
+#define mutex_enter_fast(M)    	mutex_enter_func((M), __FILE__, __LINE__)
 #define mutex_enter_fast_func  	mutex_enter_func;
 /**********************************************************************
 NOTE! Use the corresponding macro in the header file, not this function
@@ -92,7 +92,7 @@ void
 mutex_enter_func(
 /*=============*/
 	mutex_t*	mutex,		/* in: pointer to mutex */
-	char*		file_name, 	/* in: file name where locked */
+	const char*	file_name, 	/* in: file name where locked */
 	ulint		line);		/* in: line where locked */
 /************************************************************************
 Tries to lock the mutex for the current thread. If the lock is not acquired
@@ -103,9 +103,9 @@ 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
+	const char*	file_name,	/* in: file name where mutex
 					requested */
-	ulint	   	line);		/* in: line where requested */
+	ulint		line);		/* in: line where requested */
 /**********************************************************************
 Unlocks a mutex owned by the current thread. */
 UNIV_INLINE
@@ -470,7 +470,7 @@ struct mutex_struct {
 #endif /* UNIV_SYNC_DEBUG */
 	ulint	level;		/* Level in the global latching
 				order; default SYNC_LEVEL_NONE */
-	char*	cfile_name;	/* File name where mutex created */
+	const char*	cfile_name;/* File name where mutex created */
 	ulint	cline;		/* Line where created */
 	ulint	magic_n;
 };

innobase/include/sync0sync.ic

@@ -23,7 +23,7 @@ void
 mutex_spin_wait(
 /*============*/
         mutex_t*	mutex,  	/* in: pointer to mutex */
-	char*		file_name,/* in: file name where mutex requested */
+	const char*	file_name,/* in: file name where mutex requested */
 	ulint		line);	/* in: line where requested */
 #ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
@@ -241,9 +241,9 @@ UNIV_INLINE
 void
 mutex_enter_func(
 /*=============*/
-	mutex_t*	mutex,	/* in: pointer to mutex */
-	char*		file_name,/* in: file name where locked */
-	ulint		line)	/* in: line where locked */
+	mutex_t*	mutex,		/* in: pointer to mutex */
+	const char*	file_name, 	/* in: file name where locked */
+	ulint		line)		/* in: line where locked */
 {
 	ut_ad(mutex_validate(mutex));
 

innobase/include/univ.i

@@ -242,11 +242,6 @@ contains the sum of the following flag and the locally stored len. */
 
 #define UNIV_EXTERN_STORAGE_FIELD (UNIV_SQL_NULL - UNIV_PAGE_SIZE)
 
-/* The following definition of __FILE__ removes compiler warnings
-associated with const char* / char* mismatches with __FILE__ */
-
-#define IB__FILE__	((char*)__FILE__)
-
 #include <stdio.h>
 #include "ut0dbg.h"
 #include "ut0ut.h"

innobase/include/ut0dbg.h

@@ -27,7 +27,7 @@ extern const char*	ut_dbg_msg_stop;
 	if (!((ulint)(EXPR) + ut_dbg_zero)) {\
                 ut_print_timestamp(stderr);\
 	   	fprintf(stderr, ut_dbg_msg_assert_fail,\
-		os_thread_pf(os_thread_get_curr_id()), IB__FILE__,\
+		os_thread_pf(os_thread_get_curr_id()), __FILE__,\
                 (ulint)__LINE__);\
 		fputs("InnoDB: Failing assertion: " #EXPR "\n", stderr);\
 		fputs(ut_dbg_msg_trap, stderr);\
@@ -36,7 +36,7 @@ extern const char*	ut_dbg_msg_stop;
 	}\
 	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_pf(os_thread_get_curr_id()), __FILE__, (ulint)__LINE__);\
 		os_thread_sleep(1000000000);\
 	}\
 } while (0)
@@ -44,7 +44,7 @@ extern const char*	ut_dbg_msg_stop;
 #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__);\
+	os_thread_pf(os_thread_get_curr_id()), __FILE__, (ulint)__LINE__);\
 	fprintf(stderr, ut_dbg_msg_trap);\
 	ut_dbg_stop_threads = TRUE;\
 	if (*(ut_dbg_null_ptr)) ut_dbg_null_ptr = NULL;\

innobase/lock/lock0lock.c

@@ -3889,7 +3889,7 @@ lock_rec_print(
 	
 	page = buf_page_get_gen(space, page_no, RW_NO_LATCH,
 					NULL, BUF_GET_IF_IN_POOL,
-					IB__FILE__, __LINE__, &mtr);
+					__FILE__, __LINE__, &mtr);
 	if (page) {
 		page = buf_page_get_nowait(space, page_no, RW_S_LATCH, &mtr);
 

innobase/log/log0recv.c

@@ -1080,7 +1080,7 @@ recv_recover_page(
 
 		success = buf_page_get_known_nowait(RW_X_LATCH, page,
 					BUF_KEEP_OLD,
-					IB__FILE__, __LINE__,
+					__FILE__, __LINE__,
 					&mtr);
 		ut_a(success);
 
@@ -1664,7 +1664,7 @@ recv_compare_spaces(
 
 		frame = buf_page_get_gen(space1, page_no, RW_S_LATCH, NULL,
 						BUF_GET_IF_IN_POOL,
-						IB__FILE__, __LINE__,
+						__FILE__, __LINE__,
 						&mtr);
 		if (frame) {
 #ifdef UNIV_SYNC_DEBUG
@@ -1679,7 +1679,7 @@ recv_compare_spaces(
 
 		frame = buf_page_get_gen(space2, page_no, RW_S_LATCH, NULL,
 						BUF_GET_IF_IN_POOL,
-						IB__FILE__, __LINE__,
+						__FILE__, __LINE__,
 						&mtr);
 		if (frame) {
 #ifdef UNIV_SYNC_DEBUG

innobase/mem/mem0mem.c

@@ -92,11 +92,11 @@ with mem_free. */
 void*
 mem_alloc_func_noninline(
 /*=====================*/
-				/* out, own: free storage, NULL if did not
-				succeed */
-	ulint   n,              /* in: desired number of bytes */
-	char*  	file_name,	/* in: file name where created */
-	ulint   line		/* in: line where created */
+					/* out, own: free storage,
+					NULL if did not succeed */
+	ulint		n,		/* in: desired number of bytes */
+	const char*	file_name,	/* in: file name where created */
+	ulint		line		/* in: line where created */
 	)
 {
 	return(mem_alloc_func(n, file_name, line));	
@@ -108,18 +108,18 @@ Creates a memory heap block where data can be allocated. */
 mem_block_t*
 mem_heap_create_block(
 /*==================*/
-			/* out, own: memory heap block, NULL if did not
-			succeed */
-	mem_heap_t* heap,/* in: memory heap or NULL if first block should
-			be created */
-	ulint	n,	/* in: number of bytes needed for user data, or
-			if init_block is not NULL, its size in bytes */
-	void*	init_block, /* in: init block in fast create, type must be
-			MEM_HEAP_DYNAMIC */
-	ulint 	type,	/* in: type of heap: MEM_HEAP_DYNAMIC, or
-			MEM_HEAP_BUFFER possibly ORed to MEM_HEAP_BTR_SEARCH */
-	char*  	file_name,/* in: file name where created */
-	ulint 	line)   /* in: line where created */
+				/* out, own: memory heap block,
+				NULL if did not succeed */
+	mem_heap_t*	heap,	/* in: memory heap or NULL if first block
+				should be created */
+	ulint		n,	/* in: number of bytes needed for user data, or
+				if init_block is not NULL, its size in bytes */
+	void*		init_block, /* in: init block in fast create,
+				type must be MEM_HEAP_DYNAMIC */
+	ulint		type,	/* in: type of heap: MEM_HEAP_DYNAMIC or
+				MEM_HEAP_BUFFER */
+	const char*	file_name,/* in: file name where created */
+	ulint		line)	/* in: line where created */
 {
 	mem_block_t*	block;
 	ulint		len;

innobase/pars/pars0pars.c

@@ -1713,7 +1713,8 @@ Called by yyparse on error. */
 void
 yyerror(
 /*====*/
-        char*	s __attribute__((unused))) /* in: error message string */
+	const char*	s __attribute__((unused)))
+				/* in: error message string */
 {
 	ut_ad(s);
 

innobase/sync/sync0arr.c

@@ -53,7 +53,7 @@ struct sync_cell_struct {
 	rw_lock_t*	old_wait_rw_lock;/* the latest wait rw-lock in cell */
         ulint		request_type;	/* lock type requested on the
         				object */
-	char*		file;		/* in debug version file where
+	const char*	file;		/* in debug version file where
 					requested */
 	ulint		line;		/* in debug version line where
 					requested */
@@ -329,7 +329,7 @@ sync_array_reserve_cell(
         sync_array_t*	arr,	/* in: wait array */
         void*   	object, /* in: pointer to the object to wait for */
         ulint		type,	/* in: lock request type */
-        char*		file,	/* in: file where requested */
+	const char*	file,	/* in: file where requested */
         ulint		line,	/* in: line where requested */
         ulint*   	index)  /* out: index of the reserved cell */
 {

innobase/sync/sync0rw.c

@@ -89,7 +89,7 @@ void
 rw_lock_create_func(
 /*================*/
 	rw_lock_t*	lock,		/* in: pointer to memory */
-	char*		cfile_name,	/* in: file name where created */
+	const char*	cfile_name,	/* in: file name where created */
 	ulint		cline)		/* in: file line where created */
 {
 	/* If this is the very first time a synchronization
@@ -213,7 +213,7 @@ rw_lock_s_lock_spin(
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
 	ulint		pass,	/* in: pass value; != 0, if the lock
 				will be passed to another thread to unlock */
-	char*		file_name, /* in: file name where lock requested */
+	const char*	file_name, /* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
         ulint    index;	/* index of the reserved wait cell */
@@ -324,7 +324,7 @@ rw_lock_x_lock_low(
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
 	ulint		pass,	/* in: pass value; != 0, if the lock will
 				be passed to another thread to unlock */
-	char*		file_name,/* in: file name where lock requested */
+	const char*	file_name,/* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
 #ifdef UNIV_SYNC_DEBUG
@@ -429,7 +429,7 @@ rw_lock_x_lock_func(
         rw_lock_t*   	lock,  	/* in: pointer to rw-lock */
 	ulint		pass,	/* in: pass value; != 0, if the lock will
 				be passed to another thread to unlock */
-	char*		file_name,/* in: file name where lock requested */
+	const char*	file_name,/* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
         ulint	index;  /* index of the reserved wait cell */
@@ -551,7 +551,7 @@ rw_lock_debug_mutex_enter(void)
 {
 loop:
 	if (0 == mutex_enter_nowait(&rw_lock_debug_mutex,
-			IB__FILE__, __LINE__)) {
+			__FILE__, __LINE__)) {
 		return;
 	}
 
@@ -560,7 +560,7 @@ loop:
 	rw_lock_debug_waiters = TRUE;
 
 	if (0 == mutex_enter_nowait(&rw_lock_debug_mutex,
-			IB__FILE__, __LINE__)) {
+			__FILE__, __LINE__)) {
 		return;
 	}
 

innobase/sync/sync0sync.c

@@ -201,7 +201,7 @@ void
 mutex_create_func(
 /*==============*/
 	mutex_t*	mutex,		/* in: pointer to memory */
-	char*		cfile_name,	/* in: file name where created */
+	const char*	cfile_name,	/* in: file name where created */
 	ulint		cline)		/* in: file line where created */
 {
 #if defined(_WIN32) && defined(UNIV_CAN_USE_X86_ASSEMBLER)
@@ -294,10 +294,10 @@ mutex_enter_nowait(
 /*===============*/
 					/* out: 0 if succeed, 1 if not */
 	mutex_t*	mutex,		/* in: pointer to mutex */
-	char*	   	file_name __attribute__((unused)),
+	const char*	file_name __attribute__((unused)),
 					/* in: file name where mutex
 					requested */
-	ulint	   	line __attribute__((unused)))
+	ulint		line __attribute__((unused)))
 					/* in: line where requested */
 {
 	ut_ad(mutex_validate(mutex));
@@ -357,9 +357,10 @@ for the mutex before suspending the thread. */
 void
 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 */
+        mutex_t*	   mutex,     	/* in: pointer to mutex */
+	const char*	   file_name, 	/* in: file name where
+					mutex requested */
+	ulint		   line)	/* in: line where requested */
 {
         ulint    index; /* index of the reserved wait cell */
         ulint    i;   	/* spin round count */

innobase/trx/trx0rec.c

@@ -1067,7 +1067,7 @@ trx_undo_report_row_operation(
 		undo_page = buf_page_get_gen(undo->space, page_no,
 						RW_X_LATCH, undo->guess_page,
 						BUF_GET,
-						IB__FILE__, __LINE__,
+						__FILE__, __LINE__,
 						&mtr);
 
 #ifdef UNIV_SYNC_DEBUG