/**
* Get the next item in the iterator's direction, NULL if none.
*/
void *
hash_list_iter_move(hash_list_iter_t *iter)
{
hash_list_iter_check(iter);
g_assert(iter->dir != HASH_LIST_ITER_UNDEFINED);
switch (iter->dir) {
case HASH_LIST_ITER_FORWARDS:
return hash_list_iter_next(iter);
case HASH_LIST_ITER_BACKWARDS:
return hash_list_iter_previous(iter);
case HASH_LIST_ITER_UNDEFINED:
break;
}
g_assert_not_reached();
return FALSE;
}
/**
* Get a new index in the cache, and update LRU data structures.
*
* @param db the database
* @param num page number in the DB for which we want a cache index
*
*
* @return -1 on error, or the allocated cache index.
*/
static int
getidx(DBM *db, long num)
{
struct lru_cache *cache = db->cache;
long n; /* Cache index */
/*
* If we invalidated pages, reuse their indices.
* If we have not used all the pages yet, get the next one.
* Otherwise, use the least-recently requested page.
*/
if (slist_length(cache->available)) {
void *v = slist_shift(cache->available);
n = pointer_to_int(v);
g_assert(n >= 0 && n < cache->pages);
g_assert(!cache->dirty[n]);
g_assert(-1 == cache->numpag[n]);
hash_list_prepend(cache->used, int_to_pointer(n));
} else if (cache->next < cache->pages) {
n = cache->next++;
cache->dirty[n] = FALSE;
hash_list_prepend(cache->used, int_to_pointer(n));
} else {
void *last = hash_list_tail(cache->used);
long oldnum;
gboolean had_ioerr = booleanize(db->flags & DBM_IOERR_W);
hash_list_moveto_head(cache->used, last);
n = pointer_to_int(last);
/*
* This page is no longer cached as its cache index is being reused
* Flush it to disk if dirty before discarding it.
*/
g_assert(n >= 0 && n < cache->pages);
oldnum = cache->numpag[n];
if (cache->dirty[n] && !writebuf(db, oldnum, n)) {
hash_list_iter_t *iter;
void *item;
gboolean found = FALSE;
/*
* Cannot flush dirty page now, probably because we ran out of
* disk space. Look through the cache whether we can reuse a
* non-dirty page instead, which would let us keep the dirty
* page a little longer in the cache, in the hope it can then
* be properly flushed later.
*/
iter = hash_list_iterator_tail(cache->used);
while (NULL != (item = hash_list_iter_previous(iter))) {
long i = pointer_to_int(item);
g_assert(i >= 0 && i < cache->pages);
if (!cache->dirty[i]) {
found = TRUE; /* OK, reuse cache slot #i then */
n = i;
oldnum = cache->numpag[i];
break;
}
}
hash_list_iter_release(&iter);
if (found) {
g_assert(item != NULL);
hash_list_moveto_head(cache->used, item);
/*
* Clear error condition if we had none prior to the flush
* attempt, since we can do without it for now.
*/
if (!had_ioerr)
db->flags &= ~DBM_IOERR_W;
g_warning("sdbm: \"%s\": "
"reusing cache slot used by clean page #%ld instead",
sdbm_name(db), oldnum);
} else {
g_warning("sdbm: \"%s\": cannot discard dirty page #%ld",
sdbm_name(db), oldnum);
return -1;
}
}
g_hash_table_remove(cache->pagnum, ulong_to_pointer(oldnum));
cache->dirty[n] = FALSE;
}
/*
* Record the association between the cache index and the page number.
*/
g_assert(n >= 0 && n < cache->pages);
cache->numpag[n] = num;
g_hash_table_insert(cache->pagnum,
ulong_to_pointer(num), int_to_pointer(n));
return n;
}
