/*
* __sweep --
* Close unused dhandles on the connection dhandle list.
*/
static int
__sweep(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_DATA_HANDLE *dhandle, *dhandle_next;
WT_DECL_RET;
time_t now;
int locked;
conn = S2C(session);
/* Don't discard handles that have been open recently. */
WT_RET(__wt_seconds(session, &now));
WT_STAT_FAST_CONN_INCR(session, dh_conn_sweeps);
dhandle = SLIST_FIRST(&conn->dhlh);
for (; dhandle != NULL; dhandle = dhandle_next) {
dhandle_next = SLIST_NEXT(dhandle, l);
if (WT_IS_METADATA(dhandle))
continue;
if (dhandle->session_inuse != 0 ||
now <= dhandle->timeofdeath + WT_DHANDLE_SWEEP_WAIT)
continue;
if (dhandle->timeofdeath == 0) {
dhandle->timeofdeath = now;
WT_STAT_FAST_CONN_INCR(session, dh_conn_tod);
continue;
}
/*
* We have a candidate for closing; if it's open, acquire an
* exclusive lock on the handle and close it. We might be
* blocking opens for a long time (over disk I/O), but the
* handle was quiescent for awhile.
*
* The close can fail if an update cannot be written (updates
* in a no-longer-referenced file might not yet be globally
* visible if sessions have disjoint sets of files open). If
* the handle is busy, skip it, we'll retry the close the next
* time, after the transaction state has progressed.
*
* We don't set WT_DHANDLE_EXCLUSIVE deliberately, we want
* opens to block on us rather than returning an EBUSY error to
* the application.
*/
if ((ret =
__wt_try_writelock(session, dhandle->rwlock)) == EBUSY)
continue;
WT_RET(ret);
locked = 1;
/* If the handle is open, try to close it. */
if (F_ISSET(dhandle, WT_DHANDLE_OPEN)) {
WT_WITH_DHANDLE(session, dhandle,
ret = __wt_conn_btree_sync_and_close(session, 0));
if (ret != 0)
goto unlock;
/* We closed the btree handle, bump the statistic. */
WT_STAT_FAST_CONN_INCR(session, dh_conn_handles);
}
/*
* If there are no longer any references to the handle in any
* sessions, attempt to discard it. The called function
* re-checks that the handle is not in use, which is why we
* don't do any special handling of EBUSY returns above.
*/
if (dhandle->session_inuse == 0 && dhandle->session_ref == 0) {
WT_WITH_DHANDLE(session, dhandle,
ret = __wt_conn_dhandle_discard_single(session, 0));
if (ret != 0)
goto unlock;
/* If the handle was discarded, it isn't locked. */
locked = 0;
} else
WT_STAT_FAST_CONN_INCR(session, dh_conn_ref);
unlock: if (locked)
WT_TRET(__wt_writeunlock(session, dhandle->rwlock));
WT_RET_BUSY_OK(ret);
}
return (0);
}
/*
* __sweep --
* Close unused dhandles on the connection dhandle list.
*/
static int
__sweep(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_DATA_HANDLE *dhandle, *dhandle_next;
WT_DECL_RET;
time_t now;
conn = S2C(session);
/*
* Session's cache handles unless the session itself is closed, at which
* time the handle reference counts are immediately decremented. Don't
* discard handles that have been open recently.
*/
WT_RET(__wt_seconds(session, &now));
dhandle = SLIST_FIRST(&conn->dhlh);
for (; dhandle != NULL; dhandle = dhandle_next) {
dhandle_next = SLIST_NEXT(dhandle, l);
if (dhandle->session_ref != 0 ||
now - dhandle->timeofdeath <= WT_DHANDLE_SWEEP_WAIT)
continue;
/*
* We have a candidate for closing; if it's open, acquire an
* exclusive lock on the handle and close it (the lock blocks
* threads from opening the handle). We might be blocking an
* open for a fairly long time (over disk I/O), but the handle
* has been quiescent for awhile.
*
* The close can fail if an update cannot be written (updates in
* a no-longer-referenced file might not yet be globally visible
* if sessions have disjoint sets of files open). If the handle
* is busy, skip it, we'll retry the close the next time, after
* the transaction state has progressed.
*/
if (F_ISSET(dhandle, WT_DHANDLE_OPEN)) {
/*
* We don't set WT_DHANDLE_EXCLUSIVE deliberately, we
* want opens to block on us rather than returning an
* EBUSY error to the application.
*/
ret = __wt_try_writelock(session, dhandle->rwlock);
if (ret == EBUSY) {
ret = 0;
continue;
}
WT_RET(ret);
WT_WITH_DHANDLE(session, dhandle,
ret = __wt_conn_btree_sync_and_close(session));
if (ret == EBUSY)
ret = 0;
WT_TRET(__wt_rwunlock(session, dhandle->rwlock));
WT_RET(ret);
}
/*
* Attempt to discard the handle (the called function checks the
* handle-open flag after acquiring appropriate locks, which is
* why we don't do any special handling of EBUSY returns above,
* that path never cleared the handle-open flag.
*/
ret = __wt_conn_dhandle_discard_single(session, dhandle, 0);
if (ret == EBUSY)
ret = 0;
WT_RET(ret);
}
return (0);
}
/*
* __conn_btree_open --
* Open the current btree handle.
*/
static int
__conn_btree_open(
WT_SESSION_IMPL *session, const char *cfg[], uint32_t flags)
{
WT_BTREE *btree;
WT_DATA_HANDLE *dhandle;
WT_DECL_RET;
dhandle = session->dhandle;
btree = S2BT(session);
WT_ASSERT(session, F_ISSET(session, WT_SESSION_SCHEMA_LOCKED) &&
F_ISSET(dhandle, WT_DHANDLE_EXCLUSIVE) &&
!LF_ISSET(WT_DHANDLE_LOCK_ONLY));
/*
* If the handle is already open, it has to be closed so it can be
* reopened with a new configuration. We don't need to check again:
* this function isn't called if the handle is already open in the
* required mode.
*
* This call can return EBUSY if there's an update in the object that's
* not yet globally visible. That's not a problem because it can only
* happen when we're switching from a normal handle to a "special" one,
* so we're returning EBUSY to an attempt to verify or do other special
* operations. The reverse won't happen because when the handle from a
* verify or other special operation is closed, there won't be updates
* in the tree that can block the close.
*/
if (F_ISSET(dhandle, WT_DHANDLE_OPEN))
WT_RET(__wt_conn_btree_sync_and_close(session, 0));
/* Discard any previous configuration, set up the new configuration. */
__conn_btree_config_clear(session);
WT_RET(__conn_btree_config_set(session));
/* Set any special flags on the handle. */
F_SET(btree, LF_ISSET(WT_BTREE_SPECIAL_FLAGS));
do {
WT_ERR(__wt_btree_open(session, cfg));
F_SET(dhandle, WT_DHANDLE_OPEN);
/*
* Checkpoint handles are read only, so eviction calculations
* based on the number of btrees are better to ignore them.
*/
if (dhandle->checkpoint == NULL)
++S2C(session)->open_btree_count;
/* Drop back to a readlock if that is all that was needed. */
if (!LF_ISSET(WT_DHANDLE_EXCLUSIVE)) {
F_CLR(dhandle, WT_DHANDLE_EXCLUSIVE);
WT_ERR(__wt_writeunlock(session, dhandle->rwlock));
WT_ERR(
__conn_dhandle_open_lock(session, dhandle, flags));
}
} while (!F_ISSET(dhandle, WT_DHANDLE_OPEN));
if (0) {
err: F_CLR(btree, WT_BTREE_SPECIAL_FLAGS);
/* If the open failed, close the handle. */
if (F_ISSET(dhandle, WT_DHANDLE_OPEN))
WT_TRET(__wt_conn_btree_sync_and_close(session, 0));
}
return (ret);
}
