mirror of
https://github.com/MariaDB/server.git
synced 2025-01-20 14:02:32 +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.
167 lines
6.6 KiB
C
167 lines
6.6 KiB
C
/* Copyright (c) 2000, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
#ifndef _my_bitmap_h_
|
|
#define _my_bitmap_h_
|
|
|
|
#define MY_BIT_NONE (~(uint) 0)
|
|
|
|
#include <m_string.h>
|
|
|
|
typedef uint32 my_bitmap_map;
|
|
|
|
typedef struct st_bitmap
|
|
{
|
|
my_bitmap_map *bitmap;
|
|
uint n_bits; /* number of bits occupied by the above */
|
|
my_bitmap_map last_word_mask;
|
|
my_bitmap_map *last_word_ptr;
|
|
/*
|
|
mutex will be acquired for the duration of each bitmap operation if
|
|
thread_safe flag in bitmap_init was set. Otherwise, we optimize by not
|
|
acquiring the mutex
|
|
*/
|
|
#ifdef THREAD
|
|
pthread_mutex_t *mutex;
|
|
#endif
|
|
} MY_BITMAP;
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
extern void create_last_word_mask(MY_BITMAP *map);
|
|
extern my_bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint n_bits,
|
|
my_bool thread_safe);
|
|
extern my_bool bitmap_is_clear_all(const MY_BITMAP *map);
|
|
extern my_bool bitmap_is_prefix(const MY_BITMAP *map, uint prefix_size);
|
|
extern my_bool bitmap_is_set_all(const MY_BITMAP *map);
|
|
extern my_bool bitmap_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2);
|
|
extern my_bool bitmap_is_overlapping(const MY_BITMAP *map1,
|
|
const MY_BITMAP *map2);
|
|
extern my_bool bitmap_test_and_set(MY_BITMAP *map, uint bitmap_bit);
|
|
extern my_bool bitmap_test_and_clear(MY_BITMAP *map, uint bitmap_bit);
|
|
extern my_bool bitmap_fast_test_and_set(MY_BITMAP *map, uint bitmap_bit);
|
|
extern uint bitmap_set_next(MY_BITMAP *map);
|
|
extern uint bitmap_get_first(const MY_BITMAP *map);
|
|
extern uint bitmap_get_first_set(const MY_BITMAP *map);
|
|
extern uint bitmap_bits_set(const MY_BITMAP *map);
|
|
extern void bitmap_free(MY_BITMAP *map);
|
|
extern void bitmap_set_above(MY_BITMAP *map, uint from_byte, uint use_bit);
|
|
extern void bitmap_set_prefix(MY_BITMAP *map, uint prefix_size);
|
|
extern void bitmap_intersect(MY_BITMAP *map, const MY_BITMAP *map2);
|
|
extern void bitmap_subtract(MY_BITMAP *map, const MY_BITMAP *map2);
|
|
extern void bitmap_union(MY_BITMAP *map, const MY_BITMAP *map2);
|
|
extern void bitmap_xor(MY_BITMAP *map, const MY_BITMAP *map2);
|
|
extern void bitmap_invert(MY_BITMAP *map);
|
|
extern void bitmap_copy(MY_BITMAP *map, const MY_BITMAP *map2);
|
|
|
|
extern uint bitmap_lock_set_next(MY_BITMAP *map);
|
|
extern void bitmap_lock_clear_bit(MY_BITMAP *map, uint bitmap_bit);
|
|
#ifdef NOT_USED
|
|
extern uint bitmap_lock_bits_set(const MY_BITMAP *map);
|
|
extern my_bool bitmap_lock_is_set_all(const MY_BITMAP *map);
|
|
extern uint bitmap_lock_get_first(const MY_BITMAP *map);
|
|
extern uint bitmap_lock_get_first_set(const MY_BITMAP *map);
|
|
extern my_bool bitmap_lock_is_subset(const MY_BITMAP *map1,
|
|
const MY_BITMAP *map2);
|
|
extern my_bool bitmap_lock_is_prefix(const MY_BITMAP *map, uint prefix_size);
|
|
extern my_bool bitmap_lock_is_set(const MY_BITMAP *map, uint bitmap_bit);
|
|
extern my_bool bitmap_lock_is_clear_all(const MY_BITMAP *map);
|
|
extern my_bool bitmap_lock_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2);
|
|
extern void bitmap_lock_set_all(MY_BITMAP *map);
|
|
extern void bitmap_lock_clear_all(MY_BITMAP *map);
|
|
extern void bitmap_lock_set_bit(MY_BITMAP *map, uint bitmap_bit);
|
|
extern void bitmap_lock_flip_bit(MY_BITMAP *map, uint bitmap_bit);
|
|
extern void bitmap_lock_set_prefix(MY_BITMAP *map, uint prefix_size);
|
|
extern void bitmap_lock_intersect(MY_BITMAP *map, const MY_BITMAP *map2);
|
|
extern void bitmap_lock_subtract(MY_BITMAP *map, const MY_BITMAP *map2);
|
|
extern void bitmap_lock_union(MY_BITMAP *map, const MY_BITMAP *map2);
|
|
extern void bitmap_lock_xor(MY_BITMAP *map, const MY_BITMAP *map2);
|
|
extern void bitmap_lock_invert(MY_BITMAP *map);
|
|
#endif
|
|
/* Fast, not thread safe, bitmap functions */
|
|
#define bitmap_buffer_size(bits) (((bits)+31)/32)*4
|
|
#define no_bytes_in_map(map) (((map)->n_bits + 7)/8)
|
|
#define no_words_in_map(map) (((map)->n_bits + 31)/32)
|
|
#define bytes_word_aligned(bytes) (4*((bytes + 3)/4))
|
|
#define _bitmap_set_bit(MAP, BIT) (((uchar*)(MAP)->bitmap)[(BIT) / 8] \
|
|
|= (1 << ((BIT) & 7)))
|
|
#define _bitmap_flip_bit(MAP, BIT) (((uchar*)(MAP)->bitmap)[(BIT) / 8] \
|
|
^= (1 << ((BIT) & 7)))
|
|
#define _bitmap_clear_bit(MAP, BIT) (((uchar*)(MAP)->bitmap)[(BIT) / 8] \
|
|
&= ~ (1 << ((BIT) & 7)))
|
|
#define _bitmap_is_set(MAP, BIT) (uint) (((uchar*)(MAP)->bitmap)[(BIT) / 8] \
|
|
& (1 << ((BIT) & 7)))
|
|
/*
|
|
WARNING!
|
|
|
|
The below symbols are inline functions in DEBUG builds and macros in
|
|
non-DEBUG builds. The latter evaluate their 'bit' argument twice.
|
|
|
|
NEVER use an increment/decrement operator with the 'bit' argument.
|
|
It would work with DEBUG builds, but fails later in production builds!
|
|
|
|
FORBIDDEN: bitmap_set_bit($my_bitmap, (field++)->field_index);
|
|
*/
|
|
#ifndef DBUG_OFF
|
|
static inline void
|
|
bitmap_set_bit(MY_BITMAP *map,uint bit)
|
|
{
|
|
DBUG_ASSERT(bit < (map)->n_bits);
|
|
_bitmap_set_bit(map,bit);
|
|
}
|
|
static inline void
|
|
bitmap_flip_bit(MY_BITMAP *map,uint bit)
|
|
{
|
|
DBUG_ASSERT(bit < (map)->n_bits);
|
|
_bitmap_flip_bit(map,bit);
|
|
}
|
|
static inline void
|
|
bitmap_clear_bit(MY_BITMAP *map,uint bit)
|
|
{
|
|
DBUG_ASSERT(bit < (map)->n_bits);
|
|
_bitmap_clear_bit(map,bit);
|
|
}
|
|
static inline uint
|
|
bitmap_is_set(const MY_BITMAP *map,uint bit)
|
|
{
|
|
DBUG_ASSERT(bit < (map)->n_bits);
|
|
return _bitmap_is_set(map,bit);
|
|
}
|
|
#else
|
|
#define bitmap_set_bit(MAP, BIT) _bitmap_set_bit(MAP, BIT)
|
|
#define bitmap_flip_bit(MAP, BIT) _bitmap_flip_bit(MAP, BIT)
|
|
#define bitmap_clear_bit(MAP, BIT) _bitmap_clear_bit(MAP, BIT)
|
|
#define bitmap_is_set(MAP, BIT) _bitmap_is_set(MAP, BIT)
|
|
#endif
|
|
|
|
static inline my_bool bitmap_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2)
|
|
{
|
|
if (memcmp(map1->bitmap, map2->bitmap, 4*(no_words_in_map(map1)-1)) != 0)
|
|
return FALSE;
|
|
return ((*map1->last_word_ptr | map1->last_word_mask) ==
|
|
(*map2->last_word_ptr | map2->last_word_mask));
|
|
}
|
|
|
|
#define bitmap_clear_all(MAP) \
|
|
{ memset((MAP)->bitmap, 0, 4*no_words_in_map((MAP))); }
|
|
#define bitmap_set_all(MAP) \
|
|
(memset((MAP)->bitmap, 0xFF, 4*no_words_in_map((MAP))))
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _my_bitmap_h_ */
|