One Level Up Top Level

runtime/kp_mempool.c - ktap

Functions defined

Source code

  1. /*
  2. * kp_mempool.c - ktap memory pool, service for string allocation
  3. *
  4. * This file is part of ktap by Jovi Zhangwei.
  5. *
  6. * Copyright (C) 2012-2013 Jovi Zhangwei <jovi.zhangwei@gmail.com>.
  7. *
  8. * ktap is free software; you can redistribute it and/or modify it
  9. * under the terms and conditions of the GNU General Public License,
  10. * version 2, as published by the Free Software Foundation.
  11. *
  12. * ktap is distributed in the hope it will be useful, but WITHOUT
  13. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15. * more details.
  16. *
  17. * You should have received a copy of the GNU General Public License along with
  18. * this program; if not, write to the Free Software Foundation, Inc.,
  19. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  20. */

  22. #include "../include/ktap_types.h"
  23. #include "kp_obj.h"
  24. #include "kp_str.h"

  26. #include <linux/ctype.h>
  27. #include <linux/module.h>
  28. #include "ktap.h"


  31. /*
  32. * allocate memory from mempool, the allocated memory will be free
  33. * util ktap exit.
  34. * TODO: lock-free allocation
  35. */
  36. ‌void *kp_mempool_alloc(ktap_state_t *ks, int size)
  37. {
  38.     ktap_global_state_t *g = G(ks);
  39.     void *mempool = g->mempool;
  40.     void *freepos = g->mp_freepos;
  41.     void *addr;
  42.     unsigned long flags;

  44.     local_irq_save(flags);
  45.     arch_spin_lock(&g->mp_lock);

  47.     if (unlikely((unsigned long)((char *)freepos + size)) >
  48.              (unsigned long)((char *)mempool + g->mp_size)) {
  49.         addr = NULL;
  50.         goto out;
  51.     }

  53.     addr = freepos;
  54.     g->mp_freepos = (char *)freepos + size;
  55. out:

  57.     arch_spin_unlock(&g->mp_lock);
  58.     local_irq_restore(flags);
  59.     return addr;
  60. }

  62. /*
  63. * destroy mempool.
  64. */
  65. ‌void kp_mempool_destroy(ktap_state_t *ks)
  66. {
  67.     ktap_global_state_t *g = G(ks);

  69.     if (!g->mempool)
  70.         return;

  72.     vfree(g->mempool);
  73.     g->mempool = NULL;
  74.     g->mp_freepos = NULL;
  75.     g->mp_size = 0;
  76. }

  78. /*
  79. * pre-allocate size Kbytes memory pool.
  80. */
  81. ‌int kp_mempool_init(ktap_state_t *ks, int size)
  82. {
  83.     ktap_global_state_t *g = G(ks);

  85.     g->mempool = vmalloc(size * 1024);
  86.     if (!g->mempool)
  87.         return -ENOMEM;

  89.     g->mp_freepos = g->mempool;
  90.     g->mp_size = size * 1024;
  91.     g->mp_lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
  92.     return 0;
  93. }

One Level Up Top Level