items.h

#ifndef ITEMS_H
#define ITEMS_H

/*
 * You should not try to aquire any of the item locks before calling these
 * functions.
 */
typedef struct _hash_item {
    struct _hash_item *next;
    struct _hash_item *prev;
    struct _hash_item *h_next; /* hash chain next */
    rel_time_t time;  /* least recent access */
    rel_time_t exptime; 
    uint32_t nbytes; 
    uint32_t flags; 
    uint16_t nkey; 
    uint16_t iflag; 
    unsigned short refcount;
    uint8_t slabs_clsid;/* which slab class we're in */
} hash_item;

typedef struct {
    unsigned int evicted;
    unsigned int evicted_nonzero;
    rel_time_t evicted_time;
    unsigned int outofmemory;
    unsigned int tailrepairs;
    unsigned int reclaimed;
} itemstats_t;

struct items {
   hash_item *heads[POWER_LARGEST];
   hash_item *tails[POWER_LARGEST];
   itemstats_t itemstats[POWER_LARGEST];
   unsigned int sizes[POWER_LARGEST];
};


hash_item *item_alloc(struct default_engine *engine,
                      const void *key, size_t nkey, int flags,
                      rel_time_t exptime, int nbytes, const void *cookie);

hash_item *item_get(struct default_engine *engine,
                    const void *key, const size_t nkey);

void item_stats_reset(struct default_engine *engine);

void item_stats(struct default_engine *engine,
                ADD_STAT add_stat,
                const void *cookie);

void item_stats_sizes(struct default_engine *engine,
                      ADD_STAT add_stat, const void *cookie);

char *item_cachedump(struct default_engine *engine,
                     const unsigned int slabs_clsid,
                     const unsigned int limit,
                     unsigned int *bytes);

void  item_flush_expired(struct default_engine *engine, time_t when);

void item_release(struct default_engine *engine, hash_item *it);

void item_unlink(struct default_engine *engine, hash_item *it);

hash_item *touch_item(struct default_engine *engine,
                      const void *key,
                      uint16_t nkey,
                      uint32_t exptime);

ENGINE_ERROR_CODE store_item(struct default_engine *engine,
                             hash_item *item,
                             uint64_t *cas,
                             ENGINE_STORE_OPERATION operation,
                             const void *cookie);

ENGINE_ERROR_CODE arithmetic(struct default_engine *engine,
                             const void* cookie,
                             const void* key,
                             const int nkey,
                             const bool increment,
                             const bool create,
                             const uint64_t delta,
                             const uint64_t initial,
                             const rel_time_t exptime,
                             uint64_t *cas,
                             uint64_t *result);


bool item_start_scrub(struct default_engine *engine);

tap_event_t item_tap_walker(ENGINE_HANDLE* handle,
                            const void *cookie, item **itm,
                            void **es, uint16_t *nes, uint8_t *ttl,
                            uint16_t *flags, uint32_t *seqno,
                            uint16_t *vbucket);

bool initialize_item_tap_walker(struct default_engine *engine,
                                const void* cookie);


#endif