mm.c

Go to the documentation of this file.

/* $Id: mm.c,v 1.18 2004/05/05 11:59:35 jork Exp $ */
/*****************************************************************************/
/* (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/env/errno.h>
#include <l4/lock/lock.h>
#include <l4/names/libnames.h>
#include <l4/l4rm/l4rm.h>
#include <l4/dm_mem/dm_mem.h>
#include <l4/dm_phys/dm_phys.h>

#include <l4/dde_linux/dde.h>

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

/* OSKit */
#include <oskit/lmm.h>

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

static int _initialized = 0;

/* kernel memory - kmem */
static lmm_t kpool = LMM_INITIALIZER;
static lmm_region_t kregion[MM_KREGIONS];
static unsigned int kregion_size;
static unsigned int kcount = MM_KREGIONS - 1;
static l4lock_t klock = L4LOCK_UNLOCKED_INITIALIZER;

/* virtual memory - vmem */
static lmm_t vpool = LMM_INITIALIZER;
static lmm_region_t vregion;
static l4lock_t vlock = L4LOCK_UNLOCKED_INITIALIZER;

static __inline__ int __more_kcore(l4_size_t size, l4_uint32_t flags)
{
  int error;
  l4_addr_t kaddr;

  l4_size_t tmp;
  l4dm_mem_addr_t dm_paddr;

  if (!(kcount) || (size > kregion_size))
    {
      LOGdL(DEBUG_ERRORS, "Error: out of memory (kmem)");
      return -L4_ENOMEM;
    }

  LOGd(DEBUG_MALLOC, "requesting %d bytes (kmem)", size);

  /* open and attach new dataspace */
  kaddr = (l4_addr_t) \
    l4dm_mem_allocate_named(kregion_size,
                            L4DM_CONTIGUOUS | L4DM_PINNED | L4RM_MAP,
                            "dde kmem");
  if (!kaddr)
    {
      LOGdL(DEBUG_ERRORS, "Error: allocating kmem");
      return -L4_ENOMEM;
    }

  error = l4dm_mem_phys_addr((void *) kaddr, 1, &dm_paddr, 1, &tmp);
  if (error != 1)
    {
      if (error>1 || !error)
        Panic("Ouch, what's that?");
      LOGdL(DEBUG_ERRORS, "Error: getting physical address (%d)", error);
      return error;
    }

  LOGd(DEBUG_MALLOC, "adding %d Bytes (kmem) @ 0x%08x (phys. 0x%08x) region %d",
       size, kaddr, dm_paddr.addr, kcount);

  /* add new region */
  lmm_add_region(&kpool, &kregion[kcount--], (void *) kaddr, size, 0, 0);

  /* add free memory area to region/pool */
  lmm_add_free(&kpool, (void *) kaddr, size);

  /* address info */
  address_add_region(kaddr, dm_paddr.addr, size);

  return 0;
}

static __inline__ int __more_vcore(l4_size_t size)
{
  LOGdL(DEBUG_ERRORS, "Error: out of memory (vmem)");
  return -L4_ENOMEM;
}

void *kmalloc(size_t size, int gfp)
{
  lmm_flags_t lmm_flags = 0;
  l4_uint32_t *chunk;

  if (gfp & GFP_DMA)
    LOGd(DEBUG_MSG, "Warning: No ISA DMA implemented.");

  /* mutex pool access */
  l4lock_lock(&klock);

  size += sizeof(size_t);
  while (!(chunk = lmm_alloc(&kpool, size, lmm_flags)))
    {
      if (__more_kcore(size, lmm_flags))
        {
#if DEBUG_MALLOC
          LOG("failed to allocate %d bytes (kmem)", size);
          lmm_dump(&kpool);
          lmm_stats(&kpool);
#endif
          return NULL;
        }
    }
  *chunk = size;

  LOGd(DEBUG_MALLOC_EACH, "allocated %d bytes @ %p (kmem)", *chunk, chunk);

  l4lock_unlock(&klock);

  return ++chunk;
}

void kfree(const void *addr)
{
  l4_uint32_t *chunk = (l4_uint32_t *) addr - 1;

  if (!addr)
    return;

  /* mutex pool access */
  l4lock_lock(&klock);

  LOGd(DEBUG_MALLOC_EACH, "freeing %d bytes @ %p (kmem)", *chunk, chunk);

  lmm_free(&kpool, chunk, *chunk);

  l4lock_unlock(&klock);
}

void *vmalloc(unsigned long size)
{
  lmm_flags_t lmm_flags = 0;
  l4_uint32_t *chunk;

  /* mutex pool access */
  l4lock_lock(&vlock);

  size += sizeof(size_t);
  while (!(chunk = lmm_alloc(&vpool, size, lmm_flags)))
    {
      if (__more_vcore(size))
        {
#if DEBUG_MALLOC
          LOG("failed to allocate %ld bytes (vmem)", size);
          lmm_dump(&vpool);
          lmm_stats(&vpool);
#endif
          return NULL;
        }
    }
  *chunk = size;

  LOGd(DEBUG_MALLOC_EACH, "allocated %d bytes @ %p (vmem)", *chunk, chunk);

  l4lock_unlock(&vlock);

  return ++chunk;
}

void vfree(void *addr)
{
  l4_uint32_t *chunk = (l4_uint32_t *) addr - 1;

  if (!addr)
    return;

  /* mutex pool access */
  l4lock_lock(&vlock);

  lmm_free(&vpool, chunk, *chunk);

  LOGd(DEBUG_MALLOC_EACH, "freed %d bytes @ %p (vmem)", *chunk, chunk);

  l4lock_unlock(&vlock);
}

/*****************************************************************************/
/*****************************************************************************/
static int __setup_kmem(unsigned int *max, l4_addr_t *addr)
{
  unsigned int size = *max;
  int error;

  l4_size_t tmp;
  l4dm_mem_addr_t dm_paddr;

  kregion_size = size / MM_KREGIONS;
  LOGd(DEBUG_MALLOC, "size/regions = %d", kregion_size);

  kregion_size = (kregion_size + L4_PAGESIZE - 1) & L4_PAGEMASK;
  LOGd(DEBUG_MALLOC, "rsize (mod PAGESIZE) = %d", kregion_size);

  if (kregion_size * MM_KREGIONS < size)
    {
      kregion_size += L4_PAGESIZE;
      LOGd(DEBUG_MALLOC, "new rsize = %d\n", kregion_size);
    }

  LOGd(DEBUG_MALLOC, "kregion_size = 0x%x regions = %d", 
       kregion_size, MM_KREGIONS);

  /* open and attach initial dataspace */
  *addr = (l4_addr_t) \
    l4dm_mem_allocate_named(kregion_size,
                            L4DM_CONTIGUOUS | L4DM_PINNED | L4RM_MAP,
                            "dde kmem");
  if (!*addr) return -L4_ENOMEM;

  error = l4dm_mem_phys_addr((void *)*addr, 1, &dm_paddr, 1, &tmp);
  if (error != 1)
    {
      if (error>1 || !error)
        Panic("Ouch, what's that?");
      LOGdL(DEBUG_ERRORS, "Error: getting physical address (%d)", error);
      return error;
    }

  LOGd(DEBUG_MALLOC, "adding %d Bytes (kmem) @ 0x%08x (phys. 0x%08x) region 0",
       kregion_size, *addr, dm_paddr.addr);
  
  /* add initial region 0 */
  lmm_add_region(&kpool, &kregion[0], (void *) *addr, kregion_size, 0, 0);

  /* add free memory area to region/pool */
  lmm_add_free(&kpool, (void *) *addr, kregion_size);

  /* address info */
  address_add_region(*addr, dm_paddr.addr, kregion_size);

  *max = kregion_size * MM_KREGIONS;
  return 0;
}

/*****************************************************************************/
/*****************************************************************************/
static int __setup_vmem(unsigned int *max, l4_addr_t *addr)
{
  unsigned int size = *max;

  /* round */
  size = (size + L4_PAGESIZE - 1) & L4_PAGEMASK;

  /* open vmem dataspace */
  *addr = (l4_addr_t) l4dm_mem_allocate_named(size, L4RM_MAP, "dde vmem");
  if (!*addr) return -L4_ENOMEM;

  /* add region to vmem pool */
  lmm_add_region(&vpool, &vregion, (void *) *addr, size, 0, 0);
  /* add free memory area */
  lmm_add_free(&vpool, (void *) *addr, size);

  *max = size;
  return 0;
}

int l4dde_mm_init(unsigned int max_vsize, unsigned int max_ksize)
{
  int error;
  l4_addr_t vaddr, kaddr;

  char *vsize_str;
  char *ksize_str;

  if (_initialized)
    return 0;

  /* setup virtual memory pool */
  if ((error=__setup_vmem(&max_vsize, &vaddr)))
    {
      LOGdL(DEBUG_ERRORS, "Error: setting up vmem: %d (%s)", 
            error, l4env_strerror(-error));
      return error;
    }

  /* setup kernel memory pool */
  if ((error=__setup_kmem(&max_ksize, &kaddr)))
    {
      LOGdL(DEBUG_ERRORS, "Error: setting up kmem %d (%s)", 
            error, l4env_strerror(-error));
      return error;
    }

  /* print pretty message */
  if (max_vsize > 8 * 1024 * 1024)
    {
      max_vsize /= (1024 * 1024);
      vsize_str = "MB";
    }
  else if (max_vsize > 8 * 1024)
    {
      max_vsize /= 1024;
      vsize_str = "kB";
    }
  else
    vsize_str = "Byte";
  if (max_ksize > 8 * 1024 * 1024)
    {
      max_ksize /= (1024 * 1024);
      ksize_str = "MB";
    }
  else if (max_ksize > 8 * 1024)
    {
      max_ksize /= 1024;
      ksize_str = "kB";
    }
  else
    ksize_str = "Byte";
  LOG("Using ...\n"
      "  %d %s at 0x%08x (vmem)\n"
      "  %d %s in %d regions (kmem)",
      max_vsize, vsize_str, vaddr, max_ksize, ksize_str, MM_KREGIONS);

#if DEBUG_MALLOC
  {
    int debug;
    l4dm_dataspace_t ds;
    l4_offs_t offset;
    l4_addr_t map_addr;
    l4_size_t map_size;

    debug = l4rm_lookup((void*)vaddr, &ds, &offset, &map_addr, &map_size);
    if (debug)
      Panic("l4rm_lookup failed (%d)", debug);
    LOG("vmem: ds={%3u, "l4util_idfmt"} offset=%d map_addr=0x%08x map_size=%d",
        ds.id, l4util_idstr(ds.manager), offset, map_addr, map_size);
    
    debug = l4rm_lookup((void*)kaddr, &ds, &offset, &map_addr, &map_size);
    if (debug)
      Panic("l4rm_lookup failed (%d)", debug);
    LOG("kmem: ds={%3u, "l4util_idfmt"} offset=%d map_addr=0x%08x map_size=%d",
        ds.id, l4util_idstr(ds.manager), offset, map_addr, map_size);
  }
#endif

  ++_initialized;
  return 0;
}

int l4dde_mm_kmem_avail(void)
{
  if (_initialized)
    {
      return lmm_avail(&kpool, 0);
    }
  return 0;
}

---