One Level Up Top Level

runtime/kp_vm.c - ktap

Global variables defined

Functions defined

Macros defined

Source code

  1. /*
  2. * kp_vm.c - ktap script virtual machine in Linux kernel
  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/slab.h>
  27. #include <linux/ftrace_event.h>
  28. #include <linux/signal.h>
  29. #include <linux/sched.h>
  30. #include <linux/uaccess.h>
  31. #include "../include/ktap_types.h"
  32. #include "../include/ktap_bc.h"
  33. #include "../include/ktap_ffi.h"
  34. #include "ktap.h"
  35. #include "kp_obj.h"
  36. #include "kp_str.h"
  37. #include "kp_mempool.h"
  38. #include "kp_tab.h"
  39. #include "kp_transport.h"
  40. #include "kp_vm.h"
  41. #include "kp_events.h"

  43. ‌#define KTAP_MIN_RESERVED_STACK_SIZE 20
  44. ‌#define KTAP_STACK_SIZE        120 /* enlarge this value for big stack */
  45. ‌#define KTAP_STACK_SIZE_BYTES    (KTAP_STACK_SIZE * sizeof(ktap_val_t))

  47. ‌#define KTAP_PERCPU_BUFFER_SIZE    (3 * PAGE_SIZE)

  49. static ktap_cfunction gfunc_get(ktap_state_t *ks, int idx);
  50. static int gfunc_getidx(ktap_global_state_t *g, ktap_cfunction cfunc);

  52. ‌static ktap_str_t *str_concat(ktap_state_t *ks, StkId top, int start, int end)
  53. {
  54.     int i, len = 0;
  55.     ktap_str_t *ts;
  56.     char *ptr, *buffer;

  58.     for (i = start; i <= end; i++) {
  59.         if (!is_string(top + i)) {
  60.             kp_error(ks, "cannot concat non-string\n");
  61.             return NULL;
  62.         }

  64.         len += rawtsvalue(top + i)->len;
  65.     }

  67.     if (len >= KTAP_PERCPU_BUFFER_SIZE) {
  68.         kp_error(ks, "Error: too long string concatenation\n");
  69.         return NULL;
  70.     }

  72.     preempt_disable_notrace();

  74.     buffer = kp_this_cpu_print_buffer(ks);
  75.     ptr = buffer;

  77.     for (i = start; i <= end; i++) {
  78.         int len = rawtsvalue(top + i)->len;
  79.         strncpy(ptr, svalue(top + i), len);
  80.         ptr += len;
  81.     }
  82.     ts = kp_str_new(ks, buffer, len);

  84.     preempt_enable_notrace();

  86.     return ts;
  87. }

  89. ‌static ktap_upval_t *findupval(ktap_state_t *ks, StkId slot)
  90. {
  91.     ktap_global_state_t *g = G(ks);
  92.     ktap_upval_t **pp = &ks->openupval;
  93.     ktap_upval_t *p;
  94.     ktap_upval_t *uv;

  96.     while (*pp != NULL && (p = *pp)->v >= slot) {
  97.         if (p->v == slot) {  /* found a corresponding upvalue? */
  98.             return p;
  99.         }
  100.         pp = (ktap_upval_t **)&p->nextgc;
  101.     }

  103.     /* not found: create a new one */
  104.     uv = (ktap_upval_t *)kp_malloc(ks, sizeof(ktap_upval_t));
  105.     if (!uv)
  106.         return NULL;
  107.     uv->gct = ~KTAP_TUPVAL;
  108.     uv->closed = 0; /* still open */
  109.     uv->v = slot;  /* current value lives in the stack */
  110.     /* Insert into sorted list of open upvalues. */
  111.     uv->nextgc = (ktap_obj_t *)*pp;
  112.     *pp = uv;
  113.     uv->prev = &g->uvhead;  /* double link it in `uvhead' list */
  114.     uv->next = g->uvhead.next;
  115.     uv->next->prev = uv;
  116.     g->uvhead.next = uv;
  117.     return uv;
  118. }

  120. ‌static void unlinkupval(ktap_upval_t *uv)
  121. {
  122.     uv->next->prev = uv->prev;  /* remove from `uvhead' list */
  123.     uv->prev->next = uv->next;
  124. }

  126. ‌void kp_freeupval(ktap_state_t *ks, ktap_upval_t *uv)
  127. {
  128.     if (!uv->closed)  /* is it open? */
  129.         unlinkupval(uv);  /* remove from open list */
  130.     kp_free(ks, uv);  /* free upvalue */
  131. }

  133. /* close upvals */
  134. ‌static void func_closeuv(ktap_state_t *ks, StkId level)
  135. {
  136.     ktap_upval_t *uv;
  137.     ktap_global_state_t *g = G(ks);
  138.     while (ks->openupval != NULL &&
  139.         (uv = ks->openupval)->v >= level) {
  140.         ktap_obj_t *o = obj2gco(uv);
  141.         /* remove from `open' list */
  142.         ks->openupval = (ktap_upval_t *)uv->nextgc;
  143.         unlinkupval(uv);  /* remove upvalue from 'uvhead' list */
  144.         set_obj(&uv->tv, uv->v);  /* move value to upvalue slot */
  145.         uv->v = &uv->tv;  /* now current value lives here */
  146.         uv->closed = 1;
  147.         gch(o)->nextgc = g->allgc; /* link upvalue into 'allgc' list */
  148.         g->allgc = o;
  149.     }
  150. }

  152. ‌#define SIZE_KTAP_FUNC(n) (sizeof(ktap_func_t) - sizeof(ktap_obj_t *) + \
  153.                sizeof(ktap_obj_t *) * (n))
  154. ‌static ktap_func_t *func_new_empty(ktap_state_t *ks, ktap_proto_t *pt)
  155. {
  156.     ktap_func_t *fn;

  158.     /* only mainthread can create new function */
  159.     if (ks != G(ks)->mainthread) {
  160.         kp_error(ks, "only mainthread can create function\n");
  161.         return NULL;
  162.     }

  164.     fn = (ktap_func_t *)kp_obj_new(ks, SIZE_KTAP_FUNC(pt->sizeuv));
  165.     if (!fn)
  166.         return NULL;
  167.     fn->gct = ~KTAP_TFUNC;
  168.     fn->nupvalues = 0; /* Set to zero until upvalues are initialized. */
  169.     fn->pc = proto_bc(pt);
  170.     fn->p = pt;

  172.     return fn;
  173. }

  175. ‌static ktap_func_t *func_new(ktap_state_t *ks, ktap_proto_t *pt,
  176.                  ktap_func_t *parent, ktap_val_t *base)
  177. {
  178.     ktap_func_t *fn;
  179.     int nuv = pt->sizeuv, i;

  181.     fn = func_new_empty(ks, pt);
  182.     if (!fn)
  183.         return NULL;

  185.     fn->nupvalues = nuv;
  186.     for (i = 0; i < nuv; i++) {
  187.         uint32_t v = proto_uv(pt)[i];
  188.         ktap_upval_t *uv;

  190.         if (v & PROTO_UV_LOCAL) {
  191.             uv = findupval(ks, base + (v & 0xff));
  192.             if (!uv)
  193.                 return NULL;
  194.             uv->immutable = ((v /PROTO_UV_IMMUTABLE) & 1);
  195.         } else {
  196.             uv = parent->upvals[v];
  197.         }
  198.         fn->upvals[i] = uv;
  199.     }
  200.     return fn;
  201. }

  203. ‌static inline int checkstack(ktap_state_t *ks, int n)
  204. {
  205.     if (unlikely(ks->stack_last - ks->top <= n)) {
  206.         kp_error(ks, "stack overflow, please enlarge stack size\n");
  207.         return -1;
  208.     }
  209.     return 0;
  210. }

  212. ‌static StkId adjust_varargs(ktap_state_t *ks, ktap_proto_t *p, int actual)
  213. {
  214.     int i;
  215.     int nfixargs = p->numparams;
  216.     StkId base, fixed;

  218.     /* move fixed parameters to final position */
  219.     fixed = ks->top - actual;  /* first fixed argument */
  220.     base = ks->top;  /* final position of first argument */

  222.     for (i=0; i < nfixargs; i++) {
  223.         set_obj(ks->top++, fixed + i);
  224.         set_nil(fixed + i);
  225.     }

  227.     return base;
  228. }

  230. ‌static void poscall(ktap_state_t *ks, StkId func, StkId first_result,
  231.            int wanted)
  232. {
  233.     int i;

  235.     for (i = wanted; i != 0 && first_result < ks->top; i--)
  236.         set_obj(func++, first_result++);

  238.     while(i-- > 0)
  239.         set_nil(func++);
  240. }

  242. ‌void kp_vm_call_proto(ktap_state_t *ks, ktap_proto_t *pt)
  243. {
  244.     ktap_func_t *fn;

  246.     fn = func_new_empty(ks, pt);
  247.     if (!fn)
  248.         return;
  249.     set_func(ks->top++, fn);
  250.     kp_vm_call(ks, ks->top - 1, 0);
  251. }

  253. /*
  254. * Hot loop detaction
  255. *
  256. * Check hot loop detaction in three cases:
  257. * 1. jmp -x: this happens in 'while (expr) { ... }'
  258. * 2. FORPREP-FORLOOP
  259. * 3. TFORCALL-TFORLOOP
  260. */
  261. ‌static __always_inline int check_hot_loop(ktap_state_t *ks, int loop_count)
  262. {
  263.     if (unlikely(loop_count == kp_max_loop_count)) {
  264.         kp_error(ks, "loop execute count exceed max limit(%d)\n",
  265.                  kp_max_loop_count);
  266.         return -1;
  267.     }

  269.     return 0;
  270. }

  272. ‌#define dojump(i, e) { pc += (int)bc_d(i) - BCBIAS_J + e; }
  273. ‌#define donextjump  { instr = *pc; dojump(instr, 1); }

  275. ‌#define NUMADD(a, b)    ((a) + (b))
  276. ‌#define NUMSUB(a, b)    ((a) - (b))
  277. ‌#define NUMMUL(a, b)    ((a) * (b))
  278. ‌#define NUMDIV(a, b)    ((a) / (b))
  279. ‌#define NUMUNM(a)       (-(a))
  280. ‌#define NUMEQ(a, b)     ((a) == (b))
  281. ‌#define NUMLT(a, b)     ((a) < (b))
  282. ‌#define NUMLE(a, b)     ((a) <= (b))
  283. ‌#define NUMMOD(a, b)    ((a) % (b))

  285. ‌#define arith_VV(ks, op) { \
  286.     ktap_val_t *rb = RB; \
  287.     ktap_val_t *rc = RC; \
  288.     if (is_number(rb) && is_number(rc)) { \
  289.         ktap_number nb = nvalue(rb), nc = nvalue(rc); \
  290.         set_number(RA, op(nb, nc)); \
  291.     } else {    \
  292.         kp_puts(ks, "Error: Cannot make arith operation\n");    \
  293.         return;    \
  294.     } }

  296. ‌#define arith_VN(ks, op) { \
  297.     ktap_val_t *rb = RB; \
  298.     if (is_number(rb)) { \
  299.         ktap_number nb = nvalue(rb);\
  300.         ktap_number nc = nvalue((ktap_val_t *)kbase + bc_c(instr));\
  301.         set_number(RA, op(nb, nc)); \
  302.     } else {    \
  303.         kp_puts(ks, "Error: Cannot make arith operation\n");    \
  304.         return;    \
  305.     } }

  307. ‌#define arith_NV(ks, op) { \
  308.     ktap_val_t *rb = RB; \
  309.     if (is_number(rb)) { \
  310.         ktap_number nb = nvalue(rb);\
  311.         ktap_number nc = nvalue((ktap_val_t *)kbase + bc_c(instr));\
  312.         set_number(RA, op(nc, nb)); \
  313.     } else {    \
  314.         kp_puts(ks, "Error: Cannot make arith operation\n");    \
  315.         return;    \
  316.     } }


  319. ‌static const char * const bc_names[] = {
  320. ‌#define BCNAME(name, ma, mb, mc, mt)       #name,
  321.     BCDEF(BCNAME)
  322. ‌#undef BCNAME
  323.     NULL
  324. };


  327. /*
  328. * ktap bytecode interpreter routine
  329. *
  330. *
  331. * kp_vm_call only can be used for:
  332. * 1). call ktap function, not light C function
  333. * 2). accept fixed argument function
  334. */
  335. ‌void kp_vm_call(ktap_state_t *ks, StkId func, int nresults)
  336. {
  337.     int loop_count = 0;
  338.     ktap_func_t *fn;
  339.     ktap_proto_t *pt;
  340.     ktap_obj_t **kbase;
  341.     unsigned int instr, op;
  342.     const unsigned int *pc;
  343.     StkId base; /* stack pointer */
  344.     int multres = 0; /* temp varible */
  345.     ktap_tab_t *gtab = G(ks)->gtab;

  347.     /* use computed goto for opcode dispatch */

  349.     static void *dispatch_table[] = {
  350. ‌#define BCNAME(name, ma, mb, mc, mt)       &&DO_BC_##name,
  351.         BCDEF(BCNAME)
  352. ‌#undef BCNAME
  353.     };

  355. ‌#define DISPATCH()                \
  356.     do {                    \
  357.         instr = *(pc++);        \
  358.         op = bc_op(instr);        \
  359.         goto *dispatch_table[op];    \
  360.     } while (0)

  362. ‌#define RA    (base + bc_a(instr))
  363. ‌#define RB    (base + bc_b(instr))
  364. ‌#define RC    (base + bc_c(instr))
  365. ‌#define RD    (base + bc_d(instr))
  366. ‌#define RKD    ((ktap_val_t *)kbase + bc_d(instr))

  368.     /*TODO: fix argument number mismatch, example: sort cmp closure */

  370.     fn = clvalue(func);
  371.     pt = fn->p;
  372.     kbase = fn->p->k;
  373.     base = func + 1;
  374.     pc = proto_bc(pt) + 1;
  375.     ks->top = base + pt->framesize;
  376.     func->pcr = 0; /* no previous frame */

  378.     /* main loop of interpreter */
  379.     DISPATCH();

  381.     while (1) {
  382.     DO_BC_ISLT: /* Jump if A < D */
  383.         if (!is_number(RA) || !is_number(RD)) {
  384.             kp_error(ks, "compare with non-number\n");
  385.             return;
  386.         }

  388.         if (nvalue(RA) >= nvalue(RD))
  389.             pc++;
  390.         else
  391.             donextjump;
  392.         DISPATCH();
  393.     DO_BC_ISGE: /* Jump if A >= D */
  394.         if (!is_number(RA) || !is_number(RD)) {
  395.             kp_error(ks, "compare with non-number\n");
  396.             return;
  397.         }

  399.         if (nvalue(RA) < nvalue(RD))
  400.             pc++;
  401.         else
  402.             donextjump;
  403.         DISPATCH();
  404.     DO_BC_ISLE: /* Jump if A <= D */
  405.         if (!is_number(RA) || !is_number(RD)) {
  406.             kp_error(ks, "compare with non-number\n");
  407.             return;
  408.         }

  410.         if (nvalue(RA) > nvalue(RD))
  411.             pc++;
  412.         else
  413.             donextjump;
  414.         DISPATCH();
  415.     DO_BC_ISGT: /* Jump if A > D */
  416.         if (!is_number(RA) || !is_number(RD)) {
  417.             kp_error(ks, "compare with non-number\n");
  418.             return;
  419.         }

  421.         if (nvalue(RA) <= nvalue(RD))
  422.             pc++;
  423.         else
  424.             donextjump;
  425.         DISPATCH();
  426.     DO_BC_ISEQV: /* Jump if A = D */
  427.         if (!kp_obj_equal(RA, RD))
  428.             pc++;
  429.         else
  430.             donextjump;
  431.         DISPATCH();
  432.     DO_BC_ISNEV: /* Jump if A != D */
  433.         if (kp_obj_equal(RA, RD))
  434.             pc++;
  435.         else
  436.             donextjump;
  437.         DISPATCH();
  438.     DO_BC_ISEQS: { /* Jump if A = D */
  439.         int idx = ~bc_d(instr);

  441.         if (!is_string(RA) ||
  442.                 rawtsvalue(RA) != (ktap_str_t *)kbase[idx])
  443.             pc++;
  444.         else
  445.             donextjump;
  446.         DISPATCH();
  447.         }
  448.     DO_BC_ISNES: { /* Jump if A != D */
  449.         int idx = ~bc_d(instr);

  451.         if (is_string(RA) &&
  452.             rawtsvalue(RA) == (ktap_str_t *)kbase[idx])
  453.             pc++;
  454.         else
  455.             donextjump;
  456.         DISPATCH();
  457.         }
  458.     DO_BC_ISEQN: /* Jump if A = D */
  459.         if (!is_number(RA) || nvalue(RA) !=  nvalue(RKD))
  460.             pc++;
  461.         else
  462.             donextjump;
  463.         DISPATCH();
  464.     DO_BC_ISNEN: /* Jump if A != D */
  465.         if (is_number(RA) && nvalue(RA) ==  nvalue(RKD))
  466.             pc++;
  467.         else
  468.             donextjump;
  469.         DISPATCH();
  470.     DO_BC_ISEQP: /* Jump if A = D */
  471.         if (itype(RA) != ~bc_d(instr))
  472.             pc++;
  473.         else
  474.             donextjump;
  475.         DISPATCH();
  476.     DO_BC_ISNEP: /* Jump if A != D */
  477.         if (itype(RA) == ~bc_d(instr))
  478.             pc++;
  479.         else
  480.             donextjump;
  481.         DISPATCH();
  482.     DO_BC_ISTC: /* Copy D to A and jump, if D is true */
  483.         if (itype(RD) == KTAP_TNIL || itype(RD) == KTAP_TFALSE)
  484.             pc++;
  485.         else {
  486.             set_obj(RA, RD);
  487.             donextjump;
  488.         }
  489.         DISPATCH();
  490.     DO_BC_ISFC: /* Copy D to A and jump, if D is false */
  491.         if (itype(RD) != KTAP_TNIL && itype(RD) != KTAP_TFALSE)
  492.             pc++;
  493.         else {
  494.             set_obj(RA, RD);
  495.             donextjump;
  496.         }
  497.         DISPATCH();
  498.     DO_BC_IST: /* Jump if D is true */
  499.         if (itype(RD) == KTAP_TNIL || itype(RD) == KTAP_TFALSE)
  500.             pc++;
  501.         else
  502.             donextjump;
  503.         DISPATCH();
  504.     DO_BC_ISF: /* Jump if D is false */
  505.         /* only nil and false are considered false,
  506.          * all other values are true */
  507.         if (itype(RD) != KTAP_TNIL && itype(RD) != KTAP_TFALSE)
  508.             pc++;
  509.         else
  510.             donextjump;
  511.         DISPATCH();
  512.     DO_BC_ISTYPE: /* generated by genlibbc, not compiler; not used now */
  513.     DO_BC_ISNUM:
  514.         return;
  515.     DO_BC_MOV: /* Copy D to A */
  516.         set_obj(RA, RD);
  517.         DISPATCH();
  518.     DO_BC_NOT: /* Set A to boolean not of D */
  519.         if (itype(RD) == KTAP_TNIL || itype(RD) == KTAP_TFALSE)
  520.             setitype(RA, KTAP_TTRUE);
  521.         else
  522.             setitype(RA, KTAP_TFALSE);

  524.         DISPATCH();
  525.     DO_BC_UNM: /* Set A to -D (unary minus) */
  526.         if (!is_number(RD)) {
  527.             kp_error(ks, "use '-' operator on non-number\n");
  528.             return;
  529.         }

  531.         set_number(RA, -nvalue(RD));
  532.         DISPATCH();
  533.     DO_BC_ADDVN: /* A = B + C */
  534.         arith_VN(ks, NUMADD);
  535.         DISPATCH();
  536.     DO_BC_SUBVN: /* A = B - C */
  537.         arith_VN(ks, NUMSUB);
  538.         DISPATCH();
  539.     DO_BC_MULVN: /* A = B * C */
  540.         arith_VN(ks, NUMMUL);
  541.         DISPATCH();
  542.     DO_BC_DIVVN: /* A = B / C */
  543.         /* divide 0 checking */
  544.         if (!nvalue((ktap_val_t *)kbase + bc_c(instr))) {
  545.             kp_error(ks, "divide 0 arith operation\n");
  546.             return;
  547.         }
  548.         arith_VN(ks, NUMDIV);
  549.         DISPATCH();
  550.     DO_BC_MODVN: /* A = B % C */
  551.         /* divide 0 checking */
  552.         if (!nvalue((ktap_val_t *)kbase + bc_c(instr))) {
  553.             kp_error(ks, "mod 0 arith operation\n");
  554.             return;
  555.         }
  556.         arith_VN(ks, NUMMOD);
  557.         DISPATCH();
  558.     DO_BC_ADDNV: /* A = C + B */
  559.         arith_NV(ks, NUMADD);
  560.         DISPATCH();
  561.     DO_BC_SUBNV: /* A = C - B */
  562.         arith_NV(ks, NUMSUB);
  563.         DISPATCH();
  564.     DO_BC_MULNV: /* A = C * B */
  565.         arith_NV(ks, NUMMUL);
  566.         DISPATCH();
  567.     DO_BC_DIVNV: /* A = C / B */
  568.         /* divide 0 checking */
  569.         if (!nvalue(RB)){
  570.             kp_error(ks, "divide 0 arith operation\n");
  571.             return;
  572.         }
  573.         arith_NV(ks, NUMDIV);
  574.         DISPATCH();
  575.     DO_BC_MODNV: /* A = C % B */
  576.         /* divide 0 checking */
  577.         if (!nvalue(RB)){
  578.             kp_error(ks, "mod 0 arith operation\n");
  579.             return;
  580.         }
  581.         arith_NV(ks, NUMMOD);
  582.         DISPATCH();
  583.     DO_BC_ADDVV: /* A = B + C */
  584.         arith_VV(ks, NUMADD);
  585.         DISPATCH();
  586.     DO_BC_SUBVV: /* A = B - C */
  587.         arith_VV(ks, NUMSUB);
  588.         DISPATCH();
  589.     DO_BC_MULVV: /* A = B * C */
  590.         arith_VV(ks, NUMMUL);
  591.         DISPATCH();
  592.     DO_BC_DIVVV: /* A = B / C */
  593.         arith_VV(ks, NUMDIV);
  594.         DISPATCH();
  595.     DO_BC_MODVV: /* A = B % C */
  596.         arith_VV(ks, NUMMOD);
  597.         DISPATCH();
  598.     DO_BC_POW: /* A = B ^ C, rejected */
  599.         return;
  600.     DO_BC_CAT: { /* A = B .. ~ .. C */
  601.         /* The CAT instruction concatenates all values in
  602.          * variable slots B to C inclusive. */
  603.         ktap_str_t *ts = str_concat(ks, base, bc_b(instr),
  604.                         bc_c(instr));
  605.         if (!ts)
  606.             return;

  608.         set_string(RA, ts);
  609.         DISPATCH();
  610.         }
  611.     DO_BC_KSTR: { /* Set A to string constant D */
  612.         int idx = ~bc_d(instr);
  613.         set_string(RA, (ktap_str_t *)kbase[idx]);
  614.         DISPATCH();
  615.         }
  616.     DO_BC_KCDATA: /* not used now */
  617.         DISPATCH();
  618.     DO_BC_KSHORT: /* Set A to 16 bit signed integer D */
  619.         set_number(RA, bc_d(instr));
  620.         DISPATCH();
  621.     DO_BC_KNUM: /* Set A to number constant D */
  622.         set_number(RA, nvalue(RKD));
  623.         DISPATCH();
  624.     DO_BC_KPRI: /* Set A to primitive D */
  625.         setitype(RA, ~bc_d(instr));
  626.         DISPATCH();
  627.     DO_BC_KNIL: { /* Set slots A to D to nil */
  628.         int i;
  629.         for (i = 0; i <= bc_d(instr) - bc_a(instr); i++) {
  630.             set_nil(RA + i);
  631.         }
  632.         DISPATCH();
  633.         }
  634.     DO_BC_UGET: /* Set A to upvalue D */
  635.         set_obj(RA, fn->upvals[bc_d(instr)]->v);
  636.         DISPATCH();
  637.     DO_BC_USETV: /* Set upvalue A to D */
  638.         set_obj(fn->upvals[bc_a(instr)]->v, RD);
  639.         DISPATCH();
  640.     DO_BC_UINCV: { /* upvalus[A] += D */
  641.         ktap_val_t *v = fn->upvals[bc_a(instr)]->v;
  642.         if (unlikely(!is_number(RD) || !is_number(v))) {
  643.             kp_error(ks, "use '+=' on non-number\n");
  644.             return;
  645.         }
  646.         set_number(v, nvalue(v) + nvalue(RD));
  647.         DISPATCH();
  648.         }
  649.     DO_BC_USETS: { /* Set upvalue A to string constant D */
  650.         int idx = ~bc_d(instr);
  651.         set_string(fn->upvals[bc_a(instr)]->v,
  652.                 (ktap_str_t *)kbase[idx]);
  653.         DISPATCH();
  654.         }
  655.     DO_BC_USETN: /* Set upvalue A to number constant D */
  656.         set_number(fn->upvals[bc_a(instr)]->v, nvalue(RKD));
  657.         DISPATCH();
  658.     DO_BC_UINCN: { /* upvalus[A] += D */
  659.         ktap_val_t *v = fn->upvals[bc_a(instr)]->v;
  660.         if (unlikely(!is_number(v))) {
  661.             kp_error(ks, "use '+=' on non-number\n");
  662.             return;
  663.         }
  664.         set_number(v, nvalue(v) + nvalue(RKD));
  665.         DISPATCH();
  666.         }
  667.     DO_BC_USETP: /* Set upvalue A to primitive D */
  668.         setitype(fn->upvals[bc_a(instr)]->v, ~bc_d(instr));
  669.         DISPATCH();
  670.     DO_BC_UCLO: /* Close upvalues for slots . rbase and jump to target D */
  671.         if (ks->openupval != NULL)
  672.             func_closeuv(ks, RA);
  673.         dojump(instr, 0);
  674.         DISPATCH();
  675.     DO_BC_FNEW: {
  676.         /* Create new closure from prototype D and store it in A */
  677.         int idx = ~bc_d(instr);
  678.         ktap_func_t *subfn = func_new(ks, (ktap_proto_t *)kbase[idx],
  679.                           fn, base);
  680.         if (unlikely(!subfn))
  681.             return;
  682.         set_func(RA, subfn);
  683.         DISPATCH();
  684.         }
  685.     DO_BC_TNEW: { /* Set A to new table with size D */
  686.         /*
  687.          * preallocate default narr and nrec,
  688.          * op_b and op_c is not used
  689.          * This would allocate more memory for some static table.
  690.          */
  691.         ktap_tab_t *t = kp_tab_new_ah(ks, 0, 0);
  692.         if (unlikely(!t))
  693.             return;
  694.         set_table(RA, t);
  695.         DISPATCH();
  696.         }
  697.     DO_BC_TDUP: { /* Set A to duplicated template table D */
  698.         int idx = ~bc_d(instr);
  699.         ktap_tab_t *t = kp_tab_dup(ks, (ktap_tab_t *)kbase[idx]);
  700.         if (!t)
  701.             return;
  702.         set_table(RA, t);
  703.         DISPATCH();
  704.         }
  705.     DO_BC_GGET: { /* A = _G[D] */
  706.         int idx = ~bc_d(instr);
  707.         kp_tab_getstr(gtab, (ktap_str_t *)kbase[idx], RA);
  708.         DISPATCH();
  709.         }
  710.     DO_BC_GSET: /* _G[D] = A, rejected. */
  711.     DO_BC_GINC: /* _G[D] += A, rejected. */
  712.         return;
  713.     DO_BC_TGETV: /* A = B[C] */
  714.         if (unlikely(!is_table(RB))) {
  715.             kp_error(ks, "get key from non-table\n");
  716.             return;
  717.         }

  719.         kp_tab_get(ks, hvalue(RB), RC, RA);
  720.         DISPATCH();
  721.     DO_BC_TGETS: { /* A = B[C] */
  722.         int idx = ~bc_c(instr);

  724.         if (unlikely(!is_table(RB))) {
  725.             kp_error(ks, "get key from non-table\n");
  726.             return;
  727.         }
  728.         kp_tab_getstr(hvalue(RB), (ktap_str_t *)kbase[idx], RA);
  729.         DISPATCH();
  730.         }
  731.     DO_BC_TGETB: { /* A = B[C] */
  732.         /* 8 bit literal C operand as an unsigned integer
  733.          * index (0..255)) */
  734.         uint8_t idx = bc_c(instr);

  736.         if (unlikely(!is_table(RB))) {
  737.             kp_error(ks, "set key to non-table\n");
  738.             return;
  739.         }
  740.         kp_tab_getint(hvalue(RB), idx, RA);
  741.         DISPATCH();
  742.         }
  743.     DO_BC_TGETR: /* generated by genlibbc, not compiler, not used */
  744.         return;
  745.     DO_BC_TSETV: /* B[C] = A */
  746.         if (unlikely(!is_table(RB))) {
  747.             kp_error(ks, "set key to non-table\n");
  748.             return;
  749.         }
  750.         kp_tab_set(ks, hvalue(RB), RC, RA);
  751.         DISPATCH();
  752.     DO_BC_TINCV: /* B[C] += A */
  753.         if (unlikely(!is_table(RB))) {
  754.             kp_error(ks, "set key to non-table\n");
  755.             return;
  756.         }
  757.         if (unlikely(!is_number(RA))) {
  758.             kp_error(ks, "use '+=' on non-number\n");
  759.             return;
  760.         }
  761.         kp_tab_incr(ks, hvalue(RB), RC, nvalue(RA));
  762.         DISPATCH();
  763.     DO_BC_TSETS: { /* B[C] = A */
  764.         int idx = ~bc_c(instr);

  766.         if (unlikely(!is_table(RB))) {
  767.             kp_error(ks, "set key to non-table\n");
  768.             return;
  769.         }
  770.         kp_tab_setstr(ks, hvalue(RB), (ktap_str_t *)kbase[idx], RA);
  771.         DISPATCH();
  772.         }
  773.     DO_BC_TINCS: { /* B[C] += A */
  774.         int idx = ~bc_c(instr);

  776.         if (unlikely(!is_table(RB))) {
  777.             kp_error(ks, "set key to non-table\n");
  778.             return;
  779.         }
  780.         if (unlikely(!is_number(RA))) {
  781.             kp_error(ks, "use '+=' on non-number\n");
  782.             return;
  783.         }
  784.         kp_tab_incrstr(ks, hvalue(RB), (ktap_str_t *)kbase[idx],
  785.                 nvalue(RA));
  786.         DISPATCH();
  787.         }
  788.     DO_BC_TSETB: { /* B[C] = A */
  789.         /* 8 bit literal C operand as an unsigned integer
  790.          * index (0..255)) */
  791.         uint8_t idx = bc_c(instr);

  793.         if (unlikely(!is_table(RB))) {
  794.             kp_error(ks, "set key to non-table\n");
  795.             return;
  796.         }
  797.         kp_tab_setint(ks, hvalue(RB), idx, RA);
  798.         DISPATCH();
  799.         }
  800.     DO_BC_TINCB: { /* B[C] = A */
  801.         uint8_t idx = bc_c(instr);

  803.         if (unlikely(!is_table(RB))) {
  804.             kp_error(ks, "set key to non-table\n");
  805.             return;
  806.         }
  807.         if (unlikely(!is_number(RA))) {
  808.             kp_error(ks, "use '+=' on non-number\n");
  809.             return;
  810.         }
  811.         kp_tab_incrint(ks, hvalue(RB), idx, nvalue(RA));
  812.         DISPATCH();
  813.         }
  814.     DO_BC_TSETM: /* don't support */
  815.         return;
  816.     DO_BC_TSETR: /* generated by genlibbc, not compiler, not used */
  817.         return;
  818.     DO_BC_CALLM:
  819.     DO_BC_CALL: { /* b: return_number + 1; c: argument + 1 */
  820.         int c = bc_c(instr);
  821.         int nresults = bc_b(instr) - 1;
  822.         StkId oldtop = ks->top;
  823.         StkId newfunc = RA;

  825.         if (op == BC_CALL && c != 0)
  826.             ks->top = RA + c;
  827.         else if (op == BC_CALLM)
  828.             ks->top = RA + c + multres;

  830.         if (itype(newfunc) == KTAP_TCFUNC) { /* light C function */
  831.             ktap_cfunction f = fvalue(newfunc);
  832.             int n;

  834.             if (unlikely(checkstack(ks,
  835.                     KTAP_MIN_RESERVED_STACK_SIZE)))
  836.                 return;

  838.             ks->func = newfunc;
  839.             n = (*f)(ks);
  840.             if (unlikely(n < 0)) /* error occured */
  841.                 return;
  842.             poscall(ks, newfunc, ks->top - n, nresults);

  844.             ks->top = oldtop;
  845.             multres = n + 1; /* set to multres */
  846.             DISPATCH();
  847.         } else if (itype(newfunc) == KTAP_TFUNC) { /* ktap function */
  848.             int n;

  850.             func = newfunc;
  851.             pt = clvalue(func)->p;

  853.             if (unlikely(checkstack(ks, pt->framesize)))
  854.                 return;

  856.             /* get number of real arguments */
  857.             n = (int)(ks->top - func) - 1;

  859.             /* complete missing arguments */
  860.             for (; n < pt->numparams; n++)
  861.                 set_nil(ks->top++);

  863.             base = (!(pt->flags & PROTO_VARARG)) ? func + 1 :
  864.                         adjust_varargs(ks, pt, n);

  866.             fn = clvalue(func);
  867.             pt = fn->p;
  868.             kbase = pt->k;
  869.             func->pcr = pc - 1; /* save pc */
  870.             ks->top = base + pt->framesize;
  871.             pc = proto_bc(pt) + 1; /* starting point */
  872.             DISPATCH();
  873.         } else {
  874.             kp_error(ks, "attempt to call nil function\n");
  875.             return;
  876.         }
  877.         }
  878.     DO_BC_CALLMT: /* don't support */
  879.         return;
  880.     DO_BC_CALLT: { /* Tailcall: return A(A+1, ..., A+D-1) */
  881.         StkId nfunc = RA;

  883.         if (itype(nfunc) == KTAP_TCFUNC) { /* light C function */
  884.             kp_error(ks, "don't support callt for C function");
  885.             return;
  886.         } else if (itype(nfunc) == KTAP_TFUNC) { /* ktap function */
  887.             int aux;

  889.             /*
  890.              * tail call: put called frame (n) in place of
  891.              * caller one (o)
  892.              */
  893.             StkId ofunc = func; /* caller function */
  894.             /* last stack slot filled by 'precall' */
  895.             StkId lim = nfunc + 1 + clvalue(nfunc)->p->numparams;

  897.             fn = clvalue(nfunc);
  898.             ofunc->val = nfunc->val;

  900.             /* move new frame into old one */
  901.             for (aux = 1; nfunc + aux < lim; aux++)
  902.                 set_obj(ofunc + aux, nfunc + aux);

  904.             pt = fn->p;
  905.             kbase = pt->k;
  906.             ks->top = base + pt->framesize;
  907.             pc = proto_bc(pt) + 1; /* starting point */
  908.             DISPATCH();
  909.         } else {
  910.             kp_error(ks, "attempt to call nil function\n");
  911.             return;
  912.         }
  913.         }
  914.     DO_BC_ITERC: /* don't support it now */
  915.         return;
  916.     DO_BC_ITERN: /* Specialized ITERC, if iterator function A-3 is next()*/
  917.         /* detect hot loop */
  918.         if (unlikely(check_hot_loop(ks, loop_count++) < 0))
  919.             return;

  921.         if (kp_tab_next(ks, hvalue(RA - 2), RA)) {
  922.             donextjump; /* Get jump target from ITERL */
  923.         } else {
  924.             pc++; /* jump to ITERL + 1 */
  925.         }
  926.         DISPATCH();
  927.     DO_BC_VARG: /* don't support */
  928.         return;
  929.     DO_BC_ISNEXT: /* Verify ITERN specialization and jump */
  930.         if (!is_cfunc(RA - 3) || !is_table(RA - 2) || !is_nil(RA - 1)
  931.             || fvalue(RA - 3) != (ktap_cfunction)kp_tab_next) {
  932.             /* Despecialize bytecode if any of the checks fail. */
  933.             setbc_op(pc - 1, BC_JMP);
  934.             dojump(instr, 0);
  935.             setbc_op(pc, BC_ITERC);
  936.         } else {
  937.             dojump(instr, 0);
  938.             set_nil(RA); /* init control variable */
  939.         }
  940.         DISPATCH();
  941.     DO_BC_RETM: /* don't support return multiple values */
  942.     DO_BC_RET:
  943.         return;
  944.     DO_BC_RET0:
  945.         /* if it's called from external invocation, just return */
  946.         if (!func->pcr)
  947.             return;

  949.         pc = func->pcr; /* restore PC */

  951.         multres = bc_d(instr);
  952.         set_nil(func);

  954.         base = func - bc_a(*pc);
  955.         func = base - 1;
  956.         fn = clvalue(func);
  957.         kbase = fn->p->k;
  958.         ks->top = base + pt->framesize;
  959.         pc++;

  961.         DISPATCH();
  962.     DO_BC_RET1:
  963.         /* if it's called from external invocation, just return */
  964.         if (!func->pcr)
  965.             return;

  967.         pc = func->pcr; /* restore PC */

  969.         multres = bc_d(instr);
  970.         set_obj(base - 1, RA); /* move result */

  972.         base = func - bc_a(*pc);
  973.         func = base - 1;
  974.         fn = clvalue(func);
  975.         kbase = fn->p->k;
  976.         ks->top = base + pt->framesize;
  977.         pc++;

  979.         DISPATCH();
  980.     DO_BC_FORI: { /* Numeric 'for' loop init */
  981.         ktap_number idx;
  982.         ktap_number limit;
  983.         ktap_number step;

  985.         if (unlikely(!is_number(RA) || !is_number(RA + 1) ||
  986.                 !is_number(RA + 2))) {
  987.             kp_error(ks, KTAP_QL("for")
  988.                  " init/limit/step value must be a number\n");
  989.             return;
  990.         }

  992.         idx = nvalue(RA);
  993.         limit = nvalue(RA + 1);
  994.         step = nvalue(RA + 2);

  996.         if (NUMLT(0, step) ? NUMLE(idx, limit) : NUMLE(limit, idx)) {
  997.             set_number(RA + 3, nvalue(RA));
  998.         } else {
  999.             dojump(instr, 0);
  1000.         }
  1001.         DISPATCH();
  1002.         }
  1003.     DO_BC_JFORI: /* not used */
  1004.         return;
  1005.     DO_BC_FORL: { /* Numeric 'for' loop */
  1006.         ktap_number step = nvalue(RA + 2);
  1007.         /* increment index */
  1008.         ktap_number idx = NUMADD(nvalue(RA), step);
  1009.         ktap_number limit = nvalue(RA + 1);
  1010.         if (NUMLT(0, step) ? NUMLE(idx, limit) : NUMLE(limit, idx)) {
  1011.             dojump(instr, 0); /* jump back */
  1012.             set_number(RA, idx);  /* update internal index... */
  1013.             set_number(RA + 3, idx);  /* ...and external index */
  1014.         }

  1016.         if (unlikely(check_hot_loop(ks, loop_count++) < 0))
  1017.             return;

  1019.         DISPATCH();
  1020.         }
  1021.     DO_BC_IFORL: /* not used */
  1022.     DO_BC_JFORL:
  1023.     DO_BC_ITERL:
  1024.     DO_BC_IITERL:
  1025.     DO_BC_JITERL:
  1026.         return;
  1027.     DO_BC_LOOP: /* Generic loop */
  1028.         /* ktap use this bc to detect hot loop */
  1029.         if (unlikely(check_hot_loop(ks, loop_count++) < 0))
  1030.             return;
  1031.         DISPATCH();
  1032.     DO_BC_ILOOP: /* not used */
  1033.     DO_BC_JLOOP:
  1034.         return;
  1035.     DO_BC_JMP: /* Jump */
  1036.         dojump(instr, 0);
  1037.         DISPATCH();
  1038.     DO_BC_FUNCF: /* function header, not used */
  1039.     DO_BC_IFUNCF:
  1040.     DO_BC_JFUNCF:
  1041.     DO_BC_FUNCV:
  1042.     DO_BC_IFUNCV:
  1043.     DO_BC_JFUNCV:
  1044.     DO_BC_FUNCC:
  1045.     DO_BC_FUNCCW:
  1046.         return;
  1047.     DO_BC_VARGN: /* arg0 .. arg9*/
  1048.         if (unlikely(!ks->current_event)) {
  1049.             kp_error(ks, "invalid event context\n");
  1050.             return;
  1051.         }

  1053.         kp_event_getarg(ks, RA, bc_d(instr));
  1054.         DISPATCH();
  1055.     DO_BC_VARGSTR: { /* argstr */
  1056.         /*
  1057.          * If you pass argstr to print/printf function directly,
  1058.          * then no extra string generated, so don't worry string
  1059.          * poll size for below case:
  1060.          *     print(argstr)
  1061.          *
  1062.          * If you use argstr as table key like below, then it may
  1063.          * overflow your string pool size, so be care of on it.
  1064.          *     table[argstr] = V
  1065.          *
  1066.          * If you assign argstr to upval or table value like below,
  1067.          * it don't really write string, just write type KTAP_TEVENTSTR,
  1068.          * the value will be interpreted when value print out in valid
  1069.          * event context, if context mismatch, error will report.
  1070.          *     table[V] = argstr
  1071.          *     upval = argstr
  1072.          *
  1073.          * If you want to save real string of argstr, then use it like
  1074.          * below, again, be care of string pool size in this case.
  1075.          *     table[V] = stringof(argstr)
  1076.          *     upval = stringof(argstr)
  1077.          */
  1078.         struct ktap_event_data *e = ks->current_event;

  1080.         if (unlikely(!e)) {
  1081.             kp_error(ks, "invalid event context\n");
  1082.             return;
  1083.         }

  1085.         if (e->argstr) /* argstr been stringified */
  1086.             set_string(RA, e->argstr);
  1087.         else
  1088.             set_eventstr(RA);
  1089.         DISPATCH();
  1090.         }
  1091.     DO_BC_VPROBENAME: { /* probename */
  1092.         struct ktap_event_data *e = ks->current_event;

  1094.         if (unlikely(!e)) {
  1095.             kp_error(ks, "invalid event context\n");
  1096.             return;
  1097.         }
  1098.         set_string(RA, e->event->name);
  1099.         DISPATCH();
  1100.         }
  1101.     DO_BC_VPID: /* pid */
  1102.         set_number(RA, (int)current->pid);
  1103.         DISPATCH();
  1104.     DO_BC_VTID: /* tid */
  1105.         set_number(RA, (int)task_pid_vnr(current));
  1106.         DISPATCH();
  1107.     DO_BC_VUID: { /* uid */
  1108. #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
  1109.         uid_t uid = from_kuid_munged(current_user_ns(), current_uid());
  1110. #else
  1111.         uid_t uid = current_uid();
  1112. #endif
  1113.         set_number(RA, (int)uid);
  1114.         DISPATCH();
  1115.         }
  1116.     DO_BC_VCPU: /* cpu */
  1117.         set_number(RA, smp_processor_id());
  1118.         DISPATCH();
  1119.     DO_BC_VEXECNAME: { /* execname */
  1120.         ktap_str_t *ts = kp_str_newz(ks, current->comm);
  1121.         if (unlikely(!ts))
  1122.             return;
  1123.         set_string(RA, ts);
  1124.         DISPATCH();
  1125.         }
  1126.     DO_BC_GFUNC: { /* Call built-in C function, patched by BC_GGET */
  1127.         ktap_cfunction cfunc = gfunc_get(ks, bc_d(instr));
  1128.         set_cfunc(RA, cfunc);
  1129.         DISPATCH();
  1130.         }
  1131.     }
  1132. }

  1134. /*
  1135. * Validate byte code and static analysis.
  1136. *
  1137. * TODO: more type checking before real running.
  1138. */
  1139. ‌int kp_vm_validate_code(ktap_state_t *ks, ktap_proto_t *pt, ktap_val_t *base)
  1140. {
  1141.     const unsigned int *pc = proto_bc(pt) + 1;
  1142.     unsigned int instr, op;
  1143.     ktap_obj_t **kbase = pt->k;
  1144.     ktap_tab_t *gtab = G(ks)->gtab;
  1145.     int i;

  1147. ‌#define RA    (base + bc_a(instr))
  1148. ‌#define RB    (base + bc_b(instr))
  1149. ‌#define RC    (base + bc_c(instr))
  1150. ‌#define RD    (base + bc_d(instr))

  1152.     if (pt->framesize > KP_MAX_SLOTS) {
  1153.         kp_error(ks, "exceed max frame size %d\n", pt->framesize);
  1154.         return -1;
  1155.     }

  1157.     if (base + pt->framesize > ks->stack_last) {
  1158.         kp_error(ks, "stack overflow\n");
  1159.         return -1;
  1160.     }

  1162.     for (i = 0; i < pt->sizebc - 1; i++) {
  1163.         instr = *pc++;
  1164.         op = bc_op(instr);


  1167.         if (op >= BC__MAX) {
  1168.             kp_error(ks, "unknown byte code %d\n", op);
  1169.             return -1;
  1170.         }

  1172.         switch (op) {
  1173.         case BC_FNEW: {
  1174.             int idx = ~bc_d(instr);
  1175.             ktap_proto_t *newpt = (ktap_proto_t *)kbase[idx];
  1176.             if (kp_vm_validate_code(ks, newpt, RA + 1))
  1177.                 return -1;

  1179.             break;
  1180.             }
  1181.         case BC_RETM: case BC_RET:
  1182.             kp_error(ks, "don't support return multiple values\n");
  1183.             return -1;
  1184.         case BC_GSET: case BC_GINC: { /* _G[D] = A, _G[D] += A */
  1185.             int idx = ~bc_d(instr);
  1186.             ktap_str_t *ts = (ktap_str_t *)kbase[idx];
  1187.             kp_error(ks, "cannot set global variable '%s'\n",
  1188.                     getstr(ts));
  1189.             return -1;
  1190.             }
  1191.         case BC_GGET: {
  1192.             int idx = ~bc_d(instr);
  1193.             ktap_str_t *ts = (ktap_str_t *)kbase[idx];
  1194.             ktap_val_t val;
  1195.             kp_tab_getstr(gtab, ts, &val);
  1196.             if (is_nil(&val)) {
  1197.                 kp_error(ks, "undefined global variable"
  1198.                         " '%s'\n", getstr(ts));
  1199.                 return -1;
  1200.             } else if (is_cfunc(&val)) {
  1201.                 int idx = gfunc_getidx(G(ks), fvalue(&val));
  1202.                 if (idx >= 0) {
  1203.                     /* patch BC_GGET bytecode to BC_GFUNC */
  1204.                     setbc_op(pc - 1, BC_GFUNC);
  1205.                     setbc_d(pc - 1, idx);
  1206.                 }
  1207.             }
  1208.             break;
  1209.             }
  1210.         case BC_ITERC:
  1211.             kp_error(ks, "ktap only support pairs iteraor\n");
  1212.             return -1;
  1213.         case BC_POW:
  1214.             kp_error(ks, "ktap don't support pow arith\n");
  1215.             return -1;
  1216.         }
  1217.     }

  1219.     return 0;
  1220. }

  1222. /* return cfunction by idx */
  1223. ‌static ktap_cfunction gfunc_get(ktap_state_t *ks, int idx)
  1224. {
  1225.     return G(ks)->gfunc_tbl[idx];
  1226. }

  1228. /* get cfunction index, the index is for fast get cfunction in runtime */
  1229. ‌static int gfunc_getidx(ktap_global_state_t *g, ktap_cfunction cfunc)
  1230. {
  1231.     int nr = g->nr_builtin_cfunction;
  1232.     ktap_cfunction *gfunc_tbl = g->gfunc_tbl;
  1233.     int i;

  1235.     for (i = 0; i < nr; i++) {
  1236.         if (gfunc_tbl[i] == cfunc)
  1237.             return i;
  1238.     }

  1240.     return -1;
  1241. }

  1243. ‌static void gfunc_add(ktap_state_t *ks, ktap_cfunction cfunc)
  1244. {
  1245.     int nr = G(ks)->nr_builtin_cfunction;

  1247.     if (nr == KP_MAX_CACHED_CFUNCTION) {
  1248.         kp_error(ks, "please enlarge KP_MAX_CACHED_CFUNCTION %d\n",
  1249.                 KP_MAX_CACHED_CFUNCTION);
  1250.         return;
  1251.     }
  1252.     G(ks)->gfunc_tbl[nr] = cfunc;
  1253.     G(ks)->nr_builtin_cfunction++;
  1254. }

  1256. /* function for register library */
  1257. ‌int kp_vm_register_lib(ktap_state_t *ks, const char *libname,
  1258.                const ktap_libfunc_t *funcs)
  1259. {
  1260.     ktap_tab_t *gtab = G(ks)->gtab;
  1261.     ktap_tab_t *target_tbl;
  1262.     int i;

  1264.     /* lib is null when register baselib function */
  1265.     if (libname == NULL)
  1266.         target_tbl = gtab;
  1267.     else {
  1268.         ktap_val_t key, val;
  1269.         ktap_str_t *ts = kp_str_newz(ks, libname);
  1270.         if (!ts)
  1271.             return -ENOMEM;

  1273.         /* calculate the function number contained by this library */
  1274.         for (i = 0; funcs[i].name != NULL; i++) {
  1275.         }

  1277.         target_tbl = kp_tab_new_ah(ks, 0, i + 1);
  1278.         if (!target_tbl)
  1279.             return -ENOMEM;

  1281.         set_string(&key, ts);
  1282.         set_table(&val, target_tbl);
  1283.         kp_tab_set(ks, gtab, &key, &val);
  1284.     }

  1286.     /* TODO: be care of same function name issue, foo() and tbl.foo() */
  1287.     for (i = 0; funcs[i].name != NULL; i++) {
  1288.         ktap_str_t *func_name = kp_str_newz(ks, funcs[i].name);
  1289.         ktap_val_t fn;

  1291.         if (unlikely(!func_name))
  1292.             return -ENOMEM;

  1294.         set_cfunc(&fn, funcs[i].func);
  1295.         kp_tab_setstr(ks, target_tbl, func_name, &fn);

  1297.         gfunc_add(ks, funcs[i].func);
  1298.     }

  1300.     return 0;
  1301. }

  1303. ‌static int init_registry(ktap_state_t *ks)
  1304. {
  1305.     ktap_tab_t *registry = kp_tab_new_ah(ks, 2, 0);
  1306.     ktap_val_t gtbl;
  1307.     ktap_tab_t *t;

  1309.     if (!registry)
  1310.         return -1;

  1312.     set_table(&G(ks)->registry, registry);

  1314.     /* assume there will have max 1024 global variables */
  1315.     t = kp_tab_new_ah(ks, 0, 1024);
  1316.     if (!t)
  1317.         return -1;

  1319.     set_table(&gtbl, t);
  1320.     kp_tab_setint(ks, registry, KTAP_RIDX_GLOBALS, &gtbl);
  1321.     G(ks)->gtab = t;

  1323.     return 0;
  1324. }

  1326. ‌static int init_arguments(ktap_state_t *ks, int argc, char __user **user_argv)
  1327. {
  1328.     ktap_tab_t *gtbl = G(ks)->gtab;
  1329.     ktap_tab_t *arg_tbl = kp_tab_new_ah(ks, argc, 1);
  1330.     ktap_val_t arg_tblval;
  1331.     ktap_val_t arg_tsval;
  1332.     ktap_str_t *argts = kp_str_newz(ks, "arg");
  1333.     char **argv;
  1334.     int i, ret;

  1336.     if (!arg_tbl)
  1337.         return -1;

  1339.     if (unlikely(!argts))
  1340.         return -ENOMEM;

  1342.     set_string(&arg_tsval, argts);
  1343.     set_table(&arg_tblval, arg_tbl);
  1344.     kp_tab_set(ks, gtbl, &arg_tsval, &arg_tblval);

  1346.     if (!argc)
  1347.         return 0;

  1349.     if (argc > 1024)
  1350.         return -EINVAL;

  1352.     argv = kzalloc(argc * sizeof(char *), GFP_KERNEL);
  1353.     if (!argv)
  1354.         return -ENOMEM;

  1356.     ret = copy_from_user(argv, user_argv, argc * sizeof(char *));
  1357.     if (ret < 0) {
  1358.         kfree(argv);
  1359.         return -EFAULT;
  1360.     }

  1362.     ret = 0;
  1363.     for (i = 0; i < argc; i++) {
  1364.         ktap_val_t val;
  1365.         char __user *ustr = argv[i];
  1366.         char *kstr;
  1367.         int len;
  1368.         int res;

  1370.         len = strlen_user(ustr);
  1371.         if (len > 0x1000) {
  1372.             ret = -EINVAL;
  1373.             break;
  1374.         }

  1376.         kstr = kmalloc(len + 1, GFP_KERNEL);
  1377.         if (!kstr) {
  1378.             ret = -ENOMEM;
  1379.             break;
  1380.         }

  1382.         if (strncpy_from_user(kstr, ustr, len) < 0) {
  1383.             kfree(kstr);
  1384.             ret = -EFAULT;
  1385.             break;
  1386.         }

  1388.         kstr[len] = '\0';

  1390.         if (!kstrtoint(kstr, 10, &res)) {
  1391.             set_number(&val, res);
  1392.         } else {
  1393.             ktap_str_t *ts = kp_str_newz(ks, kstr);
  1394.             if (unlikely(!ts)) {
  1395.                 kfree(kstr);
  1396.                 ret = -ENOMEM;
  1397.                 break;
  1398.             }

  1400.             set_string(&val, ts);
  1401.         }

  1403.         kp_tab_setint(ks, arg_tbl, i, &val);

  1405.         kfree(kstr);
  1406.     }

  1408.     kfree(argv);
  1409.     return ret;
  1410. }

  1412. ‌static void free_preserved_data(ktap_state_t *ks)
  1413. {
  1414.     int cpu, i, j;

  1416.     /* free stack for each allocated ktap_state */
  1417.     for_each_possible_cpu(cpu) {
  1418.         for (j = 0; j < PERF_NR_CONTEXTS; j++) {
  1419.             void *percpu_state = G(ks)->percpu_state[j];
  1420.             ktap_state_t *pks;

  1422.             if (!percpu_state)
  1423.                 break;
  1424.             pks = per_cpu_ptr(percpu_state, cpu);
  1425.             if (!ks)
  1426.                 break;
  1427.             kfree(pks->stack);
  1428.         }
  1429.     }

  1431.     /* free percpu ktap_state */
  1432.     for (i = 0; i < PERF_NR_CONTEXTS; i++) {
  1433.         if (G(ks)->percpu_state[i])
  1434.             free_percpu(G(ks)->percpu_state[i]);
  1435.     }

  1437.     /* free percpu ktap print buffer */
  1438.     for (i = 0; i < PERF_NR_CONTEXTS; i++) {
  1439.         if (G(ks)->percpu_print_buffer[i])
  1440.             free_percpu(G(ks)->percpu_print_buffer[i]);
  1441.     }

  1443.     /* free percpu ktap temp buffer */
  1444.     for (i = 0; i < PERF_NR_CONTEXTS; i++) {
  1445.         if (G(ks)->percpu_temp_buffer[i])
  1446.             free_percpu(G(ks)->percpu_temp_buffer[i]);
  1447.     }

  1449.     /* free percpu ktap recursion context flag */
  1450.     for (i = 0; i < PERF_NR_CONTEXTS; i++)
  1451.         if (G(ks)->recursion_context[i])
  1452.             free_percpu(G(ks)->recursion_context[i]);
  1453. }

  1455. ‌#define ALLOC_PERCPU(size)  __alloc_percpu(size, __alignof__(char))
  1456. ‌static int init_preserved_data(ktap_state_t *ks)
  1457. {
  1458.     void __percpu *data;
  1459.     int cpu, i, j;

  1461.     /* init percpu ktap_state */
  1462.     for (i = 0; i < PERF_NR_CONTEXTS; i++) {
  1463.         data = ALLOC_PERCPU(sizeof(ktap_state_t));
  1464.         if (!data)
  1465.             goto fail;
  1466.         G(ks)->percpu_state[i] = data;
  1467.     }

  1469.     /* init stack for each allocated ktap_state */
  1470.     for_each_possible_cpu(cpu) {
  1471.         for (j = 0; j < PERF_NR_CONTEXTS; j++) {
  1472.             void *percpu_state = G(ks)->percpu_state[j];
  1473.             ktap_state_t *pks;

  1475.             if (!percpu_state)
  1476.                 break;
  1477.             pks = per_cpu_ptr(percpu_state, cpu);
  1478.             if (!ks)
  1479.                 break;
  1480.             pks->stack = kzalloc(KTAP_STACK_SIZE_BYTES, GFP_KERNEL);
  1481.             if (!pks->stack)
  1482.                 goto fail;

  1484.             pks->stack_last = pks->stack + KTAP_STACK_SIZE;
  1485.             G(pks) = G(ks);
  1486.         }
  1487.     }

  1489.     /* init percpu ktap print buffer */
  1490.     for (i = 0; i < PERF_NR_CONTEXTS; i++) {
  1491.         data = ALLOC_PERCPU(KTAP_PERCPU_BUFFER_SIZE);
  1492.         if (!data)
  1493.             goto fail;
  1494.         G(ks)->percpu_print_buffer[i] = data;
  1495.     }

  1497.     /* init percpu ktap temp buffer */
  1498.     for (i = 0; i < PERF_NR_CONTEXTS; i++) {
  1499.         data = ALLOC_PERCPU(KTAP_PERCPU_BUFFER_SIZE);
  1500.         if (!data)
  1501.             goto fail;
  1502.         G(ks)->percpu_temp_buffer[i] = data;
  1503.     }

  1505.     /* init percpu ktap recursion context flag */
  1506.     for (i = 0; i < PERF_NR_CONTEXTS; i++) {
  1507.         data = alloc_percpu(int);
  1508.         if (!data)
  1509.             goto fail;
  1510.         G(ks)->recursion_context[i] = data;
  1511.     }

  1513.     return 0;

  1515. fail:
  1516.     free_preserved_data(ks);
  1517.     return -ENOMEM;
  1518. }

  1520. /*
  1521. * wait ktapio thread read all content in ring buffer.
  1522. *
  1523. * Here we use stupid approach to sync with ktapio thread,
  1524. * note that we cannot use semaphore/completion/other sync method,
  1525. * because ktapio thread could be killed by SIG_KILL in anytime, there
  1526. * have no safe way to up semaphore or wake waitqueue before thread exit.
  1527. *
  1528. * we also cannot use waitqueue of current->signal->wait_chldexit to sync
  1529. * exit, becasue mainthread and ktapio thread are in same thread group.
  1530. *
  1531. * Also ktap mainthread must wait ktapio thread exit, otherwise ktapio
  1532. * thread will oops when access ktap structure.
  1533. */
  1534. ‌static void wait_user_completion(ktap_state_t *ks)
  1535. {
  1536.     struct task_struct *tsk = G(ks)->task;
  1537.     G(ks)->wait_user = 1;

  1539.     while (1) {
  1540.         set_current_state(TASK_INTERRUPTIBLE);
  1541.         /* sleep for 100 msecs, and try again. */
  1542.         schedule_timeout(HZ / 10);

  1544.         if (get_nr_threads(tsk) == 1)
  1545.             break;
  1546.     }
  1547. }

  1549. ‌static void sleep_loop(ktap_state_t *ks,
  1550.             int (*actor)(ktap_state_t *ks, void *arg), void *arg)
  1551. {
  1552.     while (!ks->stop) {
  1553.         set_current_state(TASK_INTERRUPTIBLE);
  1554.         /* sleep for 100 msecs, and try again. */
  1555.         schedule_timeout(HZ / 10);

  1557.         if (actor(ks, arg))
  1558.             return;
  1559.     }
  1560. }

  1562. ‌static int sl_wait_task_pause_actor(ktap_state_t *ks, void *arg)
  1563. {
  1564.     struct task_struct *task = (struct task_struct *)arg;

  1566.     if (task->state)
  1567.         return 1;
  1568.     else
  1569.         return 0;
  1570. }

  1572. ‌static int sl_wait_task_exit_actor(ktap_state_t *ks, void *arg)
  1573. {
  1574.     struct task_struct *task = (struct task_struct *)arg;

  1576.     if (signal_pending(current)) {
  1577.         flush_signals(current);

  1579.         /* newline for handle CTRL+C display as ^C */
  1580.         kp_puts(ks, "\n");
  1581.         return 1;
  1582.     }

  1584.     /* stop waiting if target pid is exited */
  1585.     if (task && task->state == TASK_DEAD)
  1586.             return 1;

  1588.     return 0;
  1589. }

  1591. /* wait user interrupt, signal killed */
  1592. ‌static void wait_user_interrupt(ktap_state_t *ks)
  1593. {
  1594.     struct task_struct *task = G(ks)->trace_task;

  1596.     if (G(ks)->state == KTAP_EXIT || G(ks)->state == KTAP_ERROR)
  1597.         return;

  1599.     /* let tracing goes now. */
  1600.     ks->stop = 0;

  1602.     if (G(ks)->parm->workload) {
  1603.         /* make sure workload is in pause state
  1604.          * so it won't miss the signal */
  1605.         sleep_loop(ks, sl_wait_task_pause_actor, task);
  1606.         /* tell workload process to start executing */
  1607.         send_sig(SIGINT, G(ks)->trace_task, 0);
  1608.     }

  1610.     if (!G(ks)->parm->quiet)
  1611.         kp_printf(ks, "Tracing... Hit Ctrl-C to end.\n");

  1613.     sleep_loop(ks, sl_wait_task_exit_actor, task);
  1614. }

  1616. /*
  1617. * ktap exit, free all resources.
  1618. */
  1619. ‌void kp_vm_exit(ktap_state_t *ks)
  1620. {
  1621.     if (!list_empty(&G(ks)->events_head) ||
  1622.         !list_empty(&G(ks)->timers))
  1623.         wait_user_interrupt(ks);

  1625.     kp_exit_timers(ks);
  1626.     kp_events_exit(ks);

  1628.     /* free all resources got by ktap */
  1629. #ifdef CONFIG_KTAP_FFI
  1630.     ffi_free_symbols(ks);
  1631. #endif
  1632.     kp_str_freeall(ks);
  1633.     kp_mempool_destroy(ks);

  1635.     func_closeuv(ks, 0); /* close all open upvals, let below call free it */
  1636.     kp_obj_freeall(ks);

  1638.     kp_vm_exit_thread(ks);
  1639.     kp_free(ks, ks->stack);

  1641.     free_preserved_data(ks);
  1642.     free_cpumask_var(G(ks)->cpumask);

  1644.     wait_user_completion(ks);

  1646.     /* should invoke after wait_user_completion */
  1647.     if (G(ks)->trace_task)
  1648.         put_task_struct(G(ks)->trace_task);

  1650.     kp_transport_exit(ks);
  1651.     kp_free(ks, ks); /* free self */
  1652. }

  1654. /*
  1655. * ktap mainthread initization
  1656. */
  1657. ‌ktap_state_t *kp_vm_new_state(ktap_option_t *parm, struct dentry *dir)
  1658. {
  1659.     ktap_state_t *ks;
  1660.     ktap_global_state_t *g;
  1661.     pid_t pid;
  1662.     int cpu;

  1664.     ks = kzalloc(sizeof(ktap_state_t) + sizeof(ktap_global_state_t),
  1665.              GFP_KERNEL);
  1666.     if (!ks)
  1667.         return NULL;

  1669.     G(ks) = (ktap_global_state_t *)(ks + 1);
  1670.     g = G(ks);
  1671.     g->mainthread = ks;
  1672.     g->task = current;
  1673.     g->parm = parm;
  1674.     g->str_lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
  1675.     g->strmask = ~(int)0;
  1676.     g->uvhead.prev = &g->uvhead;
  1677.     g->uvhead.next = &g->uvhead;
  1678.     g->state = KTAP_RUNNING;
  1679.     INIT_LIST_HEAD(&(g->timers));
  1680.     INIT_LIST_HEAD(&(g->events_head));

  1682.     if (kp_transport_init(ks, dir))
  1683.         goto out;

  1685.     ks->stack = kp_malloc(ks, KTAP_STACK_SIZE_BYTES);
  1686.     if (!ks->stack)
  1687.         goto out;

  1689.     ks->stack_last = ks->stack + KTAP_STACK_SIZE;
  1690.     ks->top = ks->stack;

  1692.     pid = (pid_t)parm->trace_pid;
  1693.     if (pid != -1) {
  1694.         struct task_struct *task;

  1696.         rcu_read_lock();
  1697.         task = pid_task(find_vpid(pid), PIDTYPE_PID);
  1698.         if (!task) {
  1699.             kp_error(ks, "cannot find pid %d\n", pid);
  1700.             rcu_read_unlock();
  1701.             goto out;
  1702.         }
  1703.         g->trace_task = task;
  1704.         get_task_struct(task);
  1705.         rcu_read_unlock();
  1706.     }

  1708.     if( !alloc_cpumask_var(&g->cpumask, GFP_KERNEL))
  1709.         goto out;

  1711.     cpumask_copy(g->cpumask, cpu_online_mask);

  1713.     cpu = parm->trace_cpu;
  1714.     if (cpu != -1) {
  1715.         if (!cpu_online(cpu)) {
  1716.             kp_error(ks, "ktap: cpu %d is not online\n", cpu);
  1717.             goto out;
  1718.         }

  1720.         cpumask_clear(g->cpumask);
  1721.         cpumask_set_cpu(cpu, g->cpumask);
  1722.     }

  1724.     if (kp_mempool_init(ks, KP_MAX_MEMPOOL_SIZE))
  1725.         goto out;

  1727.     if (kp_str_resize(ks, 1024 - 1)) /* set string hashtable size */
  1728.         goto out;

  1730.     if (init_registry(ks))
  1731.         goto out;
  1732.     if (init_arguments(ks, parm->argc, parm->argv))
  1733.         goto out;

  1735.     /* init librarys */
  1736.     if (kp_lib_init_base(ks))
  1737.         goto out;
  1738.     if (kp_lib_init_kdebug(ks))
  1739.         goto out;
  1740.     if (kp_lib_init_timer(ks))
  1741.         goto out;
  1742.     if (kp_lib_init_ansi(ks))
  1743.         goto out;
  1744. #ifdef CONFIG_KTAP_FFI
  1745.     if (kp_lib_init_ffi(ks))
  1746.         goto out;
  1747. #endif
  1748.     if (kp_lib_init_table(ks))
  1749.         goto out;

  1751.     if (kp_lib_init_net(ks))
  1752.         goto out;

  1754.     if (init_preserved_data(ks))
  1755.         goto out;

  1757.     if (kp_events_init(ks))
  1758.         goto out;

  1760.     return ks;

  1762. out:
  1763.     g->state = KTAP_ERROR;
  1764.     kp_vm_exit(ks);
  1765.     return NULL;
  1766. }

One Level Up Top Level