/tmp/l4check/full_tree/trunk/l4/pkg/dde_linux/lib/src/slab.c

Go to the documentation of this file.

/* $Id: slab.c 27628 2007-01-17 16:05:57Z ch12 $ */
/*****************************************************************************/
/* (c) 2003 Technische Universitaet Dresden
 * This file is part of DROPS, which is distributed under the terms of the
 * GNU General Public License 2. Please see the COPYING file for details.
 */

/* L4 */
#include <l4/slab/slab.h>
#include <l4/log/l4log.h>
#include <l4/dm_mem/dm_mem.h>

#include <l4/dde_linux/dde.h>

/* Linux */
#include <linux/slab.h>

/* local */
#include "__config.h"
#include "internal.h"

#define CACHE_NAMELEN 20  
struct kmem_cache_s
{
  l4slab_cache_t *l4slab_cache;

  spinlock_t spinlock;

  /* constructor func */
  void (*ctor)(void *, kmem_cache_t *, unsigned long);
  /* de-constructor func */
  void (*dtor)(void *, kmem_cache_t *, unsigned long);

  char name[CACHE_NAMELEN];
};

static void * alloc_grow (l4slab_cache_t * cache, void **data)
{
  void *memp;
  kmem_cache_t *kcache = (kmem_cache_t *)l4slab_get_data(cache);

  LOGd_Enter(DEBUG_SLAB, "(name=%s)", kcache->name);

  if (!(memp = l4dm_mem_allocate (cache->slab_size,
                                  L4DM_PINNED | L4RM_MAP | L4RM_LOG2_ALIGNED)))
      Panic("dde: kmem_caches can't grow");

  return memp;
}

#if 0
void alloc_release(l4slab_cache_t *cache, void *page, void *data)
{
//printf("alloc_release\n");
 l4dm_mem_release(page);
}
#endif

kmem_cache_t * kmem_cache_create (const char *name, size_t size,
                                  size_t offset, unsigned long flags,
                                  void (*ctor) (void *, kmem_cache_t *, unsigned long),
                                  void (*dtor) (void *, kmem_cache_t *, unsigned long))
{
  kmem_cache_t *kcache;

  LOGd_Enter(DEBUG_SLAB, "(name=%s)", name);

  if (!name)
    {
      LOG_Error ("kmem_cache name required");
      return NULL;
    }
  if(dtor){
      LOG_Error("No destructors supported!");
      return 0;
  }

  kcache = vmalloc (sizeof (kmem_cache_t));
  kcache->l4slab_cache = vmalloc (sizeof (l4slab_cache_t));
  if (l4slab_cache_init (kcache->l4slab_cache, size, 0, alloc_grow, NULL))
    {
      LOG_Error ("Couldn't get l4slab_cache");
      return NULL;
    }

  l4slab_set_data(kcache->l4slab_cache, (void *)kcache);
  spin_lock_init(&kcache->spinlock);
  strncpy (kcache->name, name, CACHE_NAMELEN);

  kcache->ctor = ctor;
  kcache->dtor = dtor;

  return kcache;
}

int kmem_cache_destroy (kmem_cache_t * kcache)
{
  LOGd_Enter(DEBUG_SLAB, "(name=%s)", kcache->name);

  l4slab_destroy (kcache->l4slab_cache);
  vfree (kcache->l4slab_cache);
  vfree (kcache);

  return 0;  // l4slab_destroy never fails
}

void * kmem_cache_alloc (kmem_cache_t * kcache, int flags)
{
  void *p;

  spin_lock(&kcache->spinlock);
  p = l4slab_alloc (kcache->l4slab_cache);
  spin_unlock(&kcache->spinlock);

  if (kcache->ctor)
    kcache->ctor(p, kcache, flags);

  return p;
}

void kmem_cache_free (kmem_cache_t * kcache, void *objp)
{
  spin_lock(&kcache->spinlock);
  l4slab_free (kcache->l4slab_cache, objp);
  spin_unlock(&kcache->spinlock);
}

---