branches/zip: Replace ib_ulonglong with ib_uint64_t, since we want exactly

64 bits.  "long long" might be longer than 64 bits on some systems.

buf/buf0buf.c

@@ -294,7 +294,7 @@ buf_page_is_corrupted(
 	ulint		checksum_field;
 	ulint		old_checksum_field;
 #ifndef UNIV_HOTBACKUP
-	ib_ulonglong	current_lsn;
+	ib_uint64_t	current_lsn;
 #endif
 	if (UNIV_LIKELY(!zip_size)
 	    && memcmp(read_buf + FIL_PAGE_LSN + 4,
@@ -1554,7 +1554,7 @@ buf_page_optimistic_get_func(
 				/* out: TRUE if success */
 	ulint		rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
 	buf_block_t*	block,	/* in: guessed buffer block */
-	ib_ulonglong	modify_clock,/* in: modify clock value if mode is
+	ib_uint64_t	modify_clock,/* in: modify clock value if mode is
 				..._GUESS_ON_CLOCK */
 	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line where called */

buf/buf0flu.c

@@ -506,7 +506,7 @@ buf_flush_init_for_writing(
 /*=======================*/
 	byte*		page,		/* in/out: page */
 	void*		page_zip_,	/* in/out: compressed page, or NULL */
-	ib_ulonglong	newest_lsn)	/* in: newest modification lsn
+	ib_uint64_t	newest_lsn)	/* in: newest modification lsn
 					to the page */
 {
 	if (page_zip_) {
@@ -889,7 +889,7 @@ buf_flush_batch(
 	ulint		min_n,		/* in: wished minimum mumber of blocks
 					flushed (it is not guaranteed that the
 					actual number is that big, though) */
-	ib_ulonglong	lsn_limit)	/* in the case BUF_FLUSH_LIST all
+	ib_uint64_t	lsn_limit)	/* in the case BUF_FLUSH_LIST all
 					blocks whose oldest_modification is
 					smaller than this should be flushed
 					(if their number does not exceed
@@ -1134,7 +1134,7 @@ buf_flush_validate_low(void)
 		/* out: TRUE if ok */
 {
 	buf_page_t*	bpage;
-	ib_ulonglong	om;
+	ib_uint64_t	om;
 
 	UT_LIST_VALIDATE(flush_list, buf_page_t, buf_pool->flush_list);
 

fil/fil0fil.c

@@ -1642,7 +1642,7 @@ fil_write_lsn_and_arch_no_to_file(
 /*==============================*/
 	ulint		sum_of_sizes,	/* in: combined size of previous files
 					in space, in database pages */
-	ib_ulonglong	lsn,		/* in: lsn to write */
+	ib_uint64_t	lsn,		/* in: lsn to write */
 	ulint		arch_log_no	/* in: archived log number to write */
 	__attribute__((unused)))
 {
@@ -1669,7 +1669,7 @@ ulint
 fil_write_flushed_lsn_to_data_files(
 /*================================*/
 					/* out: DB_SUCCESS or error number */
-	ib_ulonglong	lsn,		/* in: lsn to write */
+	ib_uint64_t	lsn,		/* in: lsn to write */
 	ulint		arch_log_no)	/* in: latest archived log
 					file number */
 {
@@ -1733,12 +1733,12 @@ fil_read_flushed_lsn_and_arch_log_no(
 	ulint*		min_arch_log_no,	/* in/out: */
 	ulint*		max_arch_log_no,	/* in/out: */
 #endif /* UNIV_LOG_ARCHIVE */
-	ib_ulonglong*	min_flushed_lsn,	/* in/out: */
-	ib_ulonglong*	max_flushed_lsn)	/* in/out: */
+	ib_uint64_t*	min_flushed_lsn,	/* in/out: */
+	ib_uint64_t*	max_flushed_lsn)	/* in/out: */
 {
 	byte*		buf;
 	byte*		buf2;
-	ib_ulonglong	flushed_lsn;
+	ib_uint64_t	flushed_lsn;
 
 	buf2 = ut_malloc(2 * UNIV_PAGE_SIZE);
 	/* Align the memory for a possible read from a raw device */
@@ -2737,7 +2737,7 @@ fil_reset_too_high_lsns(
 					/* out: TRUE if success */
 	const char*	name,		/* in: table name in the
 					databasename/tablename format */
-	ib_ulonglong	current_lsn)	/* in: reset lsn's if the lsn stamped
+	ib_uint64_t	current_lsn)	/* in: reset lsn's if the lsn stamped
 					to FIL_PAGE_FILE_FLUSH_LSN in the
 					first page is too high */
 {
@@ -2745,7 +2745,7 @@ fil_reset_too_high_lsns(
 	char*		filepath;
 	byte*		page;
 	byte*		buf2;
-	ib_ulonglong	flush_lsn;
+	ib_uint64_t	flush_lsn;
 	ulint		space_id;
 	ib_longlong	file_size;
 	ib_longlong	offset;

include/btr0pcur.h

@@ -477,7 +477,7 @@ struct btr_pcur_struct{
 					old_rec record */
 	buf_block_t*	block_when_stored;/* buffer block when the position was
 					stored */
-	ib_ulonglong	modify_clock;	/* the modify clock value of the
+	ib_uint64_t	modify_clock;	/* the modify clock value of the
 					buffer block when the cursor position
 					was stored */
 	ulint		pos_state;	/* see TODO note below!

include/buf0buf.h

@@ -98,7 +98,7 @@ buf_pool_get_curr_size(void);
 Gets the smallest oldest_modification lsn for any page in the pool. Returns
 zero if all modified pages have been flushed to disk. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 buf_pool_get_oldest_modification(void);
 /*==================================*/
 				/* out: oldest modification in pool,
@@ -166,7 +166,7 @@ buf_page_optimistic_get_func(
 				/* out: TRUE if success */
 	ulint		rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
 	buf_block_t*	block,	/* in: guessed block */
-	ib_ulonglong	modify_clock,/* in: modify clock value if mode is
+	ib_uint64_t	modify_clock,/* in: modify clock value if mode is
 				..._GUESS_ON_CLOCK */
 	const char*	file,	/* in: file name */
 	ulint		line,	/* in: line where called */
@@ -357,7 +357,7 @@ buf_page_peek_if_search_hashed(
 Gets the youngest modification log sequence number for a frame.
 Returns zero if not file page or no modification occurred yet. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 buf_block_get_newest_modification(
 /*==============================*/
 				/* out: newest modification to page */
@@ -375,7 +375,7 @@ buf_block_modify_clock_inc(
 Returns the value of the modify clock. The caller must have an s-lock
 or x-lock on the block. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 buf_block_get_modify_clock(
 /*=======================*/
 				/* out: value */
@@ -750,11 +750,11 @@ struct buf_page_struct{
 	UT_LIST_NODE_T(buf_page_t) flush_list;
 					/* node of the modified, not yet
 					flushed blocks list */
-	ib_ulonglong	newest_modification;
+	ib_uint64_t	newest_modification;
 					/* log sequence number of the youngest
 					modification to this block, zero if
 					not modified */
-	ib_ulonglong	oldest_modification;
+	ib_uint64_t	oldest_modification;
 					/* log sequence number of the START of
 					the log entry written of the oldest
 					modification to this block which has
@@ -846,7 +846,7 @@ struct buf_block_struct{
 					protected by block->mutex */
 	/* 4. Optimistic search field */
 
-	ib_ulonglong	modify_clock;	/* this clock is incremented every
+	ib_uint64_t	modify_clock;	/* this clock is incremented every
 					time a pointer to a record on the
 					page may become obsolete; this is
 					used in the optimistic cursor

include/buf0buf.ic

@@ -41,14 +41,14 @@ buf_pool_get_curr_size(void)
 Gets the smallest oldest_modification lsn for any page in the pool. Returns
 zero if all modified pages have been flushed to disk. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 buf_pool_get_oldest_modification(void)
 /*==================================*/
 				/* out: oldest modification in pool,
 				zero if none */
 {
 	buf_page_t*	bpage;
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 
 	mutex_enter(&(buf_pool->mutex));
 
@@ -484,13 +484,13 @@ buf_page_io_query(
 Gets the youngest modification log sequence number for a frame.
 Returns zero if not file page or no modification occurred yet. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 buf_block_get_newest_modification(
 /*==============================*/
 				/* out: newest modification to page */
 	buf_block_t*	block)	/* in: block containing the page frame */
 {
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 
 	mutex_enter(&(buf_pool->mutex));
 
@@ -527,7 +527,7 @@ buf_block_modify_clock_inc(
 Returns the value of the modify clock. The caller must have an s-lock
 or x-lock on the block. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 buf_block_get_modify_clock(
 /*=======================*/
 				/* out: value */

include/buf0flu.h

@@ -36,7 +36,7 @@ buf_flush_init_for_writing(
 /*=======================*/
 	byte*		page,		/* in/out: page */
 	void*		page_zip_,	/* in/out: compressed page, or NULL */
-	ib_ulonglong	newest_lsn);	/* in: newest modification lsn
+	ib_uint64_t	newest_lsn);	/* in: newest modification lsn
 					to the page */
 /***********************************************************************
 This utility flushes dirty blocks from the end of the LRU list or flush_list.
@@ -59,7 +59,7 @@ buf_flush_batch(
 	ulint		min_n,		/* in: wished minimum mumber of blocks
 					flushed (it is not guaranteed that the
 					actual number is that big, though) */
-	ib_ulonglong	lsn_limit);	/* in the case BUF_FLUSH_LIST all
+	ib_uint64_t	lsn_limit);	/* in the case BUF_FLUSH_LIST all
 					blocks whose oldest_modification is
 					smaller than this should be flushed
 					(if their number does not exceed
@@ -88,9 +88,9 @@ void
 buf_flush_recv_note_modification(
 /*=============================*/
 	buf_block_t*	block,		/* in: block which is modified */
-	ib_ulonglong	start_lsn,	/* in: start lsn of the first mtr in a
+	ib_uint64_t	start_lsn,	/* in: start lsn of the first mtr in a
 					set of mtr's */
-	ib_ulonglong	end_lsn);	/* in: end lsn of the last mtr in the
+	ib_uint64_t	end_lsn);	/* in: end lsn of the last mtr in the
 					set of mtr's */
 /************************************************************************
 Returns TRUE if the file page block is immediately suitable for replacement,

include/buf0flu.ic

@@ -71,9 +71,9 @@ void
 buf_flush_recv_note_modification(
 /*=============================*/
 	buf_block_t*	block,		/* in: block which is modified */
-	ib_ulonglong	start_lsn,	/* in: start lsn of the first mtr in a
+	ib_uint64_t	start_lsn,	/* in: start lsn of the first mtr in a
 					set of mtr's */
-	ib_ulonglong	end_lsn)	/* in: end lsn of the last mtr in the
+	ib_uint64_t	end_lsn)	/* in: end lsn of the last mtr in the
 					set of mtr's */
 {
 	ut_ad(block);

include/fil0fil.h

@@ -286,7 +286,7 @@ ulint
 fil_write_flushed_lsn_to_data_files(
 /*================================*/
 					/* out: DB_SUCCESS or error number */
-	ib_ulonglong	lsn,		/* in: lsn to write */
+	ib_uint64_t	lsn,		/* in: lsn to write */
 	ulint		arch_log_no);	/* in: latest archived log
 					file number */
 /***********************************************************************
@@ -304,8 +304,8 @@ fil_read_flushed_lsn_and_arch_log_no(
 	ulint*		min_arch_log_no,	/* in/out: */
 	ulint*		max_arch_log_no,	/* in/out: */
 #endif /* UNIV_LOG_ARCHIVE */
-	ib_ulonglong*	min_flushed_lsn,	/* in/out: */
-	ib_ulonglong*	max_flushed_lsn);	/* in/out: */
+	ib_uint64_t*	min_flushed_lsn,	/* in/out: */
+	ib_uint64_t*	max_flushed_lsn);	/* in/out: */
 /***********************************************************************
 Increments the count of pending insert buffer page merges, if space is not
 being deleted. */
@@ -457,7 +457,7 @@ fil_reset_too_high_lsns(
 					/* out: TRUE if success */
 	const char*	name,		/* in: table name in the
 					databasename/tablename format */
-	ib_ulonglong	current_lsn);	/* in: reset lsn's if the lsn stamped
+	ib_uint64_t	current_lsn);	/* in: reset lsn's if the lsn stamped
 					to FIL_PAGE_FILE_FLUSH_LSN in the
 					first page is too high */
 /************************************************************************

include/log0log.h

@@ -48,9 +48,9 @@ log_calc_where_lsn_is(
 						/* out: log file number */
 	ib_longlong*	log_file_offset,	/* out: offset in that file
 						(including the header) */
-	ib_ulonglong	first_header_lsn,	/* in: first log file start
+	ib_uint64_t	first_header_lsn,	/* in: first log file start
 						lsn */
-	ib_ulonglong	lsn,			/* in: lsn whose position to
+	ib_uint64_t	lsn,			/* in: lsn whose position to
 						determine */
 	ulint		n_log_files,		/* in: total number of log
 						files */
@@ -60,14 +60,14 @@ log_calc_where_lsn_is(
 Writes to the log the string given. The log must be released with
 log_release. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 log_reserve_and_write_fast(
 /*=======================*/
 				/* out: end lsn of the log record,
 				zero if did not succeed */
 	byte*		str,	/* in: string */
 	ulint		len,	/* in: string length */
-	ib_ulonglong*	start_lsn,/* out: start lsn of the log record */
+	ib_uint64_t*	start_lsn,/* out: start lsn of the log record */
 	ibool*		success);/* out: TRUE if success */
 /***************************************************************************
 Releases the log mutex. */
@@ -88,7 +88,7 @@ log_free_check(void);
 Opens the log for log_write_low. The log must be closed with log_close and
 released with log_release. */
 
-ib_ulonglong
+ib_uint64_t
 log_reserve_and_open(
 /*=================*/
 			/* out: start lsn of the log record */
@@ -105,14 +105,14 @@ log_write_low(
 /****************************************************************
 Closes the log. */
 
-ib_ulonglong
+ib_uint64_t
 log_close(void);
 /*===========*/
 			/* out: lsn */
 /****************************************************************
 Gets the current lsn. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 log_get_lsn(void);
 /*=============*/
 			/* out: current lsn */
@@ -155,7 +155,7 @@ flush flushed enough. If not, starts a new flush. */
 void
 log_write_up_to(
 /*============*/
-	ib_ulonglong	lsn,	/* in: log sequence number up to which
+	ib_uint64_t	lsn,	/* in: log sequence number up to which
 				the log should be written,
 				IB_ULONGLONG_MAX if not specified */
 	ulint		wait,	/* in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
@@ -182,7 +182,7 @@ log_preflush_pool_modified_pages(
 					running, which means that we
 					could not start this flush
 					batch */
-	ib_ulonglong	new_oldest,	/* in: try to advance
+	ib_uint64_t	new_oldest,	/* in: try to advance
 					oldest_modified_lsn at least
 					to this lsn */
 	ibool		sync);		/* in: TRUE if synchronous
@@ -212,7 +212,7 @@ Makes a checkpoint at a given lsn or later. */
 void
 log_make_checkpoint_at(
 /*===================*/
-	ib_ulonglong	lsn,		/* in: make a checkpoint at this or a
+	ib_uint64_t	lsn,		/* in: make a checkpoint at this or a
 					later lsn, if IB_ULONGLONG_MAX, makes
 					a checkpoint at the latest lsn */
 	ibool		write_always);	/* in: the function normally checks if
@@ -264,7 +264,7 @@ log_reset_first_header_and_checkpoint(
 /*==================================*/
 	byte*		hdr_buf,/* in: buffer which will be written to the
 				start of the first log file */
-	ib_ulonglong	start);	/* in: lsn of the start of the first log file;
+	ib_uint64_t	start);	/* in: lsn of the start of the first log file;
 				we pretend that there is a checkpoint at
 				start + LOG_BLOCK_HDR_SIZE */
 /************************************************************************
@@ -337,8 +337,8 @@ log_group_read_log_seg(
 	ulint		type,		/* in: LOG_ARCHIVE or LOG_RECOVER */
 	byte*		buf,		/* in: buffer where to read */
 	log_group_t*	group,		/* in: log group */
-	ib_ulonglong	start_lsn,	/* in: read area start */
-	ib_ulonglong	end_lsn);	/* in: read area end */
+	ib_uint64_t	start_lsn,	/* in: read area start */
+	ib_uint64_t	end_lsn);	/* in: read area end */
 /**********************************************************
 Writes a buffer to a log file group. */
 
@@ -349,7 +349,7 @@ log_group_write_buf(
 	byte*		buf,		/* in: buffer */
 	ulint		len,		/* in: buffer len; must be divisible
 					by OS_FILE_LOG_BLOCK_SIZE */
-	ib_ulonglong	start_lsn,	/* in: start lsn of the buffer; must
+	ib_uint64_t	start_lsn,	/* in: start lsn of the buffer; must
 					be divisible by
 					OS_FILE_LOG_BLOCK_SIZE */
 	ulint		new_data_offset);/* in: start offset of new data in
@@ -365,7 +365,7 @@ void
 log_group_set_fields(
 /*=================*/
 	log_group_t*	group,	/* in: group */
-	ib_ulonglong	lsn);	/* in: lsn for which the values should be
+	ib_uint64_t	lsn);	/* in: lsn for which the values should be
 				set */
 /**********************************************************
 Calculates the data capacity of a log group, when the log file headers are not
@@ -467,7 +467,7 @@ void
 log_block_init(
 /*===========*/
 	byte*		log_block,	/* in: pointer to the log buffer */
-	ib_ulonglong	lsn);		/* in: lsn within the log block */
+	ib_uint64_t	lsn);		/* in: lsn within the log block */
 /****************************************************************
 Initializes a log block in the log buffer in the old, < 3.23.52 format, where
 there was no checksum yet. */
@@ -476,7 +476,7 @@ void
 log_block_init_in_old_format(
 /*=========================*/
 	byte*		log_block,	/* in: pointer to the log buffer */
-	ib_ulonglong	lsn);		/* in: lsn within the log block */
+	ib_uint64_t	lsn);		/* in: lsn within the log block */
 /****************************************************************
 Converts a lsn to a log block number. */
 UNIV_INLINE
@@ -485,7 +485,7 @@ log_block_convert_lsn_to_no(
 /*========================*/
 				/* out: log block number,
 				it is > 0 and <= 1G */
-	ib_ulonglong	lsn);	/* in: lsn of a byte within the block */
+	ib_uint64_t	lsn);	/* in: lsn of a byte within the block */
 /**********************************************************
 Prints info of the log. */
 
@@ -501,7 +501,7 @@ log_peek_lsn(
 /*=========*/
 				/* out: TRUE if success, FALSE if
 				could not get the log system mutex */
-	ib_ulonglong*	lsn);	/* out: if returns TRUE, current lsn is here */
+	ib_uint64_t*	lsn);	/* out: if returns TRUE, current lsn is here */
 /**************************************************************************
 Refreshes the statistics used to print per-second averages. */
 
@@ -518,7 +518,7 @@ extern log_t*	log_sys;
 #define LOG_RECOVER	98887331
 
 /* The counting of lsn's starts from this value: this must be non-zero */
-#define LOG_START_LSN	((ib_ulonglong) (16 * OS_FILE_LOG_BLOCK_SIZE))
+#define LOG_START_LSN	((ib_uint64_t) (16 * OS_FILE_LOG_BLOCK_SIZE))
 
 #define LOG_BUFFER_SIZE		(srv_log_buffer_size * UNIV_PAGE_SIZE)
 #define LOG_ARCHIVE_BUF_SIZE	(srv_log_buffer_size * UNIV_PAGE_SIZE / 4)
@@ -651,7 +651,7 @@ struct log_group_struct{
 					group */
 	ulint		state;		/* LOG_GROUP_OK or
 					LOG_GROUP_CORRUPTED */
-	ib_ulonglong	lsn;		/* lsn used to fix coordinates within
+	ib_uint64_t	lsn;		/* lsn used to fix coordinates within
 					the log group */
 	ulint		lsn_offset;	/* the offset of the above lsn */
 	ulint		n_pending_writes;/* number of currently pending flush
@@ -677,7 +677,7 @@ struct log_group_struct{
 					value to ..._file_no */
 	ulint		next_archived_offset; /* like the preceding field */
 	/*-----------------------------*/
-	ib_ulonglong	scanned_lsn;	/* used only in recovery: recovery scan
+	ib_uint64_t	scanned_lsn;	/* used only in recovery: recovery scan
 					succeeded up to this lsn in this log
 					group */
 	byte*		checkpoint_buf;	/* checkpoint header is written from
@@ -690,7 +690,7 @@ struct log_struct{
 	byte		pad[64];	/* padding to prevent other memory
 					update hotspots from residing on the
 					same memory cache line */
-	ib_ulonglong	lsn;		/* log sequence number */
+	ib_uint64_t	lsn;		/* log sequence number */
 	ulint		buf_free;	/* first free offset within the log
 					buffer */
 	mutex_t		mutex;		/* mutex protecting the log */
@@ -702,7 +702,7 @@ struct log_struct{
 	ulint		old_buf_free;	/* value of buf free when log was
 					last time opened; only in the debug
 					version */
-	ib_ulonglong	old_lsn;	/* value of lsn when log was last time
+	ib_uint64_t	old_lsn;	/* value of lsn when log was last time
 					opened; only in the debug version */
 	ibool		check_flush_or_checkpoint;
 					/* this is set to TRUE when there may
@@ -725,27 +725,27 @@ struct log_struct{
 					later; this is advanced when a flush
 					operation is completed to all the log
 					groups */
-	ib_ulonglong	written_to_some_lsn;
+	ib_uint64_t	written_to_some_lsn;
 					/* first log sequence number not yet
 					written to any log group; for this to
 					be advanced, it is enough that the
 					write i/o has been completed for any
 					one log group */
-	ib_ulonglong	written_to_all_lsn;
+	ib_uint64_t	written_to_all_lsn;
 					/* first log sequence number not yet
 					written to some log group; for this to
 					be advanced, it is enough that the
 					write i/o has been completed for all
 					log groups */
-	ib_ulonglong	write_lsn;	/* end lsn for the current running
+	ib_uint64_t	write_lsn;	/* end lsn for the current running
 					write */
 	ulint		write_end_offset;/* the data in buffer has been written
 					up to this offset when the current
 					write ends: this field will then
 					be copied to buf_next_to_write */
-	ib_ulonglong	current_flush_lsn;/* end lsn for the current running
+	ib_uint64_t	current_flush_lsn;/* end lsn for the current running
 					write + flush operation */
-	ib_ulonglong	flushed_to_disk_lsn;
+	ib_uint64_t	flushed_to_disk_lsn;
 					/* how far we have written the log
 					AND flushed to disk */
 	ulint		n_pending_writes;/* number of currently pending flushes
@@ -808,11 +808,11 @@ struct log_struct{
 					/* this is the maximum allowed value
 					for lsn - last_checkpoint_lsn when a
 					new query step is started */
-	ib_ulonglong	next_checkpoint_no;
+	ib_uint64_t	next_checkpoint_no;
 					/* next checkpoint number */
-	ib_ulonglong	last_checkpoint_lsn;
+	ib_uint64_t	last_checkpoint_lsn;
 					/* latest checkpoint lsn */
-	ib_ulonglong	next_checkpoint_lsn;
+	ib_uint64_t	next_checkpoint_lsn;
 					/* next checkpoint lsn */
 	ulint		n_pending_checkpoint_writes;
 					/* number of currently pending
@@ -827,7 +827,7 @@ struct log_struct{
 	/* Fields involved in archiving */
 	ulint		archiving_state;/* LOG_ARCH_ON, LOG_ARCH_STOPPING
 					LOG_ARCH_STOPPED, LOG_ARCH_OFF */
-	ib_ulonglong	archived_lsn;	/* archiving has advanced to this
+	ib_uint64_t	archived_lsn;	/* archiving has advanced to this
 					lsn */
 	ulint		max_archived_lsn_age_async;
 					/* recommended maximum age of
@@ -836,7 +836,7 @@ struct log_struct{
 	ulint		max_archived_lsn_age;
 					/* maximum allowed age for
 					archived_lsn */
-	ib_ulonglong	next_archived_lsn;/* during an archive write,
+	ib_uint64_t	next_archived_lsn;/* during an archive write,
 					until the write is completed, we
 					store the next value for
 					archived_lsn here: the write

include/log0log.ic

@@ -21,7 +21,7 @@ log_check_log_recs(
 					the log segment in the
 					log_sys->buf log buffer */
 	ulint		len,		/* in: segment length in bytes */
-	ib_ulonglong	buf_start_lsn);	/* in: buffer start lsn */
+	ib_uint64_t	buf_start_lsn);	/* in: buffer start lsn */
 
 /****************************************************************
 Gets a log block flush bit. */
@@ -164,7 +164,7 @@ void
 log_block_set_checkpoint_no(
 /*========================*/
 	byte*		log_block,	/* in: log block */
-	ib_ulonglong	no)		/* in: checkpoint no */
+	ib_uint64_t	no)		/* in: checkpoint no */
 {
 	mach_write_to_4(log_block + LOG_BLOCK_CHECKPOINT_NO, (ulint) no);
 }
@@ -177,7 +177,7 @@ log_block_convert_lsn_to_no(
 /*========================*/
 				/* out: log block number,
 				it is > 0 and <= 1G */
-	ib_ulonglong	lsn)	/* in: lsn of a byte within the block */
+	ib_uint64_t	lsn)	/* in: lsn of a byte within the block */
 {
 	return(((ulint) (lsn / OS_FILE_LOG_BLOCK_SIZE) & 0x3FFFFFFFUL) + 1);
 }
@@ -244,7 +244,7 @@ void
 log_block_init(
 /*===========*/
 	byte*		log_block,	/* in: pointer to the log buffer */
-	ib_ulonglong	lsn)		/* in: lsn within the log block */
+	ib_uint64_t	lsn)		/* in: lsn within the log block */
 {
 	ulint	no;
 
@@ -268,7 +268,7 @@ void
 log_block_init_in_old_format(
 /*=========================*/
 	byte*		log_block,	/* in: pointer to the log buffer */
-	ib_ulonglong	lsn)		/* in: lsn within the log block */
+	ib_uint64_t	lsn)		/* in: lsn within the log block */
 {
 	ulint	no;
 
@@ -289,19 +289,19 @@ log_block_init_in_old_format(
 Writes to the log the string given. The log must be released with
 log_release. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 log_reserve_and_write_fast(
 /*=======================*/
 				/* out: end lsn of the log record,
 				zero if did not succeed */
 	byte*		str,	/* in: string */
 	ulint		len,	/* in: string length */
-	ib_ulonglong*	start_lsn,/* out: start lsn of the log record */
+	ib_uint64_t*	start_lsn,/* out: start lsn of the log record */
 	ibool*		success)/* out: TRUE if success */
 {
 	log_t*		log	= log_sys;
 	ulint		data_len;
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 
 	*success = TRUE;
 
@@ -358,12 +358,12 @@ log_release(void)
 /****************************************************************
 Gets the current lsn. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 log_get_lsn(void)
 /*=============*/
 			/* out: current lsn */
 {
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 
 	mutex_enter(&(log_sys->mutex));
 

include/log0recv.h

@@ -28,13 +28,13 @@ recv_read_cp_info_for_backup(
 				/* out: TRUE if success */
 	byte*		hdr,	/* in: buffer containing the log group
 				header */
-	ib_ulonglong*	lsn,	/* out: checkpoint lsn */
+	ib_uint64_t*	lsn,	/* out: checkpoint lsn */
 	ulint*		offset,	/* out: checkpoint offset in the log group */
 	ulint*		fsp_limit,/* out: fsp limit of space 0,
 				1000000000 if the database is running
 				with < version 3.23.50 of InnoDB */
-	ib_ulonglong*	cp_no,	/* out: checkpoint number */
-	ib_ulonglong*	first_header_lsn);
+	ib_uint64_t*	cp_no,	/* out: checkpoint number */
+	ib_uint64_t*	first_header_lsn);
 				/* out: lsn of of the start of the
 				first log file */
 /***********************************************************************
@@ -46,7 +46,7 @@ recv_scan_log_seg_for_backup(
 /*=========================*/
 	byte*		buf,		/* in: buffer containing log data */
 	ulint		buf_len,	/* in: data length in that buffer */
-	ib_ulonglong*	scanned_lsn,	/* in/out: lsn of buffer start,
+	ib_uint64_t*	scanned_lsn,	/* in/out: lsn of buffer start,
 					we return scanned lsn */
 	ulint*		scanned_checkpoint_no,
 					/* in/out: 4 lowest bytes of the
@@ -95,11 +95,11 @@ recv_recovery_from_checkpoint_start(
 /*================================*/
 					/* out: error code or DB_SUCCESS */
 	ulint		type,		/* in: LOG_CHECKPOINT or LOG_ARCHIVE */
-	ib_ulonglong	limit_lsn,	/* in: recover up to this lsn
+	ib_uint64_t	limit_lsn,	/* in: recover up to this lsn
 					if possible */
-	ib_ulonglong	min_flushed_lsn,/* in: min flushed lsn from
+	ib_uint64_t	min_flushed_lsn,/* in: min flushed lsn from
 					data files */
-	ib_ulonglong	max_flushed_lsn);/* in: max flushed lsn from
+	ib_uint64_t	max_flushed_lsn);/* in: max flushed lsn from
 					 data files */
 /************************************************************
 Completes recovery from a checkpoint. */
@@ -132,11 +132,11 @@ recv_scan_log_recs(
 	byte*		buf,		/* in: buffer containing a log segment
 					or garbage */
 	ulint		len,		/* in: buffer length */
-	ib_ulonglong	start_lsn,	/* in: buffer start lsn */
-	ib_ulonglong*	contiguous_lsn,	/* in/out: it is known that all log
+	ib_uint64_t	start_lsn,	/* in: buffer start lsn */
+	ib_uint64_t*	contiguous_lsn,	/* in/out: it is known that all log
 					groups contain contiguous log data up
 					to this lsn */
-	ib_ulonglong*	group_scanned_lsn);/* out: scanning succeeded up to
+	ib_uint64_t*	group_scanned_lsn);/* out: scanning succeeded up to
 					this lsn */
 /**********************************************************
 Resets the logs. The contents of log files will be lost! */
@@ -144,7 +144,7 @@ Resets the logs. The contents of log files will be lost! */
 void
 recv_reset_logs(
 /*============*/
-	ib_ulonglong	lsn,		/* in: reset to this lsn
+	ib_uint64_t	lsn,		/* in: reset to this lsn
 					rounded up to be divisible by
 					OS_FILE_LOG_BLOCK_SIZE, after
 					which we add
@@ -166,7 +166,7 @@ recv_reset_log_files_for_backup(
 	const char*	log_dir,	/* in: log file directory path */
 	ulint		n_log_files,	/* in: number of log files */
 	ulint		log_file_size,	/* in: log file size */
-	ib_ulonglong	lsn);		/* in: new start lsn, must be
+	ib_uint64_t	lsn);		/* in: new start lsn, must be
 					divisible by OS_FILE_LOG_BLOCK_SIZE */
 #endif /* UNIV_HOTBACKUP */
 /************************************************************
@@ -214,9 +214,9 @@ ulint
 recv_recovery_from_archive_start(
 /*=============================*/
 					/* out: error code or DB_SUCCESS */
-	ib_ulonglong	min_flushed_lsn,/* in: min flushed lsn field from the
+	ib_uint64_t	min_flushed_lsn,/* in: min flushed lsn field from the
 					data files */
-	ib_ulonglong	limit_lsn,	/* in: recover up to this lsn if
+	ib_uint64_t	limit_lsn,	/* in: recover up to this lsn if
 					possible */
 	ulint		first_log_no);	/* in: number of the first archived
 					log file to use in the recovery; the
@@ -247,11 +247,11 @@ struct recv_struct{
 	ulint		len;	/* log record body length in bytes */
 	recv_data_t*	data;	/* chain of blocks containing the log record
 				body */
-	ib_ulonglong	start_lsn;/* start lsn of the log segment written by
+	ib_uint64_t	start_lsn;/* start lsn of the log segment written by
 				the mtr which generated this log record: NOTE
 				that this is not necessarily the start lsn of
 				this log record */
-	ib_ulonglong	end_lsn;/* end lsn of the log segment written by
+	ib_uint64_t	end_lsn;/* end lsn of the log segment written by
 				the mtr which generated this log record: NOTE
 				that this is not necessarily the end lsn of
 				this log record */
@@ -285,7 +285,7 @@ struct recv_sys_struct{
 	ibool		apply_batch_on;
 				/* this is TRUE when a log rec application
 				batch is running */
-	ib_ulonglong	lsn;	/* log sequence number */
+	ib_uint64_t	lsn;	/* log sequence number */
 	ulint		last_log_buf_size;
 				/* size of the log buffer when the database
 				last time wrote to the log */
@@ -297,12 +297,12 @@ struct recv_sys_struct{
 				preceding buffer */
 	byte*		buf;	/* buffer for parsing log records */
 	ulint		len;	/* amount of data in buf */
-	ib_ulonglong	parse_start_lsn;
+	ib_uint64_t	parse_start_lsn;
 				/* this is the lsn from which we were able to
 				start parsing log records and adding them to
 				the hash table; zero if a suitable
 				start point not found yet */
-	ib_ulonglong	scanned_lsn;
+	ib_uint64_t	scanned_lsn;
 				/* the log data has been scanned up to this
 				lsn */
 	ulint		scanned_checkpoint_no;
@@ -311,10 +311,10 @@ struct recv_sys_struct{
 	ulint		recovered_offset;
 				/* start offset of non-parsed log records in
 				buf */
-	ib_ulonglong	recovered_lsn;
+	ib_uint64_t	recovered_lsn;
 				/* the log records have been parsed up to
 				this lsn */
-	ib_ulonglong	limit_lsn;/* recovery should be made at most up to this
+	ib_uint64_t	limit_lsn;/* recovery should be made at most up to this
 				lsn */
 	ibool		found_corrupt_log;
 				/* this is set to TRUE if we during log

include/mach0data.h

@@ -187,7 +187,7 @@ void
 mach_write_ull(
 /*===========*/
 	byte*		b,	/* in: pointer to 8 bytes where to store */
-	ib_ulonglong	n);	/* in: 64-bit integer to be stored */
+	ib_uint64_t	n);	/* in: 64-bit integer to be stored */
 /************************************************************
 The following function is used to fetch data from 8 consecutive
 bytes. The most significant byte is at the lowest address. */
@@ -201,7 +201,7 @@ mach_read_from_8(
 The following function is used to fetch data from 8 consecutive
 bytes. The most significant byte is at the lowest address. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 mach_read_ull(
 /*==========*/
 				/* out: 64-bit integer */

include/mach0data.ic

@@ -281,7 +281,7 @@ void
 mach_write_ull(
 /*===========*/
 	byte*		b,	/* in: pointer to 8 bytes where to store */
-	ib_ulonglong	n)	/* in: 64-bit integer to be stored */
+	ib_uint64_t	n)	/* in: 64-bit integer to be stored */
 {
 	ut_ad(b);
 
@@ -314,16 +314,16 @@ mach_read_from_8(
 The following function is used to fetch data from 8 consecutive
 bytes. The most significant byte is at the lowest address. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 mach_read_ull(
 /*==========*/
 				/* out: 64-bit integer */
 	const byte*	b)	/* in: pointer to 8 bytes */
 {
-	ib_ulonglong	ull;
+	ib_uint64_t	ull;
 
-	ull = ((ib_ulonglong) mach_read_from_4(b)) << 32;
-	ull |= (ib_ulonglong) mach_read_from_4(b + 4);
+	ull = ((ib_uint64_t) mach_read_from_4(b)) << 32;
+	ull |= (ib_uint64_t) mach_read_from_4(b + 4);
 
 	return(ull);
 }

include/mtr0mtr.h

@@ -350,9 +350,9 @@ struct mtr_struct{
 				have been written to the mtr log */
 	ulint		log_mode; /* specifies which operations should be
 				logged; default value MTR_LOG_ALL */
-	ib_ulonglong	start_lsn;/* start lsn of the possible log entry for
+	ib_uint64_t	start_lsn;/* start lsn of the possible log entry for
 				this mtr */
-	ib_ulonglong	end_lsn;/* end lsn of the possible log entry for
+	ib_uint64_t	end_lsn;/* end lsn of the possible log entry for
 				this mtr */
 	ulint		magic_n;
 };

include/srv0start.h

@@ -78,8 +78,8 @@ int
 innobase_shutdown_for_mysql(void);
 /*=============================*/
 				/* out: DB_SUCCESS or error code */
-extern	ib_ulonglong	srv_shutdown_lsn;
-extern	ib_ulonglong	srv_start_lsn;
+extern	ib_uint64_t	srv_shutdown_lsn;
+extern	ib_uint64_t	srv_start_lsn;
 
 #ifdef __NETWARE__
 void set_panic_flag_for_netware(void);

include/trx0trx.h

@@ -446,7 +446,7 @@ struct trx_struct{
 					were modifications by the transaction;
 					in that case we must flush the log
 					in trx_commit_complete_for_mysql() */
-	ib_ulonglong	commit_lsn;	/* lsn at the time of the commit */
+	ib_uint64_t	commit_lsn;	/* lsn at the time of the commit */
 	ibool		dict_operation;	/* TRUE if the trx is used to create
 					a table, create an index, or drop a
 					table.	This is a hint that the table

include/univ.i

@@ -202,10 +202,10 @@ typedef long int		lint;
 
 #ifdef __WIN__
 typedef __int64			ib_longlong;
-typedef unsigned __int64	ib_ulonglong;
+typedef unsigned __int64	ib_uint64_t;
 #else
 typedef longlong		ib_longlong;
-typedef ulonglong		ib_ulonglong;
+typedef ulonglong		ib_uint64_t;
 #endif
 
 #ifndef __WIN__
@@ -223,8 +223,8 @@ typedef ulonglong		ib_ulonglong;
 /* Maximum value for a ulint */
 #define ULINT_MAX		((ulint)(-2))
 
-/* Maximum value for ib_ulonglong */
-#define IB_ULONGLONG_MAX	((ib_ulonglong) (~0ULL))
+/* Maximum value for ib_uint64_t */
+#define IB_ULONGLONG_MAX	((ib_uint64_t) (~0ULL))
 
 /* This 'ibool' type is used within Innobase. Remember that different included
 headers may define 'bool' differently. Do not assume that 'bool' is a ulint! */

include/ut0byte.h

@@ -151,21 +151,21 @@ ut_dulint_align_up(
 /************************************************************
 Rounds a dulint downward to a multiple of a power of 2. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 ut_ulonglong_align_down(
 /*====================*/
 					/* out: rounded value */
-	ib_ulonglong	 n,		/* in: number to be rounded */
+	ib_uint64_t	 n,		/* in: number to be rounded */
 	ulint		 align_no);	/* in: align by this number
 					which must be a power of 2 */
 /************************************************************
-Rounds ib_ulonglong upward to a multiple of a power of 2. */
+Rounds ib_uint64_t upward to a multiple of a power of 2. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 ut_ulonglong_align_up(
 /*==================*/
 					/* out: rounded value */
-	ib_ulonglong	 n,		/* in: number to be rounded */
+	ib_uint64_t	 n,		/* in: number to be rounded */
 	ulint		 align_no);	/* in: align by this number
 					which must be a power of 2 */
 /***********************************************************

include/ut0byte.ic

@@ -261,34 +261,34 @@ ut_dulint_align_up(
 }
 
 /************************************************************
-Rounds ib_ulonglong downward to a multiple of a power of 2. */
+Rounds ib_uint64_t downward to a multiple of a power of 2. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 ut_ulonglong_align_down(
 /*====================*/
 					/* out: rounded value */
-	ib_ulonglong	 n,		/* in: number to be rounded */
+	ib_uint64_t	 n,		/* in: number to be rounded */
 	ulint		 align_no)	/* in: align by this number
 					which must be a power of 2 */
 {
 	ut_ad(align_no > 0);
 	ut_ad(ut_is_2pow(align_no));
 
-	return(n & (ib_ulonglong) ~(align_no - 1));
+	return(n & (ib_uint64_t) ~(align_no - 1));
 }
 
 /************************************************************
-Rounds ib_ulonglong upward to a multiple of a power of 2. */
+Rounds ib_uint64_t upward to a multiple of a power of 2. */
 UNIV_INLINE
-ib_ulonglong
+ib_uint64_t
 ut_ulonglong_align_up(
 /*==================*/
 					/* out: rounded value */
-	ib_ulonglong	 n,		/* in: number to be rounded */
+	ib_uint64_t	 n,		/* in: number to be rounded */
 	ulint		 align_no)	/* in: align by this number
 					which must be a power of 2 */
 {
-	ib_ulonglong	align_1 = (ib_ulonglong) align_no - 1;
+	ib_uint64_t	align_1 = (ib_uint64_t) align_no - 1;
 
 	ut_ad(align_no > 0);
 	ut_ad(ut_is_2pow(align_no));

log/log0log.c

@@ -159,11 +159,11 @@ log_fsp_current_free_limit_set_and_checkpoint(
 Returns the oldest modified block lsn in the pool, or log_sys->lsn if none
 exists. */
 static
-ib_ulonglong
+ib_uint64_t
 log_buf_pool_get_oldest_modification(void)
 /*======================================*/
 {
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 
 #ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(log_sys->mutex)));
@@ -183,7 +183,7 @@ log_buf_pool_get_oldest_modification(void)
 Opens the log for log_write_low. The log must be closed with log_close and
 released with log_release. */
 
-ib_ulonglong
+ib_uint64_t
 log_reserve_and_open(
 /*=================*/
 			/* out: start lsn of the log record */
@@ -327,15 +327,15 @@ log_write_low(
 /****************************************************************
 Closes the log. */
 
-ib_ulonglong
+ib_uint64_t
 log_close(void)
 /*===========*/
 			/* out: lsn */
 {
 	byte*		log_block;
 	ulint		first_rec_group;
-	ib_ulonglong	oldest_lsn;
-	ib_ulonglong	lsn;
+	ib_uint64_t	oldest_lsn;
+	ib_uint64_t	lsn;
 	log_t*		log	= log_sys;
 	ulint		checkpoint_age;
 
@@ -429,7 +429,7 @@ log_pad_current_log_block(void)
 	byte		b		= MLOG_DUMMY_RECORD;
 	ulint		pad_length;
 	ulint		i;
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 
 	/* We retrieve lsn only because otherwise gcc crashed on HP-UX */
 	lsn = log_reserve_and_open(OS_FILE_LOG_BLOCK_SIZE);
@@ -512,11 +512,11 @@ ulint
 log_group_calc_lsn_offset(
 /*======================*/
 				/* out: offset within the log group */
-	ib_ulonglong	lsn,	/* in: lsn, must be within 4 GB of
+	ib_uint64_t	lsn,	/* in: lsn, must be within 4 GB of
 				group->lsn */
 	log_group_t*	group)	/* in: log group */
 {
-	ib_ulonglong	gr_lsn;
+	ib_uint64_t	gr_lsn;
 	ib_longlong	gr_lsn_size_offset;
 	ib_longlong	difference;
 	ib_longlong	group_size;
@@ -568,9 +568,9 @@ log_calc_where_lsn_is(
 						/* out: log file number */
 	ib_longlong*	log_file_offset,	/* out: offset in that file
 						(including the header) */
-	ib_ulonglong	first_header_lsn,	/* in: first log file start
+	ib_uint64_t	first_header_lsn,	/* in: first log file start
 						lsn */
-	ib_ulonglong	lsn,			/* in: lsn whose position to
+	ib_uint64_t	lsn,			/* in: lsn whose position to
 						determine */
 	ulint		n_log_files,		/* in: total number of log
 						files */
@@ -608,7 +608,7 @@ void
 log_group_set_fields(
 /*=================*/
 	log_group_t*	group,	/* in: group */
-	ib_ulonglong	lsn)	/* in: lsn for which the values should be
+	ib_uint64_t	lsn)	/* in: lsn for which the values should be
 				set */
 {
 	group->lsn_offset = log_group_calc_lsn_offset(lsn, group);
@@ -1116,7 +1116,7 @@ log_group_file_header_flush(
 	log_group_t*	group,		/* in: log group */
 	ulint		nth_file,	/* in: header to the nth file in the
 					log file space */
-	ib_ulonglong	start_lsn)	/* in: log file data starts at this
+	ib_uint64_t	start_lsn)	/* in: log file data starts at this
 					lsn */
 {
 	byte*	buf;
@@ -1182,7 +1182,7 @@ log_group_write_buf(
 	byte*		buf,		/* in: buffer */
 	ulint		len,		/* in: buffer len; must be divisible
 					by OS_FILE_LOG_BLOCK_SIZE */
-	ib_ulonglong	start_lsn,	/* in: start lsn of the buffer; must
+	ib_uint64_t	start_lsn,	/* in: start lsn of the buffer; must
 					be divisible by
 					OS_FILE_LOG_BLOCK_SIZE */
 	ulint		new_data_offset)/* in: start offset of new data in
@@ -1300,7 +1300,7 @@ flush flushed enough. If not, starts a new flush. */
 void
 log_write_up_to(
 /*============*/
-	ib_ulonglong	lsn,	/* in: log sequence number up to which
+	ib_uint64_t	lsn,	/* in: log sequence number up to which
 				the log should be written,
 				IB_ULONGLONG_MAX if not specified */
 	ulint		wait,	/* in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
@@ -1517,7 +1517,7 @@ void
 log_buffer_flush_to_disk(void)
 /*==========================*/
 {
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 
 	mutex_enter(&(log_sys->mutex));
 
@@ -1538,7 +1538,7 @@ log_flush_margin(void)
 {
 	ibool		do_flush	= FALSE;
 	log_t*		log		= log_sys;
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 
 	mutex_enter(&(log->mutex));
 
@@ -1573,7 +1573,7 @@ log_preflush_pool_modified_pages(
 					running, which means that we
 					could not start this flush
 					batch */
-	ib_ulonglong	new_oldest,	/* in: try to advance
+	ib_uint64_t	new_oldest,	/* in: try to advance
 					oldest_modified_lsn at least
 					to this lsn */
 	ibool		sync)		/* in: TRUE if synchronous
@@ -1695,8 +1695,8 @@ log_group_checkpoint(
 {
 	log_group_t*	group2;
 #ifdef UNIV_LOG_ARCHIVE
-	ib_ulonglong	archived_lsn;
-	ib_ulonglong	next_archived_lsn;
+	ib_uint64_t	archived_lsn;
+	ib_uint64_t	next_archived_lsn;
 #endif /* UNIV_LOG_ARCHIVE */
 	ulint		write_offset;
 	ulint		fold;
@@ -1816,13 +1816,13 @@ log_reset_first_header_and_checkpoint(
 /*==================================*/
 	byte*		hdr_buf,/* in: buffer which will be written to the
 				start of the first log file */
-	ib_ulonglong	start)	/* in: lsn of the start of the first log file;
+	ib_uint64_t	start)	/* in: lsn of the start of the first log file;
 				we pretend that there is a checkpoint at
 				start + LOG_BLOCK_HDR_SIZE */
 {
 	ulint		fold;
 	byte*		buf;
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 
 	mach_write_to_4(hdr_buf + LOG_GROUP_ID, 0);
 	mach_write_ull(hdr_buf + LOG_FILE_START_LSN, start);
@@ -1921,7 +1921,7 @@ log_checkpoint(
 				parameter TRUE, a physical write will always be
 				made to log files */
 {
-	ib_ulonglong	oldest_lsn;
+	ib_uint64_t	oldest_lsn;
 
 	if (recv_recovery_is_on()) {
 		recv_apply_hashed_log_recs(TRUE);
@@ -2002,7 +2002,7 @@ Makes a checkpoint at a given lsn or later. */
 void
 log_make_checkpoint_at(
 /*===================*/
-	ib_ulonglong	lsn,		/* in: make a checkpoint at this or a
+	ib_uint64_t	lsn,		/* in: make a checkpoint at this or a
 					later lsn, if IB_ULONGLONG_MAX, makes
 					a checkpoint at the latest lsn */
 	ibool		write_always)	/* in: the function normally checks if
@@ -2034,7 +2034,7 @@ log_checkpoint_margin(void)
 	ulint		age;
 	ulint		checkpoint_age;
 	ulint		advance;
-	ib_ulonglong	oldest_lsn;
+	ib_uint64_t	oldest_lsn;
 	ibool		sync;
 	ibool		checkpoint_sync;
 	ibool		do_checkpoint;
@@ -2092,7 +2092,7 @@ log_checkpoint_margin(void)
 	mutex_exit(&(log->mutex));
 
 	if (advance) {
-		ib_ulonglong	new_oldest = oldest_lsn + advance;
+		ib_uint64_t	new_oldest = oldest_lsn + advance;
 
 		success = log_preflush_pool_modified_pages(new_oldest, sync);
 
@@ -2131,8 +2131,8 @@ log_group_read_log_seg(
 	ulint		type,		/* in: LOG_ARCHIVE or LOG_RECOVER */
 	byte*		buf,		/* in: buffer where to read */
 	log_group_t*	group,		/* in: log group */
-	ib_ulonglong	start_lsn,	/* in: read area start */
-	ib_ulonglong	end_lsn)	/* in: read area end */
+	ib_uint64_t	start_lsn,	/* in: read area start */
+	ib_uint64_t	end_lsn)	/* in: read area end */
 {
 	ulint	len;
 	ulint	source_offset;
@@ -2203,7 +2203,7 @@ log_group_archive_file_header_write(
 	ulint		nth_file,	/* in: header to the nth file in the
 					archive log file space */
 	ulint		file_no,	/* in: archived file number */
-	ib_ulonglong	start_lsn)	/* in: log file data starts at this
+	ib_uint64_t	start_lsn)	/* in: log file data starts at this
 					lsn */
 {
 	byte*	buf;
@@ -2243,7 +2243,7 @@ log_group_archive_completed_header_write(
 	log_group_t*	group,		/* in: log group */
 	ulint		nth_file,	/* in: header to the nth file in the
 					archive log file space */
-	ib_ulonglong	end_lsn)	/* in: end lsn of the file */
+	ib_uint64_t	end_lsn)	/* in: end lsn of the file */
 {
 	byte*	buf;
 	ulint	dest_offset;
@@ -2279,8 +2279,8 @@ log_group_archive(
 	log_group_t*	group)	/* in: log group */
 {
 	os_file_t	 file_handle;
-	ib_ulonglong	start_lsn;
-	ib_ulonglong	end_lsn;
+	ib_uint64_t	start_lsn;
+	ib_uint64_t	end_lsn;
 	char		name[1024];
 	byte*		buf;
 	ulint		len;
@@ -2444,8 +2444,8 @@ log_archive_write_complete_groups(void)
 	ulint		end_offset;
 	ulint		trunc_files;
 	ulint		n_files;
-	ib_ulonglong	start_lsn;
-	ib_ulonglong	end_lsn;
+	ib_uint64_t	start_lsn;
+	ib_uint64_t	end_lsn;
 	ulint		i;
 
 #ifdef UNIV_SYNC_DEBUG
@@ -2587,8 +2587,8 @@ log_archive_do(
 			archive */
 {
 	ibool		calc_new_limit;
-	ib_ulonglong	start_lsn;
-	ib_ulonglong	limit_lsn;
+	ib_uint64_t	start_lsn;
+	ib_uint64_t	limit_lsn;
 
 	calc_new_limit = TRUE;
 loop:
@@ -2703,7 +2703,7 @@ void
 log_archive_all(void)
 /*=================*/
 {
-	ib_ulonglong	present_lsn;
+	ib_uint64_t	present_lsn;
 	ulint		dummy;
 
 	mutex_enter(&(log_sys->mutex));
@@ -3038,7 +3038,7 @@ void
 logs_empty_and_mark_files_at_shutdown(void)
 /*=======================================*/
 {
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 	ulint		arch_log_no;
 
 	if (srv_print_verbose_log) {
@@ -3229,10 +3229,10 @@ log_check_log_recs(
 					the log segment in the
 					log_sys->buf log buffer */
 	ulint		len,		/* in: segment length in bytes */
-	ib_ulonglong	buf_start_lsn)	/* in: buffer start lsn */
+	ib_uint64_t	buf_start_lsn)	/* in: buffer start lsn */
 {
-	ib_ulonglong	contiguous_lsn;
-	ib_ulonglong	scanned_lsn;
+	ib_uint64_t	contiguous_lsn;
+	ib_uint64_t	scanned_lsn;
 	byte*		start;
 	byte*		end;
 	byte*		buf1;
@@ -3279,7 +3279,7 @@ log_peek_lsn(
 /*=========*/
 				/* out: TRUE if success, FALSE if
 				could not get the log system mutex */
-	ib_ulonglong*	lsn)	/* out: if returns TRUE, current lsn is here */
+	ib_uint64_t*	lsn)	/* out: if returns TRUE, current lsn is here */
 {
 	if (0 == mutex_enter_nowait(&(log_sys->mutex), __FILE__, __LINE__)) {
 		*lsn = log_sys->lsn;

log/log0recv.c

@@ -97,7 +97,7 @@ ulint	recv_n_pool_free_frames		= 256;
 is bigger than the lsn we are able to scan up to, that is an indication that
 the recovery failed and the database may be corrupt. */
 
-ib_ulonglong	recv_max_page_lsn;
+ib_uint64_t	recv_max_page_lsn;
 
 /************************************************************
 Creates the recovery system. */
@@ -218,20 +218,20 @@ void
 recv_truncate_group(
 /*================*/
 	log_group_t*	group,		/* in: log group */
-	ib_ulonglong	recovered_lsn,	/* in: recovery succeeded up to this
+	ib_uint64_t	recovered_lsn,	/* in: recovery succeeded up to this
 					lsn */
-	ib_ulonglong	limit_lsn,	/* in: this was the limit for
+	ib_uint64_t	limit_lsn,	/* in: this was the limit for
 					recovery */
-	ib_ulonglong	checkpoint_lsn,	/* in: recovery was started from this
+	ib_uint64_t	checkpoint_lsn,	/* in: recovery was started from this
 					checkpoint */
-	ib_ulonglong	archived_lsn)	/* in: the log has been archived up to
+	ib_uint64_t	archived_lsn)	/* in: the log has been archived up to
 					this lsn */
 {
-	ib_ulonglong	start_lsn;
-	ib_ulonglong	end_lsn;
-	ib_ulonglong	finish_lsn1;
-	ib_ulonglong	finish_lsn2;
-	ib_ulonglong	finish_lsn;
+	ib_uint64_t	start_lsn;
+	ib_uint64_t	end_lsn;
+	ib_uint64_t	finish_lsn1;
+	ib_uint64_t	finish_lsn2;
+	ib_uint64_t	finish_lsn;
 	ulint		len;
 	ulint		i;
 
@@ -322,11 +322,11 @@ recv_copy_group(
 						group */
 	log_group_t*	group,			/* in: copy to this log
 						group */
-	ib_ulonglong	recovered_lsn)		/* in: recovery succeeded up
+	ib_uint64_t	recovered_lsn)		/* in: recovery succeeded up
 						to this lsn */
 {
-	ib_ulonglong	start_lsn;
-	ib_ulonglong	end_lsn;
+	ib_uint64_t	start_lsn;
+	ib_uint64_t	end_lsn;
 	ulint		len;
 
 	if (group->scanned_lsn >= recovered_lsn) {
@@ -375,10 +375,10 @@ recv_synchronize_groups(
 						log group */
 {
 	log_group_t*	group;
-	ib_ulonglong	start_lsn;
-	ib_ulonglong	end_lsn;
-	ib_ulonglong	recovered_lsn;
-	ib_ulonglong	limit_lsn;
+	ib_uint64_t	start_lsn;
+	ib_uint64_t	end_lsn;
+	ib_uint64_t	recovered_lsn;
+	ib_uint64_t	limit_lsn;
 
 	recovered_lsn = recv_sys->recovered_lsn;
 	limit_lsn = recv_sys->limit_lsn;
@@ -471,8 +471,8 @@ recv_find_max_checkpoint(
 					LOG_CHECKPOINT_2 */
 {
 	log_group_t*	group;
-	ib_ulonglong	max_no;
-	ib_ulonglong	checkpoint_no;
+	ib_uint64_t	max_no;
+	ib_uint64_t	checkpoint_no;
 	ulint		field;
 	byte*		buf;
 
@@ -569,18 +569,18 @@ recv_read_cp_info_for_backup(
 				/* out: TRUE if success */
 	byte*		hdr,	/* in: buffer containing the log group
 				header */
-	ib_ulonglong*	lsn,	/* out: checkpoint lsn */
+	ib_uint64_t*	lsn,	/* out: checkpoint lsn */
 	ulint*		offset,	/* out: checkpoint offset in the log group */
 	ulint*		fsp_limit,/* out: fsp limit of space 0,
 				1000000000 if the database is running
 				with < version 3.23.50 of InnoDB */
-	ib_ulonglong*	cp_no,	/* out: checkpoint number */
-	ib_ulonglong*	first_header_lsn)
+	ib_uint64_t*	cp_no,	/* out: checkpoint number */
+	ib_uint64_t*	first_header_lsn)
 				/* out: lsn of of the start of the
 				first log file */
 {
 	ulint		max_cp		= 0;
-	ib_ulonglong	max_cp_no	= 0;
+	ib_uint64_t	max_cp_no	= 0;
 	byte*		cp_buf;
 
 	cp_buf = hdr + LOG_CHECKPOINT_1;
@@ -676,7 +676,7 @@ recv_scan_log_seg_for_backup(
 /*=========================*/
 	byte*		buf,		/* in: buffer containing log data */
 	ulint		buf_len,	/* in: data length in that buffer */
-	ib_ulonglong*	scanned_lsn,	/* in/out: lsn of buffer start,
+	ib_uint64_t*	scanned_lsn,	/* in/out: lsn of buffer start,
 					we return scanned lsn */
 	ulint*		scanned_checkpoint_no,
 					/* in/out: 4 lowest bytes of the
@@ -1040,8 +1040,8 @@ recv_add_to_hash_table(
 	ulint		page_no,	/* in: page number */
 	byte*		body,		/* in: log record body */
 	byte*		rec_end,	/* in: log record end */
-	ib_ulonglong	start_lsn,	/* in: start lsn of the mtr */
-	ib_ulonglong	end_lsn)	/* in: end lsn of the mtr */
+	ib_uint64_t	start_lsn,	/* in: start lsn of the mtr */
+	ib_uint64_t	end_lsn)	/* in: end lsn of the mtr */
 {
 	recv_t*		recv;
 	ulint		len;
@@ -1168,10 +1168,10 @@ recv_recover_page(
 	recv_addr_t*	recv_addr;
 	recv_t*		recv;
 	byte*		buf;
-	ib_ulonglong	start_lsn;
-	ib_ulonglong	end_lsn;
-	ib_ulonglong	page_lsn;
-	ib_ulonglong	page_newest_lsn;
+	ib_uint64_t	start_lsn;
+	ib_uint64_t	end_lsn;
+	ib_uint64_t	page_lsn;
+	ib_uint64_t	page_newest_lsn;
 	ibool		modification_to_page;
 	ibool		success;
 	mtr_t		mtr;
@@ -1764,11 +1764,11 @@ recv_parse_log_rec(
 /***********************************************************
 Calculates the new value for lsn when more data is added to the log. */
 static
-ib_ulonglong
+ib_uint64_t
 recv_calc_lsn_on_data_add(
 /*======================*/
-	ib_ulonglong	lsn,	/* in: old lsn */
-	ib_ulonglong	len)	/* in: this many bytes of data is
+	ib_uint64_t	lsn,	/* in: old lsn */
+	ib_uint64_t	len)	/* in: this many bytes of data is
 				added, log block headers not included */
 {
 	ulint	frag_len;
@@ -1883,8 +1883,8 @@ recv_parse_log_recs(
 	ulint		single_rec;
 	ulint		len;
 	ulint		total_len;
-	ib_ulonglong	new_recovered_lsn;
-	ib_ulonglong	old_lsn;
+	ib_uint64_t	new_recovered_lsn;
+	ib_uint64_t	old_lsn;
 	byte		type;
 	ulint		space;
 	ulint		page_no;
@@ -2118,7 +2118,7 @@ recv_sys_add_to_parsing_buf(
 /*========================*/
 					/* out: TRUE if more data added */
 	byte*		log_block,	/* in: log block */
-	ib_ulonglong	scanned_lsn)	/* in: lsn of how far we were able
+	ib_uint64_t	scanned_lsn)	/* in: lsn of how far we were able
 					to find data in this log block */
 {
 	ulint	more_len;
@@ -2224,16 +2224,16 @@ recv_scan_log_recs(
 	byte*		buf,		/* in: buffer containing a log segment
 					or garbage */
 	ulint		len,		/* in: buffer length */
-	ib_ulonglong	start_lsn,	/* in: buffer start lsn */
-	ib_ulonglong*	contiguous_lsn,	/* in/out: it is known that all log
+	ib_uint64_t	start_lsn,	/* in: buffer start lsn */
+	ib_uint64_t*	contiguous_lsn,	/* in/out: it is known that all log
 					groups contain contiguous log data up
 					to this lsn */
-	ib_ulonglong*	group_scanned_lsn)/* out: scanning succeeded up to
+	ib_uint64_t*	group_scanned_lsn)/* out: scanning succeeded up to
 					this lsn */
 {
 	byte*		log_block;
 	ulint		no;
-	ib_ulonglong	scanned_lsn;
+	ib_uint64_t	scanned_lsn;
 	ibool		finished;
 	ulint		data_len;
 	ibool		more_data;
@@ -2421,15 +2421,15 @@ void
 recv_group_scan_log_recs(
 /*=====================*/
 	log_group_t*	group,		/* in: log group */
-	ib_ulonglong*	contiguous_lsn,	/* in/out: it is known that all log
+	ib_uint64_t*	contiguous_lsn,	/* in/out: it is known that all log
 					groups contain contiguous log data up
 					to this lsn */
-	ib_ulonglong*	group_scanned_lsn)/* out: scanning succeeded up to
+	ib_uint64_t*	group_scanned_lsn)/* out: scanning succeeded up to
 					this lsn */
 {
 	ibool		finished;
-	ib_ulonglong	start_lsn;
-	ib_ulonglong	end_lsn;
+	ib_uint64_t	start_lsn;
+	ib_uint64_t	end_lsn;
 
 	finished = FALSE;
 
@@ -2470,23 +2470,23 @@ recv_recovery_from_checkpoint_start(
 /*================================*/
 					/* out: error code or DB_SUCCESS */
 	ulint		type,		/* in: LOG_CHECKPOINT or LOG_ARCHIVE */
-	ib_ulonglong	limit_lsn,	/* in: recover up to this lsn
+	ib_uint64_t	limit_lsn,	/* in: recover up to this lsn
 					if possible */
-	ib_ulonglong	min_flushed_lsn,/* in: min flushed lsn from
+	ib_uint64_t	min_flushed_lsn,/* in: min flushed lsn from
 					data files */
-	ib_ulonglong	max_flushed_lsn)/* in: max flushed lsn from
+	ib_uint64_t	max_flushed_lsn)/* in: max flushed lsn from
 					data files */
 {
 	log_group_t*	group;
 	log_group_t*	max_cp_group;
 	log_group_t*	up_to_date_group;
 	ulint		max_cp_field;
-	ib_ulonglong	checkpoint_lsn;
-	ib_ulonglong	checkpoint_no;
-	ib_ulonglong	old_scanned_lsn;
-	ib_ulonglong	group_scanned_lsn;
-	ib_ulonglong	contiguous_lsn;
-	ib_ulonglong	archived_lsn;
+	ib_uint64_t	checkpoint_lsn;
+	ib_uint64_t	checkpoint_no;
+	ib_uint64_t	old_scanned_lsn;
+	ib_uint64_t	group_scanned_lsn;
+	ib_uint64_t	contiguous_lsn;
+	ib_uint64_t	archived_lsn;
 	ulint		capacity;
 	byte*		buf;
 	byte		log_hdr_buf[LOG_FILE_HDR_SIZE];
@@ -2901,7 +2901,7 @@ Resets the logs. The contents of log files will be lost! */
 void
 recv_reset_logs(
 /*============*/
-	ib_ulonglong	lsn,		/* in: reset to this lsn
+	ib_uint64_t	lsn,		/* in: reset to this lsn
 					rounded up to be divisible by
 					OS_FILE_LOG_BLOCK_SIZE, after
 					which we add
@@ -2976,7 +2976,7 @@ recv_reset_log_files_for_backup(
 	const char*	log_dir,	/* in: log file directory path */
 	ulint		n_log_files,	/* in: number of log files */
 	ulint		log_file_size,	/* in: log file size */
-	ib_ulonglong	lsn)		/* in: new start lsn, must be
+	ib_uint64_t	lsn)		/* in: new start lsn, must be
 					divisible by OS_FILE_LOG_BLOCK_SIZE */
 {
 	os_file_t	log_file;
@@ -3070,10 +3070,10 @@ log_group_recover_from_archive_file(
 	log_group_t*	group)		/* in: log group */
 {
 	os_file_t	file_handle;
-	ib_ulonglong	start_lsn;
-	ib_ulonglong	file_end_lsn;
-	ib_ulonglong	dummy_lsn;
-	ib_ulonglong	scanned_lsn;
+	ib_uint64_t	start_lsn;
+	ib_uint64_t	file_end_lsn;
+	ib_uint64_t	dummy_lsn;
+	ib_uint64_t	scanned_lsn;
 	ulint		len;
 	ibool		ret;
 	byte*		buf;
@@ -3257,9 +3257,9 @@ ulint
 recv_recovery_from_archive_start(
 /*=============================*/
 					/* out: error code or DB_SUCCESS */
-	ib_ulonglong	min_flushed_lsn,/* in: min flushed lsn field from the
+	ib_uint64_t	min_flushed_lsn,/* in: min flushed lsn field from the
 					data files */
-	ib_ulonglong	limit_lsn,	/* in: recover up to this lsn if
+	ib_uint64_t	limit_lsn,	/* in: recover up to this lsn if
 					possible */
 	ulint		first_log_no)	/* in: number of the first archived
 					log file to use in the recovery; the

row/row0mysql.c

@@ -2512,7 +2512,7 @@ row_import_tablespace_for_mysql(
 {
 	dict_table_t*	table;
 	ibool		success;
-	ib_ulonglong	current_lsn;
+	ib_uint64_t	current_lsn;
 	ulint		err		= DB_SUCCESS;
 
 	ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());

srv/srv0srv.c

@@ -172,7 +172,7 @@ ulint	srv_n_file_io_threads	= ULINT_MAX;
 #ifdef UNIV_LOG_ARCHIVE
 ibool		srv_log_archive_on	= FALSE;
 ibool		srv_archive_recovery	= 0;
-ib_ulonglong	srv_archive_recovery_limit_lsn;
+ib_uint64_t	srv_archive_recovery_limit_lsn;
 #endif /* UNIV_LOG_ARCHIVE */
 
 ulint	srv_lock_wait_timeout	= 1024 * 1024 * 1024;
@@ -2017,8 +2017,8 @@ srv_error_monitor_thread(
 {
 	/* number of successive fatal timeouts observed */
 	ulint		fatal_cnt	= 0;
-	ib_ulonglong	old_lsn;
-	ib_ulonglong	new_lsn;
+	ib_uint64_t	old_lsn;
+	ib_uint64_t	new_lsn;
 
 	old_lsn = srv_start_lsn;
 

srv/srv0start.c

@@ -57,9 +57,9 @@ Created 2/16/1996 Heikki Tuuri
 #include "que0que.h"
 
 /* Log sequence number immediately after startup */
-ib_ulonglong	srv_start_lsn;
+ib_uint64_t	srv_start_lsn;
 /* Log sequence number at shutdown */
-ib_ulonglong	srv_shutdown_lsn;
+ib_uint64_t	srv_shutdown_lsn;
 
 #ifdef HAVE_DARWIN_THREADS
 # include <sys/utsname.h>
@@ -698,9 +698,9 @@ open_or_create_data_files(
 	ulint*		max_arch_log_no,/* out: max of archived log
 					numbers in data files */
 #endif /* UNIV_LOG_ARCHIVE */
-	ib_ulonglong*	min_flushed_lsn,/* out: min of flushed lsn
+	ib_uint64_t*	min_flushed_lsn,/* out: min of flushed lsn
 					values in data files */
-	ib_ulonglong*	max_flushed_lsn,/* out: max of flushed lsn
+	ib_uint64_t*	max_flushed_lsn,/* out: max of flushed lsn
 					values in data files */
 	ulint*		sum_of_new_sizes)/* out: sum of sizes of the
 					new files added */
@@ -970,8 +970,8 @@ innobase_start_or_create_for_mysql(void)
 	ibool		log_file_created;
 	ibool		log_created	= FALSE;
 	ibool		log_opened	= FALSE;
-	ib_ulonglong	min_flushed_lsn;
-	ib_ulonglong	max_flushed_lsn;
+	ib_uint64_t	min_flushed_lsn;
+	ib_uint64_t	max_flushed_lsn;
 #ifdef UNIV_LOG_ARCHIVE
 	ulint		min_arch_log_no;
 	ulint		max_arch_log_no;
@@ -1385,7 +1385,7 @@ innobase_start_or_create_for_mysql(void)
 			return(DB_ERROR);
 		}
 
-		if (max_flushed_lsn < (ib_ulonglong) 1000) {
+		if (max_flushed_lsn < (ib_uint64_t) 1000) {
 			fprintf(stderr,
 				"InnoDB: Cannot initialize created"
 				" log files because\n"

trx/trx0trx.c

@@ -743,7 +743,7 @@ trx_commit_off_kernel(
 	trx_t*	trx)	/* in: transaction */
 {
 	page_t*		update_hdr_page;
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 	trx_rseg_t*	rseg;
 	trx_undo_t*	undo;
 	ibool		must_flush_log	= FALSE;
@@ -1621,7 +1621,7 @@ trx_commit_complete_for_mysql(
 			/* out: 0 or error number */
 	trx_t*	trx)	/* in: trx handle */
 {
-	ib_ulonglong	lsn	= trx->commit_lsn;
+	ib_uint64_t	lsn	= trx->commit_lsn;
 
 	ut_a(trx);
 
@@ -1799,7 +1799,7 @@ trx_prepare_off_kernel(
 	page_t*		update_hdr_page;
 	trx_rseg_t*	rseg;
 	ibool		must_flush_log	= FALSE;
-	ib_ulonglong	lsn;
+	ib_uint64_t	lsn;
 	mtr_t		mtr;
 
 #ifdef UNIV_SYNC_DEBUG