/**
* kmem_cache_destroy - delete a cache
* @cachep: the cache to destroy
*
* Remove a struct kmem_cache object from the slab cache.
* Returns 0 on success.
*
* It is expected this function will be called by a module when it is
* unloaded. This will remove the cache completely, and avoid a duplicate
* cache being allocated each time a module is loaded and unloaded, if the
* module doesn't have persistent in-kernel storage across loads and unloads.
*
* The cache must be empty before calling this function.
*
* The caller must guarantee that noone will allocate memory from the cache
* during the kmem_cache_destroy().
*/
void kmem_cache_destroy(struct kmem_cache *cache)
{
ddekit_log(DEBUG_SLAB, "\"%s\"", cache->name);
ddekit_slab_destroy(cache->ddekit_slab_cache);
ddekit_simple_free(cache);
}
/*****************************************************************************
* remove_timer *
****************************************************************************/
static void remove_timer(int id)
{
/* removes a timer from the timer list */
struct ddekit_timer_s *l,*m;
lock_timer();
for (l = &list; l && l->next && l->next->id!=id; l = l->next )
;
if (l && l->next) {
m = l->next;
DDEBUG_MSG_VERBOSE(
"deleting timer at for tick: %d fn: %p, (now: %d)\n",
m->exp, m->fn, jiffies);
l->next = m->next;
DDEBUG_MSG_TIMER(m);
ddekit_simple_free(m);
}
unlock_timer();
}
/*****************************************************************************
* ddekit_minix_deregister_msg_q *
****************************************************************************/
void ddekit_minix_deregister_msg_q(struct ddekit_minix_msg_q *mq)
{
struct ddekit_minix_msg_q *prev =_list, *it;
for (it = _list->next; it != NULL ; it = it->next) {
if (it == mq) {
prev->next = it->next;
break;
}
prev=it;
}
ddekit_sem_deinit(mq->msg_r_sem);
ddekit_sem_deinit(mq->msg_w_sem);
ddekit_simple_free(mq);
DDEBUG_MSG_VERBOSE("destroyed msg_q from \n");
}
/*****************************************************************************
* ddekit_timer_thread *
****************************************************************************/
static void ddekit_timer_thread(void * data)
{
struct ddekit_timer_s * l;
/* rock around the clock! */
for ( ; ; )
{
/* wait for timer interrupts */
ddekit_sem_down(pending_timer_ints);
DDEBUG_MSG_VERBOSE("handling timer interrupt");
/* execute all expired timers */
while( (l = get_next(jiffies)) != 0 ) {
DDEBUG_MSG_TIMER(l);
if (l->fn) {
l->fn(l->args);
}
ddekit_simple_free(l);
}
}
}
/**
* kmem_cache_create - Create a cache.
* @name: A string which is used in /proc/slabinfo to identify this cache.
* @size: The size of objects to be created in this cache.
* @align: The required alignment for the objects.
* @flags: SLAB flags
* @ctor: A constructor for the objects.
*
* Returns a ptr to the cache on success, NULL on failure.
* Cannot be called within a int, but can be interrupted.
* The @ctor is run when new pages are allocated by the cache
* and the @dtor is run before the pages are handed back.
*
* @name must be valid until the cache is destroyed. This implies that
* the module calling this has to destroy the cache before getting unloaded.
*
* The flags are
*
* %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5)
* to catch references to uninitialised memory.
*
* %SLAB_RED_ZONE - Insert `Red' zones around the allocated memory to check
* for buffer overruns.
*
* %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware
* cacheline. This can be beneficial if you're counting cycles as closely
* as davem.
*/
struct kmem_cache * kmem_cache_create(const char *name, size_t size, size_t align,
unsigned long flags,
void (*ctor)(void *))
{
ddekit_log(DEBUG_SLAB, "\"%s\" obj_size=%d", name, size);
struct kmem_cache *cache;
if (!name) {
printk("kmem_cache name reqeuired\n");
return 0;
}
cache = ddekit_simple_malloc(sizeof(*cache));
if (!cache) {
printk("No memory for slab cache\n");
return 0;
}
/* Initialize a physically contiguous cache for kmem */
if (!(cache->ddekit_slab_cache = ddekit_slab_init(size, 1))) {
printk("DDEKit slab init failed\n");
ddekit_simple_free(cache);
return 0;
}
cache->name = name;
cache->size = size;
cache->ctor = ctor;
ddekit_lock_init_unlocked(&cache->cache_lock);
ddekit_printf("Created cache %p with lock %p\n", cache, &cache->cache_lock);
return cache;
}
/******************************************************************************
* ddekit_lock_deinit *
*****************************************************************************/
PUBLIC void ddekit_lock_deinit (ddekit_lock_t *mtx)
{
ddekit_simple_free(*mtx);
}
