#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; /**< When the item will expire (relative to process * startup) */ uint32_t nbytes; /**< The total size of the data (in bytes) */ uint32_t flags; /**< Flags associated with the item (in network byte order)*/ uint16_t nkey; /**< The total length of the key (in bytes) */ uint16_t iflag; /**< Intermal flags. lower 8 bit is reserved for the core * server, the upper 8 bits is reserved for engine * implementation. */ 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]; }; /** * Allocate and initialize a new item structure * @param engine handle to the storage engine * @param key the key for the new item * @param nkey the number of bytes in the key * @param flags the flags in the new item * @param exptime when the object should expire * @param nbytes the number of bytes in the body for the item * @param cookie cookie provided by the core to identify the client * @return a pointer to an item on success NULL otherwise */ 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); /** * Get an item from the cache * * @param engine handle to the storage engine * @param key the key for the item to get * @param nkey the number of bytes in the key * @return pointer to the item if it exists or NULL otherwise */ hash_item *item_get(struct default_engine *engine, const void *key, const size_t nkey); /** * Reset the item statistics * @param engine handle to the storage engine */ void item_stats_reset(struct default_engine *engine); /** * Get item statitistics * @param engine handle to the storage engine * @param add_stat callback provided by the core used to * push statistics into the response * @param cookie cookie provided by the core to identify the client */ void item_stats(struct default_engine *engine, ADD_STAT add_stat, const void *cookie); /** * Get detaild item statitistics * @param engine handle to the storage engine * @param add_stat callback provided by the core used to * push statistics into the response * @param cookie cookie provided by the core to identify the client */ void item_stats_sizes(struct default_engine *engine, ADD_STAT add_stat, const void *cookie); /** * Dump items from the cache * @param engine handle to the storage engine * @param slabs_clsid the slab class to get items from * @param limit the maximum number of items to receive * @param bytes the number of bytes in the return message (OUT) * @return pointer to a string containint the data * * @todo we need to rewrite this to use callbacks!!!! currently disabled */ char *item_cachedump(struct default_engine *engine, const unsigned int slabs_clsid, const unsigned int limit, unsigned int *bytes); /** * Flush expired items from the cache * @param engine handle to the storage engine * @param when when the items should be flushed */ void item_flush_expired(struct default_engine *engine, time_t when); /** * Release our reference to the current item * @param engine handle to the storage engine * @param it the item to release */ void item_release(struct default_engine *engine, hash_item *it); /** * Unlink the item from the hash table (make it inaccessible) * @param engine handle to the storage engine * @param it the item to unlink */ void item_unlink(struct default_engine *engine, hash_item *it); /** * Set the expiration time for an object * @param engine handle to the storage engine * @param key the key to set * @param nkey the number of characters in key.. * @param exptime the expiration time * @return The (updated) item if it exists */ hash_item *touch_item(struct default_engine *engine, const void *key, uint16_t nkey, uint32_t exptime); /** * Store an item in the cache * @param engine handle to the storage engine * @param item the item to store * @param cas the cas value (OUT) * @param operation what kind of store operation is this (ADD/SET etc) * @param cookie cookie provided by the core to identify the client * @return ENGINE_SUCCESS on success * * @todo should we refactor this into hash_item ** and remove the cas * there so that we can get it from the item instead? */ 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); /** * Start the item scrubber * @param engine handle to the storage engine */ bool item_start_scrub(struct default_engine *engine); /** * The tap walker to walk the hashtables */ 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