/* Note: this isn't an assoc_update. The key must not already exist to call this */
int assoc_insert(struct default_engine *engine, uint32_t hash, hash_item *it)
{
unsigned int oldbucket;
assert(assoc_find(engine, hash, item_get_key(it), it->nkey) == 0); /* shouldn't have duplicately named things defined */
// inserting actual hash_item to appropriate assoc_t
if (engine->assoc.expanding &&
(oldbucket = (hash & hashmask(engine->assoc.hashpower - 1))) >= engine->assoc.expand_bucket)
{
it->h_next = engine->assoc.old_hashtable[oldbucket];
engine->assoc.old_hashtable[oldbucket] = it;
} else {
it->h_next = engine->assoc.primary_hashtable[hash & hashmask(engine->assoc.hashpower)];
engine->assoc.primary_hashtable[hash & hashmask(engine->assoc.hashpower)] = it;
}
engine->assoc.hash_items++;
if (! engine->assoc.expanding && engine->assoc.hash_items > (hashsize(engine->assoc.hashpower) * 3) / 2) {
assoc_expand(engine);
}
MEMCACHED_ASSOC_INSERT(item_get_key(it), it->nkey, engine->assoc.hash_items);
return 1;
}
/* Note: this isn't an assoc_update. The key must not already exist to call this */
int assoc_insert(struct default_engine *engine, uint32_t hash, hash_item *it)
{
struct assoc *assoc = &engine->assoc;
uint32_t bucket = GET_HASH_BUCKET(hash, assoc->hashmask);
uint32_t tabidx;
assert(assoc_find(engine, hash, item_get_key(it), it->nkey) == 0); /* shouldn't have duplicately named things defined */
if (assoc->infotable[bucket].curpower != assoc->rootpower &&
assoc->infotable[bucket].refcount == 0) {
redistribute(engine, bucket);
}
tabidx = GET_HASH_TABIDX(hash, assoc->hashpower,
hashmask(assoc->infotable[bucket].curpower));
// inserting actual hash_item to appropriate assoc_t
it->h_next = assoc->roottable[tabidx].hashtable[bucket];
assoc->roottable[tabidx].hashtable[bucket] = it;
assoc->hash_items++;
if (assoc->hash_items > (hashsize(assoc->hashpower + assoc->rootpower) * 3) / 2) {
assoc_expand(engine);
}
MEMCACHED_ASSOC_INSERT(item_get_key(it), it->nkey, assoc->hash_items);
return 1;
}
/** wrapper around assoc_find which does the lazy expiration logic */
hash_item *do_item_get(struct default_engine *engine,
const hash_key *key) {
rel_time_t current_time = engine->server.core->get_current_time();
hash_item *it = assoc_find(engine,
crc32c(hash_key_get_key(key),
hash_key_get_key_len(key), 0),
key);
int was_found = 0;
if (engine->config.verbose > 2) {
EXTENSION_LOGGER_DESCRIPTOR *logger;
logger = (void*)engine->server.extension->get_extension(EXTENSION_LOGGER);
if (it == NULL) {
logger->log(EXTENSION_LOG_DEBUG, NULL,
"> NOT FOUND in bucket %d, %s",
hash_key_get_bucket_index(key),
hash_key_get_client_key(key));
} else {
logger->log(EXTENSION_LOG_DEBUG, NULL,
"> FOUND KEY in bucket %d, %s",
hash_key_get_bucket_index(item_get_key(it)),
hash_key_get_client_key(item_get_key(it)));
was_found++;
}
}
if (it != NULL && engine->config.oldest_live != 0 &&
engine->config.oldest_live <= current_time &&
it->time <= engine->config.oldest_live) {
do_item_unlink(engine, it); /* MTSAFE - items.lock held */
it = NULL;
}
if (it == NULL && was_found) {
EXTENSION_LOGGER_DESCRIPTOR *logger;
logger = (void*)engine->server.extension->get_extension(EXTENSION_LOGGER);
logger->log(EXTENSION_LOG_DEBUG, NULL, " -nuked by flush");
was_found--;
}
if (it != NULL && it->exptime != 0 && it->exptime <= current_time) {
do_item_unlink(engine, it); /* MTSAFE - items.lock held */
it = NULL;
}
if (it == NULL && was_found) {
EXTENSION_LOGGER_DESCRIPTOR *logger;
logger = (void*)engine->server.extension->get_extension(EXTENSION_LOGGER);
logger->log(EXTENSION_LOG_DEBUG, NULL, " -nuked by expire");
was_found--;
}
if (it != NULL) {
it->refcount++;
DEBUG_REFCNT(it, '+');
do_item_update(engine, it);
}
return it;
}
bool assoc_prefix_isvalid(struct default_engine *engine, hash_item *it)
{
rel_time_t current_time = engine->server.core->get_current_time();
prefix_t *pt;
if (it->nprefix == it->nkey) {
/* the prefix of key: null */
assert(root_pt != NULL);
pt = root_pt;
if (pt->oldest_live != 0 && pt->oldest_live <= current_time && it->time <= pt->oldest_live) {
return false;
}
} else {
/* the prifix of key: given */
pt = assoc_prefix_find(engine, engine->server.core->hash(item_get_key(it), it->nprefix, 0),
item_get_key(it), it->nprefix);
while (pt != NULL && pt != root_pt) {
// validation check between prefix and hash_item
if (pt->oldest_live != 0 && pt->oldest_live <= current_time && it->time <= pt->oldest_live) {
return false;
}
// traversal parent prefixes to validate
pt = pt->parent_prefix;
}
}
return true;
}
int do_item_replace(struct default_engine *engine,
hash_item *it, hash_item *new_it) {
MEMCACHED_ITEM_REPLACE(item_get_key(it), it->nkey, it->nbytes,
item_get_key(new_it), new_it->nkey, new_it->nbytes);
assert((it->iflag & ITEM_SLABBED) == 0);
do_item_unlink(engine, it);
return do_item_link(engine, new_it);
}
void assoc_prefix_unlink(struct default_engine *engine, hash_item *it,
const size_t item_size, bool drop_if_empty)
{
prefix_t *pt;
assert(it->nprefix != 0);
if (it->nprefix == it->nkey) {
pt = root_pt;
} else {
pt = assoc_prefix_find(engine, engine->server.core->hash(item_get_key(it), it->nprefix, 0),
item_get_key(it), it->nprefix);
}
assert(pt != NULL);
// update prefix information
if ((it->iflag & ITEM_IFLAG_LIST) != 0) {
pt->list_hash_items--;
pt->list_hash_items_bytes -= item_size;
} else if ((it->iflag & ITEM_IFLAG_SET) != 0) {
pt->set_hash_items--;
pt->set_hash_items_bytes -= item_size;
} else if ((it->iflag & ITEM_IFLAG_BTREE) != 0) {
pt->btree_hash_items--;
pt->btree_hash_items_bytes -= item_size;
} else {
pt->hash_items--;
pt->hash_items_bytes -= item_size;
}
#if 0 // might be used later
if (1) {
prefix_t *curr_pt = pt->parent_prefix;
while (curr_pt != NULL) {
curr_pt->tot_hash_items--;
curr_pt->tot_hash_items_bytes -= item_size;
curr_pt = curr_pt->parent_prefix;
}
}
#endif
if (drop_if_empty) {
while (pt != NULL) {
prefix_t *parent_pt = pt->parent_prefix;
if (pt != root_pt && pt->prefix_items == 0 && pt->hash_items == 0 &&
pt->list_hash_items == 0 && pt->set_hash_items == 0 && pt->btree_hash_items == 0) {
assert(pt->hash_items_bytes == 0 && pt->list_hash_items_bytes == 0 &&
pt->set_hash_items_bytes == 0 && pt->btree_hash_items_bytes == 0);
_prefix_delete(engine, engine->server.core->hash(_get_prefix(pt), pt->nprefix, 0),
_get_prefix(pt), pt->nprefix);
} else {
break;
}
pt = parent_pt;
}
}
}
void do_item_release(struct default_engine *engine, hash_item *it) {
MEMCACHED_ITEM_REMOVE(hash_key_get_client_key(item_get_key(it)),
hash_key_get_client_key_len(item_get_key(it)),
it->nbytes);
if (it->refcount != 0) {
it->refcount--;
DEBUG_REFCNT(it, '-');
}
if (it->refcount == 0 && (it->iflag & ITEM_LINKED) == 0) {
item_free(engine, it);
}
}
void do_item_update(struct default_engine *engine, hash_item *it) {
rel_time_t current_time = engine->server.core->get_current_time();
MEMCACHED_ITEM_UPDATE(hash_key_get_client_key(item_get_key(it)),
hash_key_get_client_key_len(item_get_key(it)),
it->nbytes);
if (it->time < current_time - ITEM_UPDATE_INTERVAL) {
cb_assert((it->iflag & ITEM_SLABBED) == 0);
if ((it->iflag & ITEM_LINKED) != 0) {
item_unlink_q(engine, it);
it->time = current_time;
item_link_q(engine, it);
}
}
}
/*
* adds a delta value to a numeric item.
*
* c connection requesting the operation
* it item to adjust
* incr true to increment value, false to decrement
* delta amount to adjust value by
* @param ritem The resulting item after adding the delta. Only valid if
* ENGINE_SUCCESS is returned. Caller is responsible for calling
* do_item_release() on this when finished with it.
*
* returns a response code to send back to the client.
*/
static ENGINE_ERROR_CODE do_add_delta(struct default_engine *engine,
hash_item *it, const bool incr,
const int64_t delta, item** ritem,
uint64_t *result, const void *cookie) {
const char *ptr;
uint64_t value;
char buf[80];
int res;
if (it->nbytes >= (sizeof(buf) - 1)) {
return ENGINE_EINVAL;
}
ptr = item_get_data(it);
memcpy(buf, ptr, it->nbytes);
buf[it->nbytes] = '\0';
if (!safe_strtoull(buf, &value)) {
return ENGINE_EINVAL;
}
if (incr) {
value += delta;
} else {
if ((uint64_t)delta > value) {
value = 0;
} else {
value -= delta;
}
}
*result = value;
res = snprintf(buf, sizeof(buf), "%" PRIu64, value);
if (res < 0 || res >= sizeof(buf)) {
return ENGINE_EINVAL;
}
if (it->refcount == 1 && res <= (int)it->nbytes) {
/* we can do inline replacement */
memcpy(item_get_data(it), buf, res);
memset(item_get_data(it) + res, ' ', it->nbytes - res);
item_set_cas(NULL, NULL, it, get_cas_id());
*ritem = it;
} else {
hash_item *new_it = do_item_alloc(engine, item_get_key(it),
it->flags,
it->exptime, res,
cookie, it->datatype);
if (new_it == NULL) {
do_item_unlink(engine, it);
return ENGINE_ENOMEM;
}
memcpy(item_get_data(new_it), buf, res);
do_item_replace(engine, it, new_it);
*ritem = new_it;
}
return ENGINE_SUCCESS;
}
static ENGINE_ERROR_CODE mock_item_allocate(ENGINE_HANDLE* handle,
const void* cookie,
item **it,
const void* key,
const size_t nkey,
const size_t nbytes,
const int flags,
const rel_time_t exptime) {
// Only perform allocations if there's a hashtable.
if (get_ht(handle) != NULL) {
size_t to_alloc = sizeof(item) + nkey + nbytes;
*it = calloc(to_alloc, 1);
} else {
*it = NULL;
}
// If an allocation was requested *and* worked, fill and report success
if (*it) {
item *i = *it;
i->exptime = exptime;
i->nbytes = nbytes;
i->flags = flags;
i->nkey = nkey;
memcpy((char*)item_get_key(i), key, nkey);
return ENGINE_SUCCESS;
} else {
return ENGINE_ENOMEM;
}
}
hash_item *assoc_find(struct default_engine *engine, uint32_t hash, const char *key, const size_t nkey)
{
hash_item *it;
unsigned int oldbucket;
if (engine->assoc.expanding &&
(oldbucket = (hash & hashmask(engine->assoc.hashpower - 1))) >= engine->assoc.expand_bucket)
{
it = engine->assoc.old_hashtable[oldbucket];
} else {
it = engine->assoc.primary_hashtable[hash & hashmask(engine->assoc.hashpower)];
}
hash_item *ret = NULL;
int depth = 0;
while (it) {
if ((nkey == it->nkey) && (memcmp(key, item_get_key(it), nkey) == 0)) {
ret = it;
break;
}
it = it->h_next;
++depth;
}
MEMCACHED_ASSOC_FIND(key, nkey, depth);
return ret;
}
void do_item_unlink(struct default_engine *engine, hash_item *it) {
MEMCACHED_ITEM_UNLINK(item_get_key(it), it->nkey, it->nbytes);
if ((it->iflag & ITEM_LINKED) != 0) {
it->iflag &= ~ITEM_LINKED;
pthread_mutex_lock(&engine->stats.lock);
engine->stats.curr_bytes -= ITEM_ntotal(engine, it);
engine->stats.curr_items -= 1;
pthread_mutex_unlock(&engine->stats.lock);
assoc_delete(engine, engine->server.core->hash(item_get_key(it),
it->nkey, 0),
item_get_key(it), it->nkey);
item_unlink_q(engine, it);
if (it->refcount == 0) {
item_free(engine, it);
}
}
}
static ENGINE_ERROR_CODE mock_store(ENGINE_HANDLE* handle,
const void *cookie,
item* item,
uint64_t *cas,
ENGINE_STORE_OPERATION operation) {
genhash_update(get_ht(handle), item_get_key(item), item->nkey, item, 0);
return ENGINE_SUCCESS;
}
static void *assoc_maintenance_thread(void *arg)
{
struct default_engine *engine = arg;
bool done = false;
struct timespec sleep_time = {0, 1000};
int i,try_cnt = 9;
long tot_execs = 0;
EXTENSION_LOGGER_DESCRIPTOR *logger = engine->server.log->get_logger();
if (engine->config.verbose) {
logger->log(EXTENSION_LOG_INFO, NULL, "Hash table expansion start: %d => %d\n",
hashsize(engine->assoc.hashpower - 1), hashsize(engine->assoc.hashpower));
}
do {
int ii;
/* long-running background task.
* hold the cache lock lazily in order to give priority to normal workers.
*/
for (i = 0; i < try_cnt; i++) {
if (pthread_mutex_trylock(&engine->cache_lock) == 0) break;
nanosleep(&sleep_time, NULL);
}
if (i == try_cnt) pthread_mutex_lock(&engine->cache_lock);
for (ii = 0; ii < hash_bulk_move && engine->assoc.expanding; ++ii) {
hash_item *it, *next;
int bucket;
for (it = engine->assoc.old_hashtable[engine->assoc.expand_bucket];
NULL != it; it = next) {
next = it->h_next;
bucket = engine->server.core->hash(item_get_key(it), it->nkey, 0)
& hashmask(engine->assoc.hashpower);
it->h_next = engine->assoc.primary_hashtable[bucket];
engine->assoc.primary_hashtable[bucket] = it;
}
engine->assoc.old_hashtable[engine->assoc.expand_bucket] = NULL;
engine->assoc.expand_bucket++;
if (engine->assoc.expand_bucket == hashsize(engine->assoc.hashpower - 1)) {
engine->assoc.expanding = false;
free(engine->assoc.old_hashtable);
}
}
if (!engine->assoc.expanding) {
done = true;
}
pthread_mutex_unlock(&engine->cache_lock);
if ((++tot_execs % 100) == 0) {
nanosleep(&sleep_time, NULL);
}
} while (!done);
if (engine->config.verbose) {
logger->log(EXTENSION_LOG_INFO, NULL, "Hash table expansion done\n");
}
return NULL;
}
/* warning: don't use these macros with a function, as it evals its arg twice */
static size_t ITEM_ntotal(struct default_engine *engine,
const hash_item *item) {
size_t ret = sizeof(*item) + hash_key_get_alloc_size(item_get_key(item)) + item->nbytes;
if (engine->config.use_cas) {
ret += sizeof(uint64_t);
}
return ret;
}
static ENGINE_ERROR_CODE do_item_dcp_step(struct default_engine *engine,
struct dcp_connection *connection,
const void *cookie,
struct dcp_message_producers *producers)
{
ENGINE_ERROR_CODE ret = ENGINE_DISCONNECT;
while (connection->it == NULL) {
if (!do_item_walk_cursor(engine, &connection->cursor, 1,
item_dcp_iterfunc, connection, &ret)) {
/* find next slab class to look at.. */
bool linked = false;
int ii;
for (ii = connection->cursor.slabs_clsid + 1; ii < POWER_LARGEST && !linked; ++ii) {
if (engine->items.heads[ii] != NULL) {
/* add the item at the tail */
do_item_link_cursor(engine, &connection->cursor, ii);
linked = true;
}
}
if (!linked) {
break;
}
}
}
if (connection->it != NULL) {
rel_time_t current_time = engine->server.core->get_current_time();
rel_time_t exptime = connection->it->exptime;
if (exptime != 0 && exptime < current_time) {
const hash_key* key = item_get_key(connection->it);
ret = producers->expiration(cookie, connection->opaque,
hash_key_get_client_key(key),
hash_key_get_client_key_len(key),
item_get_cas(connection->it),
0, 0, 0, NULL, 0);
if (ret == ENGINE_SUCCESS) {
do_item_unlink(engine, connection->it);
do_item_release(engine, connection->it);
}
} else {
ret = producers->mutation(cookie, connection->opaque,
connection->it, 0, 0, 0, 0, NULL, 0, 0);
}
if (ret == ENGINE_SUCCESS) {
connection->it = NULL;
}
} else {
return ENGINE_DISCONNECT;
}
return ret;
}
int do_item_link(struct default_engine *engine, hash_item *it) {
MEMCACHED_ITEM_LINK(item_get_key(it), it->nkey, it->nbytes);
assert((it->iflag & (ITEM_LINKED|ITEM_SLABBED)) == 0);
assert(it->nbytes < (1024 * 1024)); /* 1MB max size */
it->iflag |= ITEM_LINKED;
it->time = engine->server.core->get_current_time();
assoc_insert(engine, engine->server.core->hash(item_get_key(it),
it->nkey, 0),
it);
pthread_mutex_lock(&engine->stats.lock);
engine->stats.curr_bytes += ITEM_ntotal(engine, it);
engine->stats.curr_items += 1;
engine->stats.total_items += 1;
pthread_mutex_unlock(&engine->stats.lock);
/* Allocate a new CAS ID on link. */
item_set_cas(NULL, NULL, it, get_cas_id());
item_link_q(engine, it);
return 1;
}
static ENGINE_ERROR_CODE mock_store(ENGINE_HANDLE* handle,
const void *cookie,
item* itm,
uint64_t *cas,
ENGINE_STORE_OPERATION operation,
uint16_t vbucket) {
(void)cookie;
(void)cas;
(void)vbucket;
(void)operation;
mock_item* it = (mock_item*)itm;
genhash_update(get_ht(handle), item_get_key(itm), it->nkey, itm, 0);
return ENGINE_SUCCESS;
}
/*@null@*/
static char *do_item_cachedump(const unsigned int slabs_clsid,
const unsigned int limit,
unsigned int *bytes) {
#ifdef FUTURE
unsigned int memlimit = 2 * 1024 * 1024; /* 2MB max response size */
char *buffer;
unsigned int bufcurr;
hash_item *it;
unsigned int len;
unsigned int shown = 0;
char key_temp[KEY_MAX_LENGTH + 1];
char temp[512];
it = engine->items.heads[slabs_clsid];
buffer = malloc((size_t)memlimit);
if (buffer == 0) return NULL;
bufcurr = 0;
while (it != NULL && (limit == 0 || shown < limit)) {
assert(it->nkey <= KEY_MAX_LENGTH);
/* Copy the key since it may not be null-terminated in the struct */
strncpy(key_temp, item_get_key(it), it->nkey);
key_temp[it->nkey] = 0x00; /* terminate */
len = snprintf(temp, sizeof(temp), "ITEM %s [%d b; %lu s]\r\n",
key_temp, it->nbytes,
(unsigned long)it->exptime + process_started);
if (bufcurr + len + 6 > memlimit) /* 6 is END\r\n\0 */
break;
memcpy(buffer + bufcurr, temp, len);
bufcurr += len;
shown++;
it = it->next;
}
memcpy(buffer + bufcurr, "END\r\n", 6);
bufcurr += 5;
*bytes = bufcurr;
return buffer;
#endif
(void)slabs_clsid;
(void)limit;
(void)bytes;
return NULL;
}
static bool do_item_walk_cursor(struct default_engine *engine,
hash_item *cursor,
int steplength,
ITERFUNC itemfunc,
void* itemdata,
ENGINE_ERROR_CODE *error)
{
int ii = 0;
*error = ENGINE_SUCCESS;
while (cursor->prev != NULL && ii < steplength) {
/* Move cursor */
hash_item *ptr = cursor->prev;
bool done = false;
++ii;
item_unlink_q(engine, cursor);
if (ptr == engine->items.heads[cursor->slabs_clsid]) {
done = true;
cursor->prev = NULL;
} else {
cursor->next = ptr;
cursor->prev = ptr->prev;
cursor->prev->next = cursor;
ptr->prev = cursor;
}
/* Ignore cursors */
if (item_get_key(ptr)->header.len == 0 && ptr->nbytes == 0) {
--ii;
} else {
*error = itemfunc(engine, ptr, itemdata);
if (*error != ENGINE_SUCCESS) {
return false;
}
}
if (done) {
return false;
}
}
return (cursor->prev != NULL);
}
static bool get_item_info(ENGINE_HANDLE *handle, const void *cookie,
const item* item, item_info *item_info)
{
mock_item* it = (mock_item*)item;
if (item_info->nvalue < 1) {
return false;
}
item_info->cas = item_get_cas(it);
item_info->exptime = it->exptime;
item_info->nbytes = it->nbytes;
item_info->flags = it->flags;
item_info->clsid = it->clsid;
item_info->nkey = it->nkey;
item_info->nvalue = 1;
item_info->key = item_get_key(it);
item_info->value[0].iov_base = item_get_data(it);
item_info->value[0].iov_len = it->nbytes;
return true;
}
void do_item_unlink(struct default_engine *engine, hash_item *it) {
const hash_key* key = item_get_key(it);
MEMCACHED_ITEM_UNLINK(hash_key_get_client_key(key),
hash_key_get_client_key_len(key),
it->nbytes);
if ((it->iflag & ITEM_LINKED) != 0) {
it->iflag &= ~ITEM_LINKED;
cb_mutex_enter(&engine->stats.lock);
engine->stats.curr_bytes -= ITEM_ntotal(engine, it);
engine->stats.curr_items -= 1;
cb_mutex_exit(&engine->stats.lock);
assoc_delete(engine, crc32c(hash_key_get_key(key),
hash_key_get_key_len(key), 0),
key);
item_unlink_q(engine, it);
if (it->refcount == 0 || engine->scrubber.force_delete) {
item_free(engine, it);
}
}
}
static void assoc_maintenance_thread(void *arg) {
struct default_engine *engine = arg;
bool done = false;
do {
int ii;
cb_mutex_enter(&engine->cache_lock);
for (ii = 0; ii < hash_bulk_move && engine->assoc.expanding; ++ii) {
hash_item *it, *next;
int bucket;
for (it = engine->assoc.old_hashtable[engine->assoc.expand_bucket];
NULL != it; it = next) {
next = it->h_next;
bucket = engine->server.core->hash(item_get_key(it), it->nkey, 0)
& hashmask(engine->assoc.hashpower);
it->h_next = engine->assoc.primary_hashtable[bucket];
engine->assoc.primary_hashtable[bucket] = it;
}
engine->assoc.old_hashtable[engine->assoc.expand_bucket] = NULL;
engine->assoc.expand_bucket++;
if (engine->assoc.expand_bucket == hashsize(engine->assoc.hashpower - 1)) {
engine->assoc.expanding = false;
free(engine->assoc.old_hashtable);
if (engine->config.verbose > 1) {
EXTENSION_LOGGER_DESCRIPTOR *logger;
logger = (void*)engine->server.extension->get_extension(EXTENSION_LOGGER);
logger->log(EXTENSION_LOG_INFO, NULL,
"Hash table expansion done\n");
}
}
}
if (!engine->assoc.expanding) {
done = true;
}
cb_mutex_exit(&engine->cache_lock);
} while (!done);
}
static void *assoc_maintenance_thread(void *arg) {
struct default_engine *engine = arg;
bool done = false;
do {
int ii;
pthread_mutex_lock(&engine->cache_lock);
for (ii = 0; ii < hash_bulk_move && engine->assoc.expanding; ++ii) {
hash_item *it, *next;
int bucket;
for (it = engine->assoc.old_hashtable[engine->assoc.expand_bucket];
NULL != it; it = next) {
next = it->h_next;
bucket = engine->server.core->hash(item_get_key(it), it->nkey, 0)
& hashmask(engine->assoc.hashpower);
it->h_next = engine->assoc.primary_hashtable[bucket];
engine->assoc.primary_hashtable[bucket] = it;
}
engine->assoc.old_hashtable[engine->assoc.expand_bucket] = NULL;
engine->assoc.expand_bucket++;
if (engine->assoc.expand_bucket == hashsize(engine->assoc.hashpower - 1)) {
engine->assoc.expanding = false;
free(engine->assoc.old_hashtable);
if (engine->config.verbose > 1) {
fprintf(stderr, "Hash table expansion done\n");
}
}
}
if (!engine->assoc.expanding) {
done = true;
}
pthread_mutex_unlock(&engine->cache_lock);
} while (!done);
pthread_detach(pthread_self());
return NULL;
}
hash_item *assoc_find(struct default_engine *engine, uint32_t hash,
const char *key, const size_t nkey)
{
struct assoc *assoc = &engine->assoc;
hash_item *it;
int depth = 0;
uint32_t bucket = GET_HASH_BUCKET(hash, assoc->hashmask);
uint32_t tabidx = GET_HASH_TABIDX(hash, assoc->hashpower,
hashmask(assoc->infotable[bucket].curpower));
it = assoc->roottable[tabidx].hashtable[bucket];
while (it) {
if ((hash == it->khash) && (nkey == it->nkey) &&
(memcmp(key, item_get_key(it), nkey) == 0)) {
break; /* found */
}
it = it->h_next;
++depth;
}
MEMCACHED_ASSOC_FIND(key, nkey, depth);
return it;
}
/* Note: this isn't an assoc_update. The key must not already exist to call this */
int assoc_insert(struct persistent_engine *engine, uint32_t hash, hash_item *it) {
unsigned int oldbucket;
assert(assoc_find(engine, hash, item_get_key(&it->item), it->item.nkey) == 0); /* shouldn't have duplicately named things defined */
if (engine->assoc.expanding &&
(oldbucket = (hash & hashmask(engine->assoc.hashpower - 1))) >= engine->assoc.expand_bucket)
{
it->h_next = engine->assoc.old_hashtable[oldbucket];
engine->assoc.old_hashtable[oldbucket] = it;
} else {
it->h_next = engine->assoc.primary_hashtable[hash & hashmask(engine->assoc.hashpower)];
engine->assoc.primary_hashtable[hash & hashmask(engine->assoc.hashpower)] = it;
}
engine->assoc.hash_items++;
if (! engine->assoc.expanding && engine->assoc.hash_items > (hashsize(engine->assoc.hashpower) * 3) / 2) {
assoc_expand(engine);
}
return 1;
}
static void redistribute(struct default_engine *engine, unsigned int bucket)
{
struct assoc *assoc = &engine->assoc;
hash_item *it, **prev;
uint32_t tabidx;
uint32_t ii, table_count = hashsize(assoc->infotable[bucket].curpower);
for (ii=0; ii < table_count; ++ii) {
prev = &assoc->roottable[ii].hashtable[bucket];
while (*prev != NULL) {
it = *prev;
tabidx = GET_HASH_TABIDX(engine->server.core->hash(item_get_key(it), it->nkey, 0),
assoc->hashpower, hashmask(assoc->rootpower));
if (tabidx == ii) {
prev = &it->h_next;
} else {
*prev = it->h_next;
it->h_next = assoc->roottable[tabidx].hashtable[bucket];
assoc->roottable[tabidx].hashtable[bucket] = it;
}
}
}
assoc->infotable[bucket].curpower = assoc->rootpower;
}
int do_item_link(struct default_engine *engine, hash_item *it) {
const hash_key* key = item_get_key(it);
MEMCACHED_ITEM_LINK(hash_key_get_client_key(key), hash_key_get_client_key_len(key), it->nbytes);
cb_assert((it->iflag & (ITEM_LINKED|ITEM_SLABBED)) == 0);
it->iflag |= ITEM_LINKED;
it->time = engine->server.core->get_current_time();
assoc_insert(engine, crc32c(hash_key_get_key(key),
hash_key_get_key_len(key), 0),
it);
cb_mutex_enter(&engine->stats.lock);
engine->stats.curr_bytes += ITEM_ntotal(engine, it);
engine->stats.curr_items += 1;
engine->stats.total_items += 1;
cb_mutex_exit(&engine->stats.lock);
/* Allocate a new CAS ID on link. */
item_set_cas(NULL, NULL, it, get_cas_id());
item_link_q(engine, it);
return 1;
}
static char* item_get_data(const item* item)
{
return ((char*)item_get_key(item)) + item->nkey + 1;
}
static ENGINE_ERROR_CODE mock_item_delete(ENGINE_HANDLE* handle,
const void* cookie,
item* item) {
int r = genhash_delete_all(get_ht(handle), item_get_key(item), item->nkey);
return r > 0 ? ENGINE_SUCCESS : ENGINE_KEY_ENOENT;
}