Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include 

 * Allocate frames for slab space and initialize

 *

 */

static slab_t * slab_space_alloc(slab_cache_t *cache, int flags)

{

  void *data;

  slab_t *slab;

  size_t fsize;

  unsigned int i;

  u32_t p;

  if (!data) {

    return NULL;

  }

  slab = (slab_t*)slab_create();

  if (!slab) {

    core_free(KA2PA(data));

      return NULL;

  }

  for (i = 0; i < ((u32_t) 1 << cache->order); i++)

    frame_set_parent(ADDR2PFN(KA2PA(data)) + i, slab);

  slab->available = cache->objects;

  slab->nextavail = (void*)data;

  slab->cache = cache;

  {

    *(addr_t *)p = p+cache->size;

    p = p+cache->size;

  };

  atomic_inc(&cache->allocated_slabs);

  return slab;

}

 * Take new object from slab or create new if needed

 *

 * @return Object address or null

 */

static void * slab_obj_create(slab_cache_t *cache, int flags)

{

  slab_t *slab;

  void *obj;

    /* Allow recursion and reclaiming

     * - this should work, as the slab control structures

     *   are small and do not need to allocate with anything

     *   other than frame_alloc when they are allocating,

     *   that's why we should get recursion at most 1-level deep

     */

    slab = slab_space_alloc(cache, flags);

    if (!slab)

    {

      spinlock_unlock(&cache->slablock);

      return NULL;

    }

  } else {

    slab = list_get_instance(cache->partial_slabs.next, slab_t, link);

    list_remove(&slab->link);

  }

  slab->nextavail = *(void**)obj;

  slab->available--;

    list_prepend(&slab->link, &cache->full_slabs);

  else

    list_prepend(&slab->link, &cache->partial_slabs);

    /* Bad, bad, construction failed */

//    slab_obj_destroy(cache, obj, slab);

//    return NULL;

//  }

  return obj;

}

static slab_t * obj2slab(void *obj)

{

  return (slab_t *) frame_get_parent(ADDR2PFN(KA2PA(obj)));

}

    memory */

void* __fastcall slab_alloc(slab_cache_t *cache, int flags)

{

   eflags_t efl;

   void *result = NULL;

   efl = safe_cli();

 //   result = magazine_obj_get(cache);

 // }

//  if (!result)

    result = slab_obj_create(cache, flags);

//    atomic_inc(&cache->allocated_objs);

}

/* Slab cache functions */

static unsigned int comp_objects(slab_cache_t *cache)

{

  if (cache->flags & SLAB_CACHE_SLINSIDE)

    return ((PAGE_SIZE << cache->order) - sizeof(slab_t)) / cache->size;

  else

    return (PAGE_SIZE << cache->order) / cache->size;

}

static unsigned int badness(slab_cache_t *cache)

{

  unsigned int objects;

  unsigned int ssize;

  size_t val;

  ssize = PAGE_SIZE << cache->order;

  if (cache->flags & SLAB_CACHE_SLINSIDE)

    ssize -= sizeof(slab_t);

  val = ssize - objects * cache->size;

  return val;

static void

_slab_cache_create(slab_cache_t *cache,

       size_t size,

       size_t align,

       int (*constructor)(void *obj, int kmflag),

       int (*destructor)(void *obj),

       int flags)

{

  int pages;

 // ipl_t ipl;

//  cache->name = name;

//    align = sizeof(unative_t);

//  size = ALIGN_UP(size, align);

//  cache->destructor = destructor;

  cache->flags = flags;

  list_initialize(&cache->partial_slabs);

  list_initialize(&cache->magazines);

//  spinlock_initialize(&cache->slablock, "slab_lock");

//  spinlock_initialize(&cache->maglock, "slab_maglock");

//  if (! (cache->flags & SLAB_CACHE_NOMAGAZINE))

//    make_magcache(cache);

  pages = SIZE2FRAMES(cache->size);

  /* We need the 2^order >= pages */

  if (pages == 1)

    cache->order = 0;

  else

    cache->order = fnzb(pages-1)+1;

    cache->order += 1;

  }

  cache->objects = comp_objects(cache);

//  ipl = interrupts_disable();

//  spinlock_lock(&slab_cache_lock);

//  interrupts_restore(ipl);

}

slab_cache_t * slab_cache_create(

				 size_t size,

				 size_t align,

				 int (*constructor)(void *obj, int kmflag),

				 int (*destructor)(void *obj),

				 int flags)

{

	slab_cache_t *cache;

  _slab_cache_create(cache, size, align, constructor, destructor, flags);

	return cache;

}

 * Deallocate space associated with slab

 *

 * @return number of freed frames

 */

static count_t slab_space_free(slab_cache_t *cache, slab_t *slab)

{

	frame_free(KA2PA(slab->start));

	if (! (cache->flags & SLAB_CACHE_SLINSIDE))

    slab_free(slab_cache, slab);

}

 * Return object to slab and call a destructor

 *

 * @param slab If the caller knows directly slab of the object, otherwise NULL

 *

 * @return Number of freed pages

 */

static count_t slab_obj_destroy(slab_cache_t *cache, void *obj,

				slab_t *slab)

{

	int freed = 0;

		slab = obj2slab(obj);

//    freed = cache->destructor(obj);

//	ASSERT(slab->available < cache->objects);

	slab->nextavail = obj;

	slab->available++;

	if (slab->available == cache->objects) {

		/* Free associated memory */

		list_remove(&slab->link);

//		spinlock_unlock(&cache->slablock);

		/* It was in full, move to partial */

		list_remove(&slab->link);

		list_prepend(&slab->link, &cache->partial_slabs);

	}

//	spinlock_unlock(&cache->slablock);

	return freed;

}

static void _slab_free(slab_cache_t *cache, void *obj, slab_t *slab)

{

   eflags_t efl;

//      || magazine_obj_put(cache, obj)) {

  safe_sti(efl);

  atomic_dec(&cache->allocated_objs);

}

void __fastcall slab_free(slab_cache_t *cache, void *obj)

{

	_slab_free(cache, obj, NULL);

}

{

  slab_t *slab;

  void *obj;

  u32_t p;

    /* Allow recursion and reclaiming

     * - this should work, as the slab control structures

     *   are small and do not need to allocate with anything

     *   other than frame_alloc when they are allocating,

     *   that's why we should get recursion at most 1-level deep

     */

//    spinlock_unlock(&cache->slablock);

//    slab = slab_create();

    unsigned int i;

    if (!data) {

      return NULL;

    }

    frame_set_parent(ADDR2PFN(KA2PA(data)), slab);

    slab->available = slab_cache->objects;

    slab->nextavail = (void*)data;

    slab->cache = slab_cache;

    {

      *(int *)p = p+slab_cache->size;

      p = p+slab_cache->size;

    };

//    spinlock_lock(&cache->slablock);

  } else {

    slab = list_get_instance(slab_cache->partial_slabs.next, slab_t, link);

    list_remove(&slab->link);

  }

  obj = slab->nextavail;

  slab->nextavail = *((void**)obj);

  slab->available--;

    list_prepend(&slab->link, &slab_cache->full_slabs);

  else

    list_prepend(&slab->link, &slab_cache->partial_slabs);

}

{

  slab_t *slab;

  void *obj;

  u32_t *p;

    /* Allow recursion and reclaiming

     * - this should work, as the slab control structures

     *   are small and do not need to allocate with anything

     *   other than frame_alloc when they are allocating,

     *   that's why we should get recursion at most 1-level deep

     */

//    spinlock_unlock(&cache->slablock);

//    slab = slab_create();

    unsigned int i;

    if (!data) {

      return NULL;

    }

    frame_set_parent(ADDR2PFN(KA2PA(data)), slab);

    slab->available = slab_cache_cache.objects;

    slab->nextavail = (void*)data;

    slab->cache = &slab_cache_cache;

    {

      *p = (u32_t)p+slab_cache_cache.size;

      p = (u32_t*)((u32_t)p+slab_cache_cache.size);

    };

//    spinlock_lock(&cache->slablock);

  } else {

    slab = list_get_instance(slab_cache_cache.partial_slabs.next, slab_t, link);

    list_remove(&slab->link);

  }

  obj = slab->nextavail;

  slab->nextavail = *((void**)obj);

  slab->available--;

    list_prepend(&slab->link, &slab_cache_cache.full_slabs);

  else

    list_prepend(&slab->link, &slab_cache_cache.partial_slabs);

}

{

                     sizeof(void *), NULL, NULL,

                     SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);

  slab_cache = slab_cache_create(sizeof(slab_t),

					      0, NULL, NULL,SLAB_CACHE_MAGDEFERRED);

};