END_TEST
START_TEST(double_close_bitmap_file)
{
bloom_bitmap map;
int res = bitmap_from_filename("/tmp/mmap_close_bitmap", 8196, 1, 1, SHARED, &map);
fail_unless(res == 0);
fail_unless(bitmap_close(&map) == 0);
fail_unless(map.mmap == NULL);
unlink("/tmp/mmap_close_bitmap");
fail_unless(bitmap_close(&map) < 0);
}
END_TEST
START_TEST(double_close_bitmap_file_persist)
{
bloom_bitmap map;
int res = bitmap_from_filename("/tmp/mmap_close_bitmap_persist",
8196, 1, 1, PERSISTENT, &map);
fail_unless(res == 0);
fail_unless(bitmap_close(&map) == 0);
fail_unless(map.mmap == NULL);
unlink("/tmp/mmap_close_bitmap_persist");
fail_unless(bitmap_close(&map) < 0);
}
void map_textures_close_texture(map_type *map,int txt_idx)
{
int n;
texture_type *texture;
texture_frame_type *frame;
texture=&map->textures[txt_idx];
frame=texture->frames;
for (n=0;n!=max_texture_frame;n++) {
bitmap_close(&frame->bitmap);
bitmap_close(&frame->bumpmap);
bitmap_close(&frame->specularmap);
bitmap_close(&frame->glowmap);
frame++;
}
}
void walk_view_shutdown(void)
{
// interface textures
bitmap_close(&spot_bitmap);
bitmap_close(&scenery_bitmap);
bitmap_close(&node_bitmap);
bitmap_close(&node_defined_bitmap);
bitmap_close(&light_bitmap);
bitmap_close(&sound_bitmap);
bitmap_close(&particle_bitmap);
}
END_TEST
/*
* int bitmap_close(bloom_bitmap *map) {
*/
START_TEST(close_bitmap_anonymous)
{
bloom_bitmap map;
int res = bitmap_from_file(-1, 4096, ANONYMOUS, &map);
fail_unless(res == 0);
fail_unless(bitmap_close(&map) == 0);
fail_unless(map.mmap == NULL);
}
/**
* Destroys an hll. Closes the bitmap, but does not free it.
* @return 0 on success
*/
int hll_destroy(hll_t *h) {
// Close the bitmap
if (h->bm) {
bitmap_close(h->bm);
h->bm = NULL;
h->registers = NULL;
// Destroy the registers if we allocated them
} else if (h->registers) {
free(h->registers);
h->registers = NULL;
}
return 0;
}
void view_images_free(void)
{
int n;
view_image_type *image;
// close the images
image=view.images;
for (n=0;n!=view.count.image;n++) {
image->path[0]=0x0;
bitmap_close(&image->bitmap);
image++;
}
}
void view_shutdown(void)
{
// soring lists
free(view_poly_trans_sort.polys);
free(view_mesh_sort.meshes);
// interface textures
bitmap_close(&spot_bitmap);
bitmap_close(&scenery_bitmap);
bitmap_close(&node_bitmap);
bitmap_close(&node_defined_bitmap);
bitmap_close(&light_bitmap);
bitmap_close(&sound_bitmap);
bitmap_close(&particle_bitmap);
}
END_TEST
START_TEST(close_does_flush) {
bloom_bitmap map;
int res = bitmap_from_filename("/tmp/mmap_close_flush", 4096, 1, 1, SHARED, &map);
fchmod(map.fileno, 0777);
fail_unless(res == 0);
for (int idx = 0; idx < 4096*8 ; idx++) {
bitmap_setbit((&map), idx);
}
bitmap_close(&map);
res = bitmap_from_filename("/tmp/mmap_close_flush", 4096, 0, 0, SHARED, &map);
fail_unless(res == 0);
for (int idx = 0; idx < 4096; idx++) {
fail_unless(map.mmap[idx] == 255);
}
unlink("/tmp/mmap_close_flush");
}
/**
* Flushes and closes the filter. Closes the underlying bitmap,
* but does not free it.
* @return 0 on success, negative on failure.
*/
int bf_close(bloom_bloomfilter *filter) {
// Make sure we have a filter
if (filter == NULL or filter->map == NULL) {
return -1;
}
// Flush first
bf_flush(filter);
// Clean up the map
bitmap_close(filter->map);
filter->map = NULL;
// Clear all the fields
filter->header = NULL;
filter->offset = 0;
filter->bitmap_size = 0;
return 0;
}
void gl_texture_shutdown(void)
{
bitmap_close(&null_bitmap);
}
END_TEST
START_TEST(close_bitmap_null)
{
fail_unless(bitmap_close(NULL) == -EINVAL);
}
/**
* This beast mode method scans the data directory
* belonging to this filter for any existing filters,
* and restores the SBF
* @return 0 on success. -1 on error.
*/
static int discover_existing_filters(bloom_filter *f) {
// Scan through the folder looking for data files
struct dirent **namelist;
int num;
// Filter only data dirs, in sorted order
num = scandir(f->full_path, &namelist, filter_data_files, alphasort);
if (num == -1) {
syslog(LOG_ERR, "Failed to scan files for filter '%s'. %s",
f->filter_name, strerror(errno));
return -1;
}
syslog(LOG_INFO, "Found %d files for filter %s.", num, f->filter_name);
// Speical case when there are no filters
if (num == 0) {
int res = create_sbf(f, 0, NULL);
return res;
}
// Allocate space for all the filter
bloom_bitmap **maps = malloc(num * sizeof(bloom_bitmap*));
bloom_bloomfilter **filters = malloc(num * sizeof(bloom_bloomfilter*));
// Initialize the bitmaps and bloom filters
int res;
int err = 0;
uint64_t size;
bitmap_mode mode = (f->config->use_mmap) ? SHARED : PERSISTENT;
for (int i=0; i < num && !err; i++) {
// Get the full path to the bitmap
char *bitmap_path = join_path(f->full_path, namelist[i]->d_name);
syslog(LOG_INFO, "Discovered bloom filter: %s.", bitmap_path);
// Get the size
size = get_size(bitmap_path);
if (size == 0) {
err = 1;
syslog(LOG_ERR, "Failed to get the filesize for: %s. %s", bitmap_path, strerror(errno));
free(bitmap_path);
break;
}
// Create the bitmap
bloom_bitmap *bitmap = maps[num - i - 1] = malloc(sizeof(bloom_bitmap));
res = bitmap_from_filename(bitmap_path, size, 0, mode, bitmap);
if (res != 0) {
err = 1;
syslog(LOG_ERR, "Failed to load bitmap for: %s. %s", bitmap_path, strerror(errno));
free(bitmap);
free(bitmap_path);
break;
}
// Create the bloom filter
bloom_bloomfilter *filter = filters[num - i - 1] = malloc(sizeof(bloom_bloomfilter));
res = bf_from_bitmap(bitmap, 1, 0, filter);
if (res != 0) {
err = 1;
syslog(LOG_ERR, "Failed to load bloom filter for: %s. [%d]", bitmap_path, res);
free(filter);
bitmap_close(bitmap);
free(bitmap);
free(bitmap_path);
break;
}
// Cleanup
free(bitmap_path);
}
// Free the memory associated with scandir
for (int i=0; i < num; i++) free(namelist[i]);
free(namelist);
// Return if there was an error
if (err) return -1;
// Create the SBF
res = create_sbf(f, num, filters);
// Cleanup on err
if (res != 0) {
syslog(LOG_ERR, "Failed to make scalable bloom filter for: %s.", f->filter_name);
// For f***s sake. We need to clean up so much shit now.
for (int i=0; i < num; i++) {
bf_close(filters[i]);
bitmap_close(maps[i]);
free(filters[i]);
free(maps[i]);
}
}
// Increase our page ins
f->counters.page_ins += 1;
// Remove the filters list
free(maps);
free(filters);
return (err) ? -1 : 0;
}
void cursor_shutdown(void)
{
bitmap_close(&cursor_bitmap);
}
