One Level Up Top Level

runtime/kp_obj.c - ktap

Global variables defined

Functions defined

Macros defined

Source code

  1. /*
  2. * kp_obj.c - ktap object generic operation
  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. * Adapted from luajit and lua interpreter.
  9. * Copyright (C) 2005-2014 Mike Pall.
  10. * Copyright (C) 1994-2008 Lua.org, PUC-Rio.
  11. *
  12. * ktap is free software; you can redistribute it and/or modify it
  13. * under the terms and conditions of the GNU General Public License,
  14. * version 2, as published by the Free Software Foundation.
  15. *
  16. * ktap is distributed in the hope it will be useful, but WITHOUT
  17. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  19. * more details.
  20. *
  21. * You should have received a copy of the GNU General Public License along with
  22. * this program; if not, write to the Free Software Foundation, Inc.,
  23. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  24. */

  26. #include <linux/stacktrace.h>
  27. #include <linux/module.h>
  28. #include <linux/kallsyms.h>
  29. #include <linux/slab.h>
  30. #include "../include/ktap_types.h"
  31. #include "../include/ktap_ffi.h"
  32. #include "kp_obj.h"
  33. #include "kp_str.h"
  34. #include "kp_tab.h"
  35. #include "ktap.h"
  36. #include "kp_vm.h"
  37. #include "kp_transport.h"

  39. /* Error message strings. */
  40. ‌const char *kp_err_allmsg =
  41. ‌#define ERRDEF(name, msg)       msg "\0"
  42. #include "../include/ktap_errmsg.h"
  43. ;

  45. /* memory allocation flag */
  46. ‌#define KTAP_ALLOC_FLAGS ((GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN) \
  47.              & ~__GFP_WAIT)

  49. /*
  50. * TODO: It's not safe to call into facilities in the kernel at-large,
  51. * so we may need to use ktap own memory pool, not kmalloc.
  52. */


  55. ‌void *kp_malloc(ktap_state_t *ks, int size)
  56. {
  57.     void *addr;

  59.     addr = kmalloc(size, KTAP_ALLOC_FLAGS);
  60.     if (unlikely(!addr)) {
  61.         kp_error(ks, "kmalloc failed\n");
  62.     }
  63.     return addr;
  64. }

  66. ‌void *kp_zalloc(ktap_state_t *ks, int size)
  67. {
  68.     void *addr;

  70.     addr = kzalloc(size, KTAP_ALLOC_FLAGS);
  71.     if (unlikely(!addr))
  72.         kp_error(ks, "kzalloc failed\n");
  73.     return addr;
  74. }

  76. ‌void kp_free(ktap_state_t *ks, void *addr)
  77. {
  78.     kfree(addr);
  79. }


  82. ‌void kp_obj_dump(ktap_state_t *ks, const ktap_val_t *v)
  83. {
  84.     switch (itype(v)) {
  85.     case KTAP_TNIL:
  86.         kp_puts(ks, "NIL");
  87.         break;
  88.     case KTAP_TTRUE:
  89.         kp_printf(ks, "true");
  90.         break;
  91.     case KTAP_TFALSE:
  92.         kp_printf(ks, "false");
  93.         break;
  94.     case KTAP_TNUM:
  95.         kp_printf(ks, "NUM %ld", nvalue(v));
  96.         break;
  97.     case KTAP_TLIGHTUD:
  98.         kp_printf(ks, "LIGHTUD 0x%lx", (unsigned long)pvalue(v));
  99.         break;
  100.     case KTAP_TFUNC:
  101.         kp_printf(ks, "FUNCTION 0x%lx", (unsigned long)fvalue(v));
  102.         break;
  103.     case KTAP_TSTR:
  104.         kp_printf(ks, "STR #%s", svalue(v));
  105.         break;
  106.     case KTAP_TTAB:
  107.         kp_printf(ks, "TABLE 0x%lx", (unsigned long)hvalue(v));
  108.         break;
  109.         default:
  110.         kp_printf(ks, "GCVALUE 0x%lx", (unsigned long)gcvalue(v));
  111.         break;
  112.     }
  113. }

  115. ‌void kp_obj_show(ktap_state_t *ks, const ktap_val_t *v)
  116. {
  117.     switch (itype(v)) {
  118.     case KTAP_TNIL:
  119.         kp_puts(ks, "nil");
  120.         break;
  121.     case KTAP_TTRUE:
  122.         kp_puts(ks, "true");
  123.         break;
  124.     case KTAP_TFALSE:
  125.         kp_puts(ks, "false");
  126.         break;
  127.     case KTAP_TNUM:
  128.         kp_printf(ks, "%ld", nvalue(v));
  129.         break;
  130.     case KTAP_TLIGHTUD:
  131.         kp_printf(ks, "lightud 0x%lx", (unsigned long)pvalue(v));
  132.         break;
  133.     case KTAP_TCFUNC:
  134.         kp_printf(ks, "cfunction 0x%lx", (unsigned long)fvalue(v));
  135.         break;
  136.     case KTAP_TFUNC:
  137.         kp_printf(ks, "function 0x%lx", (unsigned long)gcvalue(v));
  138.         break;
  139.     case KTAP_TSTR:
  140.         kp_puts(ks, svalue(v));
  141.         break;
  142.     case KTAP_TTAB:
  143.         kp_printf(ks, "table 0x%lx", (unsigned long)hvalue(v));
  144.         break;
  145. #ifdef CONFIG_KTAP_FFI
  146.     case KTAP_TCDATA:
  147.         kp_cdata_dump(ks, cdvalue(v));
  148.         break;
  149. #endif
  150.     case KTAP_TEVENTSTR:
  151.         /* check event context */
  152.         if (!ks->current_event) {
  153.             kp_error(ks,
  154.             "cannot stringify event str in invalid context\n");
  155.             return;
  156.         }

  158.         kp_transport_event_write(ks, ks->current_event);
  159.         break;
  160.     case KTAP_TKSTACK:
  161.         kp_transport_print_kstack(ks, v->val.stack.depth,
  162.                           v->val.stack.skip);
  163.         break;
  164.         default:
  165.         kp_error(ks, "print unknown value type: %d\n", itype(v));
  166.         break;
  167.     }
  168. }


  171. /*
  172. * equality of ktap values.
  173. */
  174. ‌int kp_obj_rawequal(const ktap_val_t *t1, const ktap_val_t *t2)
  175. {
  176.     switch (itype(t1)) {
  177.     case KTAP_TNIL:
  178.     case KTAP_TTRUE:
  179.     case KTAP_TFALSE:
  180.         return 1;
  181.     case KTAP_TNUM:
  182.         return nvalue(t1) == nvalue(t2);
  183.     case KTAP_TLIGHTUD:
  184.         return pvalue(t1) == pvalue(t2);
  185.     case KTAP_TFUNC:
  186.         return fvalue(t1) == fvalue(t2);
  187.     case KTAP_TSTR:
  188.         return rawtsvalue(t1) == rawtsvalue(t2);
  189.     case KTAP_TTAB:
  190.         return hvalue(t1) == hvalue(t2);
  191.     default:
  192.         return gcvalue(t1) == gcvalue(t2);
  193.     }

  195.     return 0;
  196. }

  198. /*
  199. * ktap will not use lua's length operator for table,
  200. * also # is not for length operator any more in ktap.
  201. */
  202. ‌int kp_obj_len(ktap_state_t *ks, const ktap_val_t *v)
  203. {
  204.     switch(itype(v)) {
  205.     case KTAP_TTAB:
  206.         return kp_tab_len(ks, hvalue(v));
  207.     case KTAP_TSTR:
  208.         return rawtsvalue(v)->len;
  209.     default:
  210.         kp_printf(ks, "cannot get length of type %d\n", v->type);
  211.         return -1;
  212.     }
  213.     return 0;
  214. }

  216. /* need to protect allgc field? */
  217. ‌ktap_obj_t *kp_obj_new(ktap_state_t *ks, size_t size)
  218. {
  219.     ktap_obj_t *o, **list;

  221.     if (ks != G(ks)->mainthread) {
  222.         kp_error(ks, "kp_obj_new only can be called in mainthread\n");
  223.         return NULL;
  224.     }

  226.     o = kp_malloc(ks, size);
  227.     if (unlikely(!o))
  228.         return NULL;

  230.     list = &G(ks)->allgc;
  231.     gch(o)->nextgc = *list;
  232.     *list = o;

  234.     return o;
  235. }


  238. /* this function may be time consuming, move out from table set/get? */
  239. ‌ktap_str_t *kp_obj_kstack2str(ktap_state_t *ks, uint16_t depth, uint16_t skip)
  240. {
  241.     struct stack_trace trace;
  242.     unsigned long *bt;
  243.     char *btstr, *p;
  244.     int i;

  246.     bt = kp_this_cpu_print_buffer(ks); /* use print percpu buffer */
  247.     trace.nr_entries = 0;
  248.     trace.skip = skip;
  249.     trace.max_entries = depth;
  250.     trace.entries = (unsigned long *)(bt + 1);
  251.     save_stack_trace(&trace);

  253.     /* convert backtrace to string */
  254.     p = btstr = kp_this_cpu_temp_buffer(ks);
  255.     for (i = 0; i < trace.nr_entries; i++) {
  256.         unsigned long addr = trace.entries[i];

  258.         if (addr == ULONG_MAX)
  259.             break;

  261.         p += sprint_symbol(p, addr);
  262.         *p++ = '\n';
  263.         }

  265.     return kp_str_new(ks, btstr, p - btstr);
  266. }

  268. ‌void kp_obj_free_gclist(ktap_state_t *ks, ktap_obj_t *o)
  269. {
  270.     while (o) {
  271.         ktap_obj_t *next;

  273.         next = gch(o)->nextgc;
  274.         switch (gch(o)->gct) {
  275.         case ~KTAP_TTAB:
  276.             kp_tab_free(ks, (ktap_tab_t *)o);
  277.             break;
  278.         case ~KTAP_TUPVAL:
  279.             kp_freeupval(ks, (ktap_upval_t *)o);
  280.             break;
  281.         default:
  282.             kp_free(ks, o);
  283.         }
  284.         o = next;
  285.     }
  286. }

  288. ‌void kp_obj_freeall(ktap_state_t *ks)
  289. {
  290.     kp_obj_free_gclist(ks, G(ks)->allgc);
  291.     G(ks)->allgc = NULL;
  292. }

One Level Up Top Level