/*
* __wt_lsm_free_chunks --
* Try to drop chunks from the tree that are no longer required.
*/
int
__wt_lsm_free_chunks(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree)
{
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_WORKER_COOKIE cookie;
u_int i, skipped;
int drop_ret;
bool flush_metadata;
flush_metadata = false;
if (lsm_tree->nold_chunks == 0)
return (0);
/*
* Make sure only a single thread is freeing the old chunk array
* at any time.
*/
if (!__wt_atomic_cas32(&lsm_tree->freeing_old_chunks, 0, 1))
return (0);
/*
* Take a copy of the current state of the LSM tree and look for chunks
* to drop. We do it this way to avoid holding the LSM tree lock while
* doing I/O or waiting on the schema lock.
*
* This is safe because only one thread will be in this function at a
* time. Merges may complete concurrently, and the old_chunks array
* may be extended, but we shuffle down the pointers each time we free
* one to keep the non-NULL slots at the beginning of the array.
*/
WT_CLEAR(cookie);
WT_RET(__lsm_copy_chunks(session, lsm_tree, &cookie, true));
for (i = skipped = 0; i < cookie.nchunks; i++) {
chunk = cookie.chunk_array[i];
WT_ASSERT(session, chunk != NULL);
/* Skip the chunk if another worker is using it. */
if (chunk->refcnt > 1) {
++skipped;
continue;
}
/*
* Don't remove files if a hot backup is in progress.
*
* The schema lock protects the set of live files, this check
* prevents us from removing a file that hot backup already
* knows about.
*/
if (S2C(session)->hot_backup)
break;
/*
* Drop any bloom filters and chunks we can. Don't try to drop
* a chunk if the bloom filter drop fails.
* An EBUSY return indicates that a cursor is still open in
* the tree - move to the next chunk in that case.
* An ENOENT return indicates that the LSM tree metadata was
* out of sync with the on disk state. Update the
* metadata to match in that case.
*/
if (F_ISSET(chunk, WT_LSM_CHUNK_BLOOM)) {
drop_ret = __lsm_drop_file(session, chunk->bloom_uri);
if (drop_ret == EBUSY) {
++skipped;
continue;
} else if (drop_ret != ENOENT)
WT_ERR(drop_ret);
flush_metadata = true;
F_CLR(chunk, WT_LSM_CHUNK_BLOOM);
}
if (chunk->uri != NULL) {
drop_ret = __lsm_drop_file(session, chunk->uri);
if (drop_ret == EBUSY) {
++skipped;
continue;
} else if (drop_ret != ENOENT)
WT_ERR(drop_ret);
flush_metadata = true;
}
/* Lock the tree to clear out the old chunk information. */
WT_ERR(__wt_lsm_tree_writelock(session, lsm_tree));
/*
* The chunk we are looking at should be the first one in the
* tree that we haven't already skipped over.
*/
WT_ASSERT(session, lsm_tree->old_chunks[skipped] == chunk);
__wt_free(session, chunk->bloom_uri);
__wt_free(session, chunk->uri);
__wt_free(session, lsm_tree->old_chunks[skipped]);
/* Shuffle down to keep all occupied slots at the beginning. */
if (--lsm_tree->nold_chunks > skipped) {
memmove(lsm_tree->old_chunks + skipped,
lsm_tree->old_chunks + skipped + 1,
(lsm_tree->nold_chunks - skipped) *
sizeof(WT_LSM_CHUNK *));
lsm_tree->old_chunks[lsm_tree->nold_chunks] = NULL;
}
WT_ERR(__wt_lsm_tree_writeunlock(session, lsm_tree));
/*
* Clear the chunk in the cookie so we don't attempt to
* decrement the reference count.
*/
cookie.chunk_array[i] = NULL;
}
err: /* Flush the metadata unless the system is in panic */
if (flush_metadata && ret != WT_PANIC) {
WT_TRET(__wt_lsm_tree_writelock(session, lsm_tree));
WT_TRET(__wt_lsm_meta_write(session, lsm_tree));
WT_TRET(__wt_lsm_tree_writeunlock(session, lsm_tree));
}
__lsm_unpin_chunks(session, &cookie);
__wt_free(session, cookie.chunk_array);
lsm_tree->freeing_old_chunks = 0;
/* Returning non-zero means there is no work to do. */
if (!flush_metadata)
WT_TRET(WT_NOTFOUND);
return (ret);
}
/*
* __lsm_free_chunks --
* Try to drop chunks from the tree that are no longer required.
*/
static int
__lsm_free_chunks(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree)
{
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_WORKER_COOKIE cookie;
u_int i, skipped;
int progress;
/*
* Take a copy of the current state of the LSM tree and look for chunks
* to drop. We do it this way to avoid holding the LSM tree lock while
* doing I/O or waiting on the schema lock.
*
* This is safe because only one thread will be in this function at a
* time (the first merge thread). Merges may complete concurrently,
* and the old_chunks array may be extended, but we shuffle down the
* pointers each time we free one to keep the non-NULL slots at the
* beginning of the array.
*/
WT_CLEAR(cookie);
WT_RET(__lsm_copy_chunks(session, lsm_tree, &cookie, 1));
for (i = skipped = 0, progress = 0; i < cookie.nchunks; i++) {
chunk = cookie.chunk_array[i];
WT_ASSERT(session, chunk != NULL);
/* Skip the chunk if another worker is using it. */
if (chunk->refcnt > 1) {
++skipped;
continue;
}
if (F_ISSET_ATOMIC(chunk, WT_LSM_CHUNK_BLOOM)) {
/*
* An EBUSY return is acceptable - a cursor may still
* be positioned on this old chunk.
*/
if ((ret = __lsm_drop_file(
session, chunk->bloom_uri)) == EBUSY) {
WT_VERBOSE_ERR(session, lsm,
"LSM worker bloom drop busy: %s.",
chunk->bloom_uri);
++skipped;
continue;
} else
WT_ERR(ret);
F_CLR_ATOMIC(chunk, WT_LSM_CHUNK_BLOOM);
}
if (chunk->uri != NULL) {
/*
* An EBUSY return is acceptable - a cursor may still
* be positioned on this old chunk.
*/
if ((ret = __lsm_drop_file(
session, chunk->uri)) == EBUSY) {
WT_VERBOSE_ERR(session, lsm,
"LSM worker drop busy: %s.",
chunk->uri);
++skipped;
continue;
} else
WT_ERR(ret);
}
progress = 1;
/* Lock the tree to clear out the old chunk information. */
WT_ERR(__wt_lsm_tree_lock(session, lsm_tree, 1));
/*
* The chunk we are looking at should be the first one in the
* tree that we haven't already skipped over.
*/
WT_ASSERT(session, lsm_tree->old_chunks[skipped] == chunk);
__wt_free(session, chunk->bloom_uri);
__wt_free(session, chunk->uri);
__wt_free(session, lsm_tree->old_chunks[skipped]);
/* Shuffle down to keep all occupied slots at the beginning. */
if (--lsm_tree->nold_chunks > skipped) {
memmove(lsm_tree->old_chunks + skipped,
lsm_tree->old_chunks + skipped + 1,
(lsm_tree->nold_chunks - skipped) *
sizeof(WT_LSM_CHUNK *));
lsm_tree->old_chunks[lsm_tree->nold_chunks] = NULL;
}
/*
* Clear the chunk in the cookie so we don't attempt to
* decrement the reference count.
*/
cookie.chunk_array[i] = NULL;
/*
* Update the metadata. We used to try to optimize by only
* updating the metadata once at the end, but the error
* handling is not straightforward.
*/
WT_TRET(__wt_lsm_meta_write(session, lsm_tree));
WT_ERR(__wt_lsm_tree_unlock(session, lsm_tree));
}
err: __lsm_unpin_chunks(session, &cookie);
__wt_free(session, cookie.chunk_array);
/* Returning non-zero means there is no work to do. */
if (!progress)
WT_TRET(WT_NOTFOUND);
return (ret);
}
