mirror of
https://github.com/MariaDB/server.git
synced 2025-11-03 14:33:32 +03:00
d0b61c03bf
From revision r5733 to r5747 Detailed revision comments: r5733 | sunny | 2009-09-02 02:05:15 -0500 (Wed, 02 Sep 2009) | 6 lines branches/zip: Fix a regression introduced by the fix for bug#26316. We check whether a transaction holds any AUTOINC locks before we acquire the kernel mutex and release those locks. Fix for rb://153. Approved by Marko. r5734 | sunny | 2009-09-02 02:08:45 -0500 (Wed, 02 Sep 2009) | 2 lines branches/zip: Update ChangeLog with r5733 changes. r5735 | marko | 2009-09-02 02:43:09 -0500 (Wed, 02 Sep 2009) | 2 lines branches/zip: univ.i: Do not undefine PACKAGE or VERSION. InnoDB source code does not refer to these macros. r5736 | marko | 2009-09-02 02:53:19 -0500 (Wed, 02 Sep 2009) | 1 line branches/zip: Enclose some timestamp functions in #ifndef UNIV_HOTBACKUP. r5743 | marko | 2009-09-03 01:36:12 -0500 (Thu, 03 Sep 2009) | 3 lines branches/zip: log_reserve_and_write_fast(): Remove the redundant output parameter "success". Success is also indicated by a nonzero return value. r5744 | marko | 2009-09-03 03:28:35 -0500 (Thu, 03 Sep 2009) | 1 line branches/zip: ut_align(): Make ptr const, like in ut_align_down(). r5745 | marko | 2009-09-03 03:38:22 -0500 (Thu, 03 Sep 2009) | 2 lines branches/zip: log_check_log_recs(): Enclose in #ifdef UNIV_LOG_DEBUG. Add const qualifiers. r5746 | marko | 2009-09-03 03:55:36 -0500 (Thu, 03 Sep 2009) | 2 lines branches/zip: log_reserve_and_write_fast(): Do not cache the log_sys pointer in a local variable. r5747 | marko | 2009-09-03 05:46:38 -0500 (Thu, 03 Sep 2009) | 2 lines branches/zip: recv_scan_log_recs(): Replace while with do...while, because the termination condition will always hold on the first iteration.
271 lines
8.1 KiB
C
271 lines
8.1 KiB
C
/*****************************************************************************
|
|
|
|
Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved.
|
|
|
|
This program is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free Software
|
|
Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
|
|
Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/******************************************************************//**
|
|
@file include/ut0byte.h
|
|
Utilities for byte operations
|
|
|
|
Created 1/20/1994 Heikki Tuuri
|
|
***********************************************************************/
|
|
|
|
#ifndef ut0byte_h
|
|
#define ut0byte_h
|
|
|
|
|
|
#include "univ.i"
|
|
|
|
/** Pair of ulint integers. */
|
|
typedef struct dulint_struct dulint;
|
|
/** Type definition for a 64-bit unsigned integer, which works also
|
|
in 32-bit machines. NOTE! Access the fields only with the accessor
|
|
functions. This definition appears here only for the compiler to
|
|
know the size of a dulint. */
|
|
struct dulint_struct{
|
|
ulint high; /*!< most significant 32 bits */
|
|
ulint low; /*!< least significant 32 bits */
|
|
};
|
|
|
|
/** Zero value for a dulint */
|
|
extern const dulint ut_dulint_zero;
|
|
|
|
/** Maximum value for a dulint */
|
|
extern const dulint ut_dulint_max;
|
|
|
|
/*******************************************************//**
|
|
Creates a 64-bit dulint out of two ulints.
|
|
@return created dulint */
|
|
UNIV_INLINE
|
|
dulint
|
|
ut_dulint_create(
|
|
/*=============*/
|
|
ulint high, /*!< in: high-order 32 bits */
|
|
ulint low); /*!< in: low-order 32 bits */
|
|
/*******************************************************//**
|
|
Gets the high-order 32 bits of a dulint.
|
|
@return 32 bits in ulint */
|
|
UNIV_INLINE
|
|
ulint
|
|
ut_dulint_get_high(
|
|
/*===============*/
|
|
dulint d); /*!< in: dulint */
|
|
/*******************************************************//**
|
|
Gets the low-order 32 bits of a dulint.
|
|
@return 32 bits in ulint */
|
|
UNIV_INLINE
|
|
ulint
|
|
ut_dulint_get_low(
|
|
/*==============*/
|
|
dulint d); /*!< in: dulint */
|
|
/*******************************************************//**
|
|
Converts a dulint (a struct of 2 ulints) to ib_int64_t, which is a 64-bit
|
|
integer type.
|
|
@return value in ib_int64_t type */
|
|
UNIV_INLINE
|
|
ib_int64_t
|
|
ut_conv_dulint_to_longlong(
|
|
/*=======================*/
|
|
dulint d); /*!< in: dulint */
|
|
/*******************************************************//**
|
|
Tests if a dulint is zero.
|
|
@return TRUE if zero */
|
|
UNIV_INLINE
|
|
ibool
|
|
ut_dulint_is_zero(
|
|
/*==============*/
|
|
dulint a); /*!< in: dulint */
|
|
/*******************************************************//**
|
|
Compares two dulints.
|
|
@return -1 if a < b, 0 if a == b, 1 if a > b */
|
|
UNIV_INLINE
|
|
int
|
|
ut_dulint_cmp(
|
|
/*==========*/
|
|
dulint a, /*!< in: dulint */
|
|
dulint b); /*!< in: dulint */
|
|
/*******************************************************//**
|
|
Calculates the max of two dulints.
|
|
@return max(a, b) */
|
|
UNIV_INLINE
|
|
dulint
|
|
ut_dulint_get_max(
|
|
/*==============*/
|
|
dulint a, /*!< in: dulint */
|
|
dulint b); /*!< in: dulint */
|
|
/*******************************************************//**
|
|
Calculates the min of two dulints.
|
|
@return min(a, b) */
|
|
UNIV_INLINE
|
|
dulint
|
|
ut_dulint_get_min(
|
|
/*==============*/
|
|
dulint a, /*!< in: dulint */
|
|
dulint b); /*!< in: dulint */
|
|
/*******************************************************//**
|
|
Adds a ulint to a dulint.
|
|
@return sum a + b */
|
|
UNIV_INLINE
|
|
dulint
|
|
ut_dulint_add(
|
|
/*==========*/
|
|
dulint a, /*!< in: dulint */
|
|
ulint b); /*!< in: ulint */
|
|
/*******************************************************//**
|
|
Subtracts a ulint from a dulint.
|
|
@return a - b */
|
|
UNIV_INLINE
|
|
dulint
|
|
ut_dulint_subtract(
|
|
/*===============*/
|
|
dulint a, /*!< in: dulint */
|
|
ulint b); /*!< in: ulint, b <= a */
|
|
/*******************************************************//**
|
|
Subtracts a dulint from another. NOTE that the difference must be positive
|
|
and smaller that 4G.
|
|
@return a - b */
|
|
UNIV_INLINE
|
|
ulint
|
|
ut_dulint_minus(
|
|
/*============*/
|
|
dulint a, /*!< in: dulint; NOTE a must be >= b and at most
|
|
2 to power 32 - 1 greater */
|
|
dulint b); /*!< in: dulint */
|
|
/********************************************************//**
|
|
Rounds a dulint downward to a multiple of a power of 2.
|
|
@return rounded value */
|
|
UNIV_INLINE
|
|
dulint
|
|
ut_dulint_align_down(
|
|
/*=================*/
|
|
dulint n, /*!< in: number to be rounded */
|
|
ulint align_no); /*!< in: align by this number which must be a
|
|
power of 2 */
|
|
/********************************************************//**
|
|
Rounds a dulint upward to a multiple of a power of 2.
|
|
@return rounded value */
|
|
UNIV_INLINE
|
|
dulint
|
|
ut_dulint_align_up(
|
|
/*===============*/
|
|
dulint n, /*!< in: number to be rounded */
|
|
ulint align_no); /*!< in: align by this number which must be a
|
|
power of 2 */
|
|
/********************************************************//**
|
|
Rounds a dulint downward to a multiple of a power of 2.
|
|
@return rounded value */
|
|
UNIV_INLINE
|
|
ib_uint64_t
|
|
ut_uint64_align_down(
|
|
/*=================*/
|
|
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_uint64_t upward to a multiple of a power of 2.
|
|
@return rounded value */
|
|
UNIV_INLINE
|
|
ib_uint64_t
|
|
ut_uint64_align_up(
|
|
/*===============*/
|
|
ib_uint64_t n, /*!< in: number to be rounded */
|
|
ulint align_no); /*!< in: align by this number
|
|
which must be a power of 2 */
|
|
/*******************************************************//**
|
|
Increments a dulint variable by 1. */
|
|
#define UT_DULINT_INC(D)\
|
|
{\
|
|
if ((D).low == 0xFFFFFFFFUL) {\
|
|
(D).high = (D).high + 1;\
|
|
(D).low = 0;\
|
|
} else {\
|
|
(D).low = (D).low + 1;\
|
|
}\
|
|
}
|
|
/*******************************************************//**
|
|
Tests if two dulints are equal. */
|
|
#define UT_DULINT_EQ(D1, D2) (((D1).low == (D2).low)\
|
|
&& ((D1).high == (D2).high))
|
|
#ifdef notdefined
|
|
/************************************************************//**
|
|
Sort function for dulint arrays. */
|
|
UNIV_INTERN
|
|
void
|
|
ut_dulint_sort(
|
|
/*===========*/
|
|
dulint* arr, /*!< in/out: array to be sorted */
|
|
dulint* aux_arr,/*!< in/out: auxiliary array (same size as arr) */
|
|
ulint low, /*!< in: low bound of sort interval, inclusive */
|
|
ulint high); /*!< in: high bound of sort interval, noninclusive */
|
|
#endif /* notdefined */
|
|
|
|
/*********************************************************//**
|
|
The following function rounds up a pointer to the nearest aligned address.
|
|
@return aligned pointer */
|
|
UNIV_INLINE
|
|
void*
|
|
ut_align(
|
|
/*=====*/
|
|
const void* ptr, /*!< in: pointer */
|
|
ulint align_no); /*!< in: align by this number */
|
|
/*********************************************************//**
|
|
The following function rounds down a pointer to the nearest
|
|
aligned address.
|
|
@return aligned pointer */
|
|
UNIV_INLINE
|
|
void*
|
|
ut_align_down(
|
|
/*==========*/
|
|
const void* ptr, /*!< in: pointer */
|
|
ulint align_no) /*!< in: align by this number */
|
|
__attribute__((const));
|
|
/*********************************************************//**
|
|
The following function computes the offset of a pointer from the nearest
|
|
aligned address.
|
|
@return distance from aligned pointer */
|
|
UNIV_INLINE
|
|
ulint
|
|
ut_align_offset(
|
|
/*============*/
|
|
const void* ptr, /*!< in: pointer */
|
|
ulint align_no) /*!< in: align by this number */
|
|
__attribute__((const));
|
|
/*****************************************************************//**
|
|
Gets the nth bit of a ulint.
|
|
@return TRUE if nth bit is 1; 0th bit is defined to be the least significant */
|
|
UNIV_INLINE
|
|
ibool
|
|
ut_bit_get_nth(
|
|
/*===========*/
|
|
ulint a, /*!< in: ulint */
|
|
ulint n); /*!< in: nth bit requested */
|
|
/*****************************************************************//**
|
|
Sets the nth bit of a ulint.
|
|
@return the ulint with the bit set as requested */
|
|
UNIV_INLINE
|
|
ulint
|
|
ut_bit_set_nth(
|
|
/*===========*/
|
|
ulint a, /*!< in: ulint */
|
|
ulint n, /*!< in: nth bit requested */
|
|
ibool val); /*!< in: value for the bit to set */
|
|
|
|
#ifndef UNIV_NONINL
|
|
#include "ut0byte.ic"
|
|
#endif
|
|
|
|
#endif
|