One Level Up Top Level

runtime/ffi/ffi_call.c - ktap

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. * ffi_call.c - foreign function calling library support for ktap
  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 <linux/ctype.h>
  23. #include <linux/slab.h>
  24. #include "../../include/ktap_types.h"
  25. #include "../../include/ktap_ffi.h"
  26. #include "../ktap.h"
  27. #include "../kp_vm.h"
  28. #include "../kp_obj.h"

  30. ‌static int ffi_type_check(ktap_state_t *ks, csymbol_func *csf, int idx)
  31. {
  32.     StkId arg;
  33.     csymbol *cs;

  35.     if (idx >= csymf_arg_nr(csf))
  36.         return 0;
  37.     arg = kp_arg(ks, idx + 1);
  38.     cs = csymf_arg(ks, csf, idx);

  40.     if (!kp_cdata_type_match(ks, cs, arg))
  41.         return 0;
  42.     else {
  43.         kp_error(ks, "Cannot convert to csymbol %s for arg %d\n",
  44.                 csym_name(cs), idx);
  45.         return -1;
  46.     }
  47. }

  49. ‌static csymbol *ffi_get_arg_csym(ktap_state_t *ks, csymbol_func *csf, int idx)
  50. {
  51.     StkId arg;
  52.     csymbol *cs;

  54.     if (idx < csymf_arg_nr(csf))
  55.         return csymf_arg(ks, csf, idx);

  57.     arg = kp_arg(ks, idx + 1);
  58.     cs = id_to_csym(ks, ffi_get_csym_id(ks, "void *"));
  59.     switch (ttypenv(arg)) {
  60.     case KTAP_TYPE_LIGHTUSERDATA:
  61.     case KTAP_TYPE_BOOLEAN:
  62.     case KTAP_TYPE_NUMBER:
  63.     case KTAP_TYPE_STRING:
  64.         return cs;
  65.     case KTAP_TYPE_CDATA:
  66.         return cd_csym(ks, cdvalue(arg));
  67.     default:
  68.         kp_error(ks, "Error: Cannot get type for arg %d\n", idx);
  69.         return cs;
  70.     }
  71. }

  73. ‌static void ffi_unpack(ktap_state_t *ks, char *dst, csymbol_func *csf,
  74.         int idx, int align)
  75. {
  76.     StkId arg = kp_arg(ks, idx + 1);
  77.     csymbol *cs = ffi_get_arg_csym(ks, csf, idx);
  78.     size_t size = csym_size(ks, cs);

  80.     /* initialize the destination section */
  81.     memset(dst, 0, ALIGN(size, align));

  83.     kp_cdata_unpack(ks, dst, cs, arg);
  84. }

  86. #ifdef __x86_64

  88. ‌enum arg_status {
  89.     IN_REGISTER,
  90.     IN_MEMORY,
  91.     IN_STACK,
  92. };

  94. ‌#define ALIGN_STACK(v, a) ((void *)(ALIGN(((uint64_t)v), a)))
  95. ‌#define STACK_ALIGNMENT 8
  96. ‌#define REDZONE_SIZE 128
  97. ‌#define GPR_SIZE (sizeof(void *))
  98. ‌#define MAX_GPR 6
  99. ‌#define MAX_GPR_SIZE (MAX_GPR * GPR_SIZE)
  100. ‌#define NEWSTACK_SIZE 512

  102. ‌#define ffi_call_arch(ks, cf, rvalue) ffi_call_x86_64(ks, cf, rvalue)

  104. extern void ffi_call_assem_x86_64(void *stack, void *temp_stack,
  105.                     void *func_addr, void *rvalue, ffi_type rtype);

  107. ‌static void ffi_call_x86_64(ktap_state_t *ks, csymbol_func *csf, void *rvalue)
  108. {
  109.     int i;
  110.     int gpr_nr;
  111.     int arg_bytes; /* total bytes needed for exceeded args in stack */
  112.     int mem_bytes; /* total bytes needed for memory storage */
  113.     char *stack, *stack_p, *gpr_p, *arg_p, *mem_p, *tmp_p;
  114.     int arg_nr;
  115.     csymbol *rsym;
  116.     ffi_type rtype;
  117.     size_t rsize;
  118.     bool ret_in_memory;
  119.     /* New stack to call C function */
  120.     char space[NEWSTACK_SIZE];

  122.     arg_nr = kp_arg_nr(ks);
  123.     rsym = csymf_ret(ks, csf);
  124.     rtype = csym_type(rsym);
  125.     rsize = csym_size(ks, rsym);
  126.     ret_in_memory = false;
  127.     if (rtype == FFI_STRUCT || rtype == FFI_UNION) {
  128.         if (rsize > 16) {
  129.             rvalue = kp_malloc(ks, rsize);
  130.             rtype = FFI_VOID;
  131.             ret_in_memory = true;
  132.         } else {
  133.             /* much easier to always copy 16 bytes from registers */
  134.             rvalue = kp_malloc(ks, 16);
  135.         }
  136.     }

  138.     gpr_nr = 0;
  139.     arg_bytes = mem_bytes = 0;
  140.     if (ret_in_memory)
  141.         gpr_nr++;
  142.     /* calculate bytes needed for stack */
  143.     for (i = 0; i < arg_nr; i++) {
  144.         csymbol *cs = ffi_get_arg_csym(ks, csf, i);
  145.         size_t size = csym_size(ks, cs);
  146.         size_t align = csym_align(ks, cs);
  147.         enum arg_status st = IN_REGISTER;
  148.         int n_gpr_nr = 0;
  149.         if (size > 32) {
  150.             st = IN_MEMORY;
  151.             n_gpr_nr = 1;
  152.         } else if (size > 16)
  153.             st = IN_STACK;
  154.         else
  155.             n_gpr_nr = ALIGN(size, GPR_SIZE) / GPR_SIZE;

  157.         if (gpr_nr + n_gpr_nr > MAX_GPR) {
  158.             if (st == IN_MEMORY)
  159.                 arg_bytes += GPR_SIZE;
  160.             else
  161.                 st = IN_STACK;
  162.         } else
  163.             gpr_nr += n_gpr_nr;
  164.         if (st == IN_STACK) {
  165.             arg_bytes = ALIGN(arg_bytes, align);
  166.             arg_bytes += size;
  167.             arg_bytes = ALIGN(arg_bytes, STACK_ALIGNMENT);
  168.         }
  169.         if (st == IN_MEMORY) {
  170.             mem_bytes = ALIGN(mem_bytes, align);
  171.             mem_bytes += size;
  172.             mem_bytes = ALIGN(mem_bytes, STACK_ALIGNMENT);
  173.         }
  174.     }

  176.     /* apply space to fake stack for C function call */
  177.     if (16 + REDZONE_SIZE + MAX_GPR_SIZE + arg_bytes +
  178.             mem_bytes + 6 * 8 >= NEWSTACK_SIZE) {
  179.         kp_error(ks, "Unable to handle that many arguments by now\n");
  180.         return;
  181.     }
  182.     stack = space;
  183.     /* 128 bytes below %rsp is red zone */
  184.     /* stack should be 16-bytes aligned */
  185.     stack_p = ALIGN_STACK(stack + REDZONE_SIZE, 16);
  186.     /* save general purpose registers here */
  187.     gpr_p = stack_p;
  188.     memset(gpr_p, 0, MAX_GPR_SIZE);
  189.     /* save arguments in stack here */
  190.     arg_p = gpr_p + MAX_GPR_SIZE;
  191.     /* save arguments in memory here */
  192.     mem_p = arg_p + arg_bytes;
  193.     /* set additional space as temporary space */
  194.     tmp_p = mem_p + mem_bytes;

  196.     /* copy arguments here */
  197.     gpr_nr = 0;
  198.     if (ret_in_memory) {
  199.         memcpy(gpr_p, &rvalue, GPR_SIZE);
  200.         gpr_p += GPR_SIZE;
  201.         gpr_nr++;
  202.     }
  203.     for (i = 0; i < arg_nr; i++) {
  204.         csymbol *cs = ffi_get_arg_csym(ks, csf, i);
  205.         size_t size = csym_size(ks, cs);
  206.         size_t align = csym_align(ks, cs);
  207.         enum arg_status st = IN_REGISTER;
  208.         int n_gpr_nr = 0;
  209.         if (size > 32) {
  210.             st = IN_MEMORY;
  211.             n_gpr_nr = 1;
  212.         } else if (size > 16)
  213.             st = IN_STACK;
  214.         else
  215.             n_gpr_nr = ALIGN(size, GPR_SIZE) / GPR_SIZE;

  217.         if (st == IN_MEMORY)
  218.             mem_p = ALIGN_STACK(mem_p, align);
  219.         /* Tricky way about storing it above mem_p. It won't overflow
  220.          * because temp region can be temporarily used if necesseary. */
  221.         ffi_unpack(ks, mem_p, csf, i, GPR_SIZE);
  222.         if (gpr_nr + n_gpr_nr > MAX_GPR) {
  223.             if (st == IN_MEMORY) {
  224.                 memcpy(arg_p, &mem_p, GPR_SIZE);
  225.                 arg_p += GPR_SIZE;
  226.             } else
  227.                 st = IN_STACK;
  228.         } else {
  229.             memcpy(gpr_p, mem_p, n_gpr_nr * GPR_SIZE);
  230.             gpr_p += n_gpr_nr * GPR_SIZE;
  231.             gpr_nr += n_gpr_nr;
  232.         }
  233.         if (st == IN_STACK) {
  234.             arg_p = ALIGN_STACK(arg_p, align);
  235.             memcpy(arg_p, mem_p, size);
  236.             arg_p += size;
  237.             arg_p = ALIGN_STACK(arg_p, STACK_ALIGNMENT);
  238.         }
  239.         if (st == IN_MEMORY) {
  240.             mem_p += size;
  241.             mem_p = ALIGN_STACK(mem_p, STACK_ALIGNMENT);
  242.         }
  243.     }

  245.     kp_verbose_printf(ks, "Stack location: %p -redzone- %p -general purpose "
  246.             "register used- %p -zero- %p -stack for argument- %p"
  247.             " -memory for argument- %p -temp stack-\n",
  248.             stack, stack_p, gpr_p, stack_p + MAX_GPR_SIZE,
  249.             arg_p, mem_p);
  250.     kp_verbose_printf(ks, "GPR number: %d; arg in stack: %d; "
  251.             "arg in mem: %d\n",
  252.             gpr_nr, arg_bytes, mem_bytes);
  253.     kp_verbose_printf(ks, "Return: address %p type %d\n", rvalue, rtype);
  254.     kp_verbose_printf(ks, "Number of register used: %d\n", gpr_nr);
  255.     kp_verbose_printf(ks, "Start FFI call on %p\n", csf->addr);
  256.     ffi_call_assem_x86_64(stack_p, tmp_p, csf->addr, rvalue, rtype);
  257. }

  259. #else /* non-supported platform */

  261. ‌#define ffi_call(ks, cf, rvalue) ffi_call_unsupported(ks, cf, rvalue)

  263. ‌static void ffi_call_unsupported(ktap_state_t *ks,
  264.         csymbol_func *csf, void *rvalue)
  265. {
  266.     kp_error(ks, "unsupported architecture.\n");
  267. }

  269. #endif /* end for platform-specific setting */


  272. ‌static int ffi_set_return(ktap_state_t *ks, void *rvalue, csymbol_id ret_id)
  273. {
  274.     ktap_cdata_t *cd;
  275.     ffi_type type = csym_type(id_to_csym(ks, ret_id));

  277.     /* push return value to ktap stack */
  278.     switch (type) {
  279.     case FFI_VOID:
  280.         return 0;
  281.     case FFI_UINT8:
  282.     case FFI_INT8:
  283.     case FFI_UINT16:
  284.     case FFI_INT16:
  285.     case FFI_UINT32:
  286.     case FFI_INT32:
  287.     case FFI_UINT64:
  288.     case FFI_INT64:
  289.         set_number(ks->top, (ktap_number)rvalue);
  290.         break;
  291.     case FFI_PTR:
  292.         cd = kp_cdata_new_ptr(ks, rvalue, -1, ret_id, 0);
  293.         set_cdata(ks->top, cd);
  294.         break;
  295.     case FFI_STRUCT:
  296.     case FFI_UNION:
  297.         cd = kp_cdata_new_record(ks, rvalue, ret_id);
  298.         set_cdata(ks->top, cd);
  299.         break;
  300.     case FFI_FUNC:
  301.     case FFI_UNKNOWN:
  302.         kp_error(ks, "Error: Have not support ffi_type %s\n",
  303.                 ffi_type_name(type));
  304.         return 0;
  305.     }
  306.     incr_top(ks);
  307.     return 1;
  308. }

  310. /*
  311. * Call C into function
  312. * First argument should be function symbol address, argument types
  313. * and return type.
  314. * Left arguments should be arguments for calling the C function.
  315. * Types between Ktap and C are converted automatically.
  316. * Only support x86_64 function call by now
  317. */
  318. ‌int ffi_call(ktap_state_t *ks, csymbol_func *csf)
  319. {
  320.     int i;
  321.     int expected_arg_nr, arg_nr;
  322.     ktap_closure_t *cl;
  323.     void *rvalue;

  325.     expected_arg_nr = csymf_arg_nr(csf);
  326.     arg_nr = kp_arg_nr(ks);

  328.     /* check stack status for C call */
  329.     if (!csf->has_var_arg && expected_arg_nr != arg_nr) {
  330.         kp_error(ks, "wrong argument number %d, which should be %d\n",
  331.                 arg_nr, expected_arg_nr);
  332.         goto out;
  333.     }
  334.     if (csf->has_var_arg && expected_arg_nr > arg_nr) {
  335.         kp_error(ks, "argument number %d, which should be bigger than %d\n",
  336.                 arg_nr, expected_arg_nr);
  337.         goto out;
  338.     }

  340.     /* maybe useful later, leave it here first */
  341.     cl = clvalue(kp_arg(ks, arg_nr + 1));

  343.     /* check the argument types */
  344.     for (i = 0; i < arg_nr; i++) {
  345.         if (ffi_type_check(ks, csf, i) < 0)
  346.             goto out;
  347.     }

  349.     /* platform-specific calling workflow */
  350.     ffi_call_arch(ks, csf, &rvalue);
  351.     kp_verbose_printf(ks, "Finish FFI call\n");

  353. out:
  354.     return ffi_set_return(ks, rvalue, csymf_ret_id(csf));
  355. }

One Level Up Top Level