mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 20:42:30 +01:00
ba5b97343c
Assertion `bitmap_is_set_all(&table->s->all_set)' failed in handler::ha_reset This assertion could be triggered if two connections simultaneously executed two bitmap test functions on the same bitmap. For example, the assertion could be triggered if one connection executed UPDATE while a second connection executed SELECT on the same table. Even if bitmap test functions have read-only semantics and have const bitmaps as parameter, several of them modified the internal state of the bitmap. With interleaved execution of two such functions it was possible for one function to modify the state of the same bitmap that the other function had just modified. This lead to an inconsistent state and could trigger the assert. Internally the bitmap uses 32 bit words for storage. Since bitmaps can contain any number of bits, the last word in the bitmap may not be fully used. A 32 bit mask is maintained where a bit is set if the corresponding bit in the last bitmap word is unused. The problem was that several test functions applied this mask to the last word. Sometimes the mask was negated and used to zero out the remainder of the last word and sometimes the mask was used as-is to fill the remainder of the last word with 1's. This meant that if a function first used the negated mask and another function then used the mask as-is (or vice-versa), the first function would then get the wrong result. This patch fixes the problem by changing the implementation of 9 bitmap functions that modified the bitmap state even if the bitmap was declared const. These functions now preserve the internal state of the bitmap. This makes it possible for two connections to concurrently execute two of these functions on the same bitmap without issues. The patch also removes dead testing code from my_bitmap.c. These tests have already been moved to unittest/mysys/bitmap-t.c. Existing test coverage of my_bitmap has been extended. No MTR test case added as this would require adding several sync points to the bitmap functions. The patch has been tested with a non-deterministic test case posted on the bug report.
127 lines
3.8 KiB
C
127 lines
3.8 KiB
C
/* Copyright (c) 2007, 2011, Oracle and/or its affiliates. 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
/*
|
|
Some useful bit functions
|
|
*/
|
|
|
|
C_MODE_START
|
|
#ifdef HAVE_INLINE
|
|
|
|
extern const char _my_bits_nbits[256];
|
|
extern const uchar _my_bits_reverse_table[256];
|
|
|
|
/*
|
|
Find smallest X in 2^X >= value
|
|
This can be used to divide a number with value by doing a shift instead
|
|
*/
|
|
|
|
STATIC_INLINE uint my_bit_log2(ulong value)
|
|
{
|
|
uint bit;
|
|
for (bit=0 ; value > 1 ; value>>=1, bit++) ;
|
|
return bit;
|
|
}
|
|
|
|
STATIC_INLINE uint my_count_bits(ulonglong v)
|
|
{
|
|
#if SIZEOF_LONG_LONG > 4
|
|
/* The following code is a bit faster on 16 bit machines than if we would
|
|
only shift v */
|
|
ulong v2=(ulong) (v >> 32);
|
|
return (uint) (uchar) (_my_bits_nbits[(uchar) v] +
|
|
_my_bits_nbits[(uchar) (v >> 8)] +
|
|
_my_bits_nbits[(uchar) (v >> 16)] +
|
|
_my_bits_nbits[(uchar) (v >> 24)] +
|
|
_my_bits_nbits[(uchar) (v2)] +
|
|
_my_bits_nbits[(uchar) (v2 >> 8)] +
|
|
_my_bits_nbits[(uchar) (v2 >> 16)] +
|
|
_my_bits_nbits[(uchar) (v2 >> 24)]);
|
|
#else
|
|
return (uint) (uchar) (_my_bits_nbits[(uchar) v] +
|
|
_my_bits_nbits[(uchar) (v >> 8)] +
|
|
_my_bits_nbits[(uchar) (v >> 16)] +
|
|
_my_bits_nbits[(uchar) (v >> 24)]);
|
|
#endif
|
|
}
|
|
|
|
STATIC_INLINE uint my_count_bits_uint32(uint32 v)
|
|
{
|
|
return (uint) (uchar) (_my_bits_nbits[(uchar) v] +
|
|
_my_bits_nbits[(uchar) (v >> 8)] +
|
|
_my_bits_nbits[(uchar) (v >> 16)] +
|
|
_my_bits_nbits[(uchar) (v >> 24)]);
|
|
}
|
|
|
|
|
|
/*
|
|
Next highest power of two
|
|
|
|
SYNOPSIS
|
|
my_round_up_to_next_power()
|
|
v Value to check
|
|
|
|
RETURN
|
|
Next or equal power of 2
|
|
Note: 0 will return 0
|
|
|
|
NOTES
|
|
Algorithm by Sean Anderson, according to:
|
|
http://graphics.stanford.edu/~seander/bithacks.html
|
|
(Orignal code public domain)
|
|
|
|
Comments shows how this works with 01100000000000000000000000001011
|
|
*/
|
|
|
|
STATIC_INLINE uint32 my_round_up_to_next_power(uint32 v)
|
|
{
|
|
v--; /* 01100000000000000000000000001010 */
|
|
v|= v >> 1; /* 01110000000000000000000000001111 */
|
|
v|= v >> 2; /* 01111100000000000000000000001111 */
|
|
v|= v >> 4; /* 01111111110000000000000000001111 */
|
|
v|= v >> 8; /* 01111111111111111100000000001111 */
|
|
v|= v >> 16; /* 01111111111111111111111111111111 */
|
|
return v+1; /* 10000000000000000000000000000000 */
|
|
}
|
|
|
|
STATIC_INLINE uint32 my_clear_highest_bit(uint32 v)
|
|
{
|
|
uint32 w=v >> 1;
|
|
w|= w >> 1;
|
|
w|= w >> 2;
|
|
w|= w >> 4;
|
|
w|= w >> 8;
|
|
w|= w >> 16;
|
|
return v & w;
|
|
}
|
|
|
|
STATIC_INLINE uint32 my_reverse_bits(uint32 key)
|
|
{
|
|
return
|
|
(_my_bits_reverse_table[ key & 255] << 24) |
|
|
(_my_bits_reverse_table[(key>> 8) & 255] << 16) |
|
|
(_my_bits_reverse_table[(key>>16) & 255] << 8) |
|
|
_my_bits_reverse_table[(key>>24) ];
|
|
}
|
|
|
|
#else /* HAVE_INLINE */
|
|
extern uint my_bit_log2(ulong value);
|
|
extern uint32 my_round_up_to_next_power(uint32 v);
|
|
uint32 my_clear_highest_bit(uint32 v);
|
|
uint32 my_reverse_bits(uint32 key);
|
|
extern uint my_count_bits(ulonglong v);
|
|
extern uint my_count_bits_uint32(uint32 v);
|
|
#endif /* HAVE_INLINE */
|
|
C_MODE_END
|