mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-19 21:42:35 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source 
64 bits.  "long long" might be longer than 64 bits on some systems.
This commit is contained in:
marko 2006-11-29 14:52:16 +00:00
parent 3fe8f14c20
commit 5e9d893508
26 changed files with 246 additions and 246 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
buf/buf0buf.c
View file

@ -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 */

6
buf/buf0flu.c
View file

@ -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);

14
fil/fil0fil.c
View file

@ -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;

2
include/btr0pcur.h
View file

@ -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!

14
include/buf0buf.h
View file

@ -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

10
include/buf0buf.ic
View file

@ -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 */

8
include/buf0flu.h
View file

@ -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,

4
include/buf0flu.ic
View file

@ -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);

8
include/fil0fil.h
View file

@ -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 */
/************************************************************************

68
include/log0log.h
View file

@ -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

20
include/log0log.ic
View file

@ -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));

42
include/log0recv.h
View file

@ -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

4
include/mach0data.h
View file

@ -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 */

10
include/mach0data.ic
View file

@ -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);
}

4
include/mtr0mtr.h
View file

@ -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;
};

4
include/srv0start.h
View file

@ -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);

2
include/trx0trx.h
View file

@ -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

8
include/univ.i
View file

@ -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! */

10
include/ut0byte.h
View file

@ -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 */
/***********************************************************

16
include/ut0byte.ic
View file

@ -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));

84
log/log0log.c
View file

@ -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 @@ part_loop:
/****************************************************************
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 @@ loop:
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;

122
log/log0recv.c
View file

@ -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

2
row/row0mysql.c
View file

@ -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());

6
srv/srv0srv.c
View file

@ -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;

14
srv/srv0start.c
View file

@ -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"

6
trx/trx0trx.c
View file

@ -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