rkmem.c

Go to the documentation of this file.

/*************************************************** */
/* Rule Set Based Access Control                     */
/* Author and (c) 1999-2005: Amon Ott <ao@rsbac.org> */
/* (a lot copied from mm/slab.c, with other          */
/*  copyrights)                                      */
/* Memory allocation functions for all parts         */
/* Last modified: 08/Jun/2005                        */
/*************************************************** */

#include <rsbac/types.h>
#include <rsbac/rkmem.h>
#include <rsbac/debug.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/timer.h>

/* Size description struct for general RSBAC caches. */
typedef struct rsbac_cache_sizes {
        size_t           cs_size;
        kmem_cache_t    *cs_cachep;
        char             name[15];
} rsbac_cache_sizes_t;

static rsbac_cache_sizes_t rsbac_cache_sizes[] = {
#if PAGE_SIZE == 4096
        {    32,        NULL,   "rsbac-32"},
#endif
        {    64,        NULL,   "rsbac-64"},
#if PAGE_SIZE == 4096
        {    96,        NULL,   "rsbac-96"},
#endif
        {   128,        NULL,   "rsbac-128"},
        {   192,        NULL,   "rsbac-192"},
        {   256,        NULL,   "rsbac-256"},
        {   512,        NULL,   "rsbac-512"},
        {  1024,        NULL,   "rsbac-1024"},
        {  2048,        NULL,   "rsbac-2048"},
        {  4096,        NULL,   "rsbac-4096"},
        {  8192,        NULL,   "rsbac-8192"},
/* Cannot use vmalloc in 2.6ff, so we need more space here */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
        { 16384,        NULL,   "rsbac-16384"},
        { 32768,        NULL,   "rsbac-32768"},
        { 65536,        NULL,   "rsbac-65536"},
        {131072,        NULL,   "rsbac-131072"},
#ifndef CONFIG_MMU
        {262144,        NULL,   "rsbac-262144"},
        {524288,        NULL,   "rsbac-524288"},
        {1048576,        NULL,   "rsbac-1048576"},
#ifdef CONFIG_LARGE_ALLOCS
        {2097152,        NULL,   "rsbac-2097152"},
        {4194304,        NULL,   "rsbac-4194304"},
        {8388608,        NULL,   "rsbac-8388608"},
        {16777216,        NULL,   "rsbac-16777216"},
        {33554432,        NULL,   "rsbac-33554432"},
#endif /* CONFIG_LARGE_ALLOCS */
#endif /* CONFIG_MMU */
#endif
        {     0,        NULL,   "rsbac0"}
};
#ifdef CONFIG_RSBAC_INIT_DELAY
void rsbac_kmem_cache_sizes_init(void)
#else
void __init rsbac_kmem_cache_sizes_init(void)
#endif
{
        rsbac_cache_sizes_t *sizes = rsbac_cache_sizes;

        while (sizes->cs_size) {
                sizes->cs_cachep = kmem_cache_create(
                        sizes->name, sizes->cs_size,
                        0, SLAB_HWCACHE_ALIGN, NULL, NULL);
                if (!sizes->cs_cachep)
                        BUG();

                sizes++;
        }
}


/**
 * rsbac_kmalloc - allocate memory
 * @size: how many bytes of memory are required.
 *
 * rsbac_kmalloc is the normal method of allocating memory for RSBAC
 * in the kernel. It will always be of type GFP_KERNEL in 2.4 and
 * GFP_ATOMIC in 2.6.
 *
 * rsbac_kmalloc'd memory is freed by rsbac_kfree
 */
#if defined(CONFIG_RSBAC_REG) || defined(CONFIG_RSBAC_REG_MAINT)
EXPORT_SYMBOL(rsbac_kmalloc);
#endif
void * rsbac_kmalloc (size_t size)
{
        rsbac_cache_sizes_t *csizep = rsbac_cache_sizes;

        if(!size)
          return NULL;
        for (; csizep->cs_size; csizep++) {
                if (size > csizep->cs_size)
                        continue;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
                return kmem_cache_alloc(csizep->cs_cachep, GFP_ATOMIC);
#else
                return kmem_cache_alloc(csizep->cs_cachep, GFP_KERNEL);
#endif
        }
        rsbac_printk(KERN_WARNING
               "rsbac_kmalloc: size %u requested, max size is %u!\n",
               size, RSBAC_MAX_KMALLOC);
        BUG();
        return NULL;
}

#if defined(CONFIG_RSBAC_REG) || defined(CONFIG_RSBAC_REG_MAINT)
EXPORT_SYMBOL(rsbac_vkmalloc);
#endif
void * rsbac_vkmalloc (size_t size, rsbac_boolean_t * vmalloc_used_p)
{
        rsbac_cache_sizes_t *csizep = rsbac_cache_sizes;
        void * result;

        if(!size)
          return NULL;
        for (; csizep->cs_size; csizep++) {
                if (size > csizep->cs_size)
                        continue;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
                result = kmem_cache_alloc(csizep->cs_cachep, GFP_ATOMIC);
#else
                result = kmem_cache_alloc(csizep->cs_cachep, GFP_KERNEL);
#endif
                if(result)
                  {
                    if(vmalloc_used_p)
                      *vmalloc_used_p = FALSE;
                    return result;
                  }
        }
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
        return NULL;
#else
        if(vmalloc_used_p)
          *vmalloc_used_p = TRUE;
        return vmalloc(size);
#endif
}

/**
 * rsbac_kfree - free previously allocated memory
 * @objp: pointer returned by kmalloc.
 *
 * Don't free memory not originally allocated by rsbac_kmalloc()
 * or you will run into trouble.
 *
 * We simply call general kfree, which does everything
 */
#if defined(CONFIG_RSBAC_REG) || defined(CONFIG_RSBAC_REG_MAINT)
EXPORT_SYMBOL(rsbac_kfree);
#endif
void rsbac_kfree (const void *objp)
  {
    kfree(objp);
  }

static void wakeup_kfree(u_long dk_dummy)
  {
    struct rsbac_delayed_kfree_t * dk_p = (struct rsbac_delayed_kfree_t *) dk_dummy;

    kfree(dk_p->objp);
    kfree(dk_p);
  }

#if defined(CONFIG_RSBAC_REG) || defined(CONFIG_RSBAC_REG_MAINT)
EXPORT_SYMBOL(rsbac_delayed_kfree);
#endif
void rsbac_delayed_kfree(void *objp, rsbac_time_t delay)
  {
    struct rsbac_delayed_kfree_t * dk_p;

    if(!objp)
      return;
    dk_p = rsbac_kmalloc(sizeof(*dk_p));
    if(!dk_p)
      return;

    dk_p->objp = objp;
    init_timer(&dk_p->timer);
    dk_p->timer.function = wakeup_kfree;
    dk_p->timer.data = (u_long) dk_p;
    dk_p->timer.expires = jiffies + delay * HZ;
    add_timer(&dk_p->timer);
  }

#if defined(CONFIG_RSBAC_REG) || defined(CONFIG_RSBAC_REG_MAINT)
EXPORT_SYMBOL(rsbac_vkfree);
#endif
void rsbac_vkfree(void *objp, rsbac_boolean_t vmalloc_used)
  {
    if(vmalloc_used)
      vfree(objp);
    else
      kfree(objp);
  }

/* end of rkmem.c */

---