One Level Up Top Level

runtime/ffi/cdata.c - ktap

Functions defined

Source code

  1. /*
  2. * cdata.c - support functions for ktap_cdata_t
  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. */


  23. #include "../../include/ktap_types.h"
  24. #include "../../include/ktap_ffi.h"
  25. #include "../kp_obj.h"

  27. ‌ktap_cdata_t *kp_cdata_new(ktap_state_t *ks, csymbol_id id)
  28. {
  29.     ktap_cdata_t *cd;

  31.     cd = &kp_obj_newobject(ks, KTAP_TYPE_CDATA, sizeof(ktap_cdata_t), NULL)->cd;
  32.     cd_set_csym_id(cd, id);

  34.     return cd;
  35. }

  37. ‌ktap_cdata_t *kp_cdata_new_number(ktap_state_t *ks, void *val, csymbol_id id)
  38. {
  39.     ktap_cdata_t *cd;

  41.     cd = kp_cdata_new(ks, id);
  42.     cd_int(cd) = (cdata_number)val;

  44.     return cd;
  45. }

  47. /* argument nmemb here indicates the length of array that is pointed to,
  48. * -1 for unknown */
  49. ‌ktap_cdata_t *kp_cdata_new_ptr(ktap_state_t *ks, void *addr,
  50.                  int nmemb, csymbol_id id, int to_allocate)
  51. {
  52.     ktap_cdata_t *cd;
  53.     size_t memb_size;
  54.     csymbol_id deref_id;

  56.     cd = kp_cdata_new(ks, id);

  58.     if (to_allocate) {
  59.         /* allocate new empty space */
  60.         deref_id = csym_ptr_deref_id(id_to_csym(ks, id));
  61.         memb_size = csym_size(ks, id_to_csym(ks, deref_id));
  62.         cd_ptr(cd) = kp_rawobj_alloc(ks, memb_size * nmemb);
  63.     } else {
  64.         cd_ptr(cd) = addr;
  65.     }

  67.     cd_ptr_nmemb(cd) = nmemb;

  69.     return cd;
  70. }

  72. ‌ktap_cdata_t *kp_cdata_new_record(ktap_state_t *ks, void *val, csymbol_id id)
  73. {
  74.     ktap_cdata_t *cd;
  75.     size_t size;

  77.     cd = kp_cdata_new(ks, id);

  79.     /* if val == NULL, allocate new empty space */
  80.     if (val == NULL) {
  81.         size = csym_size(ks, id_to_csym(ks, id));
  82.         cd_record(cd) = kp_rawobj_alloc(ks, size);
  83.     } else
  84.         cd_record(cd) = val;

  86.     return cd;
  87. }

  89. ‌ktap_cdata_t *kp_cdata_new_by_id(ktap_state_t *ks, void *val, csymbol_id id)
  90. {
  91.     csymbol *cs = id_to_csym(ks, id);

  93.     switch (csym_type(cs)) {
  94.     case FFI_VOID:
  95.         kp_error(ks, "Error: Cannot new a void type\n");
  96.         return NULL;
  97.     case FFI_UINT8:
  98.     case FFI_INT8:
  99.     case FFI_UINT16:
  100.     case FFI_INT16:
  101.     case FFI_UINT32:
  102.     case FFI_INT32:
  103.     case FFI_UINT64:
  104.     case FFI_INT64:
  105.         return kp_cdata_new_number(ks, val, id);
  106.     case FFI_PTR:
  107.         return kp_cdata_new_ptr(ks, val, 0, id, 0);
  108.     case FFI_STRUCT:
  109.     case FFI_UNION:
  110.         return kp_cdata_new_record(ks, val, id);
  111.     case FFI_FUNC:
  112.         kp_error(ks, "Error: Cannot new a function type\n");
  113.         return NULL;
  114.     case FFI_UNKNOWN:
  115.     default:
  116.         kp_error(ks, "Error: unknown csymbol type %s\n", csym_name(cs));
  117.         return NULL;
  118.     }
  119. }

  121. ‌void kp_cdata_dump(ktap_state_t *ks, ktap_cdata_t *cd)
  122. {
  123.     switch (cd_type(ks, cd)) {
  124.     case FFI_UINT8:    case FFI_INT8:
  125.         kp_printf(ks, "c int(0x%01x)", cd_int(cd));
  126.         break;
  127.     case FFI_UINT16:    case FFI_INT16:
  128.         kp_printf(ks, "c int(0x%02x)", cd_int(cd));
  129.         break;
  130.     case FFI_UINT32:    case FFI_INT32:
  131.         kp_printf(ks, "c int(0x%04x)", cd_int(cd));
  132.         break;
  133.     case FFI_UINT64:    case FFI_INT64:
  134.         kp_printf(ks, "c int(0x%08x)", cd_int(cd));
  135.         break;
  136.     case FFI_PTR:
  137.         kp_printf(ks, "c pointer(0x%p)", cd_ptr(cd));
  138.         break;
  139.     case FFI_STRUCT:
  140.         kp_printf(ks, "c struct(0x%p)", cd_struct(cd));
  141.         break;
  142.     case FFI_UNION:
  143.         kp_printf(ks, "c union(0x%p)", cd_union(cd));
  144.         break;
  145.     default:
  146.         kp_printf(ks, "unsupported cdata type %d!\n", cd_type(ks, cd));
  147.     }
  148. }

  150. /* Notice: Even if the types are matched, there may exist the lost of
  151. * data in the unpack process due to precision */
  152. ‌int kp_cdata_type_match(ktap_state_t *ks, csymbol *cs, ktap_val_t *val)
  153. {
  154.     ffi_type type;

  156.     type = csym_type(cs);
  157.     if (type == FFI_FUNC)
  158.         goto error;

  160.     switch (ttypenv(val)) {
  161.     case KTAP_TYPE_LIGHTUSERDATA:
  162.         if (type != FFI_PTR) goto error;
  163.         break;
  164.     case KTAP_TYPE_BOOLEAN:
  165.     case KTAP_TYPE_NUMBER:
  166.         if (type != FFI_UINT8 && type != FFI_INT8
  167.         && type != FFI_UINT16 && type != FFI_INT16
  168.         && type != FFI_UINT32 && type != FFI_INT32
  169.         && type != FFI_UINT64 && type != FFI_INT64)
  170.             goto error;
  171.         break;
  172.     case KTAP_TYPE_STRING:
  173.         if (type != FFI_PTR && type != FFI_UINT8 && type != FFI_INT8)
  174.             goto error;
  175.         break;
  176.     case KTAP_TYPE_CDATA:
  177.         if (cs != cd_csym(ks, cdvalue(val)))
  178.             goto error;
  179.         break;
  180.     default:
  181.         goto error;
  182.     }
  183.     return 0;

  185. error:
  186.     return -1;
  187. }

  189. ‌static void kp_cdata_value(ktap_state_t *ks, ktap_val_t *val, void **out_addr,
  190.                size_t *out_size, void **temp)
  191. {
  192.     ktap_cdata_t *cd;
  193.     csymbol *cs;
  194.     ffi_type type;

  196.     switch (ttypenv(val)) {
  197.     case KTAP_TYPE_BOOLEAN:
  198.         *out_addr = &bvalue(val);
  199.         *out_size = sizeof(int);
  200.         return;
  201.     case KTAP_TYPE_LIGHTUSERDATA:
  202.         *out_addr = pvalue(val);
  203.         *out_size = sizeof(void *);
  204.         return;
  205.     case KTAP_TYPE_NUMBER:
  206.         *out_addr = &nvalue(val);
  207.         *out_size = sizeof(ktap_number);
  208.         return;
  209.     case KTAP_TYPE_STRING:
  210.         *temp = (void *)svalue(val);
  211.         *out_addr = temp;
  212.         *out_size = sizeof(void *);
  213.         return;
  214.     }

  216.     cd = cdvalue(val);
  217.     cs = cd_csym(ks, cd);
  218.     type = csym_type(cs);
  219.     *out_size = csym_size(ks, cs);
  220.     switch (type) {
  221.     case FFI_VOID:
  222.         kp_error(ks, "Error: Cannot copy data from void type\n");
  223.         return;
  224.     case FFI_UINT8:
  225.     case FFI_INT8:
  226.     case FFI_UINT16:
  227.     case FFI_INT16:
  228.     case FFI_UINT32:
  229.     case FFI_INT32:
  230.     case FFI_UINT64:
  231.     case FFI_INT64:
  232.         *out_addr = &cd_int(cd);
  233.         return;
  234.     case FFI_PTR:
  235.         *out_addr = &cd_ptr(cd);
  236.         return;
  237.     case FFI_STRUCT:
  238.     case FFI_UNION:
  239.         *out_addr = cd_record(cd);
  240.         return;
  241.     case FFI_FUNC:
  242.     case FFI_UNKNOWN:
  243.         kp_error(ks, "Error: internal error for csymbol %s\n",
  244.                 csym_name(cs));
  245.         return;
  246.     }
  247. }

  249. /* Check whether or not type is matched before unpacking */
  250. ‌void kp_cdata_unpack(ktap_state_t *ks, char *dst, csymbol *cs, ktap_val_t *val)
  251. {
  252.     size_t size = csym_size(ks, cs), val_size;
  253.     void *val_addr, *temp;

  255.     kp_cdata_value(ks, val, &val_addr, &val_size, &temp);
  256.     if (val_size > size)
  257.         val_size = size;
  258.     memmove(dst, val_addr, val_size);
  259.     memset(dst + val_size, 0, size - val_size);
  260. }

  262. /* Check whether or not type is matched before packing */
  263. ‌void kp_cdata_pack(ktap_state_t *ks, ktap_val_t *val, char *src, csymbol *cs)
  264. {
  265.     size_t size = csym_size(ks, cs), val_size;
  266.     void *val_addr, *temp;

  268.     kp_cdata_value(ks, val, &val_addr, &val_size, &temp);
  269.     if (size > val_size)
  270.         size = val_size;
  271.     memmove(val_addr, src, size);
  272.     memset(val_addr + size, 0, val_size - size);
  273. }

  275. /* Init its cdata type, but not its actual value */
  276. ‌static void kp_cdata_init(ktap_state_t *ks, ktap_val_t *val, void *addr, int len,
  277.               csymbol_id id)
  278. {
  279.     ffi_type type = csym_type(id_to_csym(ks, id));

  281.     switch (type) {
  282.     case FFI_PTR:
  283.         set_cdata(val, kp_cdata_new_ptr(ks, addr, len, id, 0));
  284.         break;
  285.     case FFI_STRUCT:
  286.     case FFI_UNION:
  287.         set_cdata(val, kp_cdata_new_record(ks, addr, id));
  288.         break;
  289.     case FFI_UINT8:
  290.     case FFI_INT8:
  291.     case FFI_UINT16:
  292.     case FFI_INT16:
  293.     case FFI_UINT32:
  294.     case FFI_INT32:
  295.     case FFI_UINT64:
  296.     case FFI_INT64:
  297.         /* set all these value into ktap_number(long) */
  298.         set_number(val, 0);
  299.         break;
  300.     default:
  301.         set_cdata(val, kp_cdata_new(ks, id));
  302.         break;
  303.     }
  304. }

  306. ‌void kp_cdata_ptr_set(ktap_state_t *ks, ktap_cdata_t *cd,
  307.               ktap_val_t *key, ktap_val_t *val)
  308. {
  309.     ktap_number idx;
  310.     csymbol *cs;
  311.     size_t size;
  312.     char *addr;

  314.     if (!is_number(key)) {
  315.         kp_error(ks, "array index should be number\n");
  316.         return;
  317.     }
  318.     idx = nvalue(key);
  319.     if (unlikely(idx < 0 || (cd_ptr_nmemb(cd) >= 0
  320.                     && idx >= cd_ptr_nmemb(cd)))) {
  321.         kp_error(ks, "array index out of bound\n");
  322.         return;
  323.     }

  325.     cs = csym_ptr_deref(ks, cd_csym(ks, cd));
  326.     if (kp_cdata_type_match(ks, cs, val)) {
  327.         kp_error(ks, "array member should be %s type\n", csym_name(cs));
  328.         return;
  329.     }
  330.     size = csym_size(ks, cs);
  331.     addr = cd_ptr(cd);
  332.     addr += size * idx;
  333.     kp_cdata_unpack(ks, addr, cs, val);
  334. }

  336. ‌void kp_cdata_ptr_get(ktap_state_t *ks, ktap_cdata_t *cd,
  337.               ktap_val_t *key, ktap_val_t *val)
  338. {
  339.     ktap_number idx;
  340.     csymbol *cs;
  341.     size_t size;
  342.     char *addr;
  343.     csymbol_id cs_id;

  345.     if (!is_number(key)) {
  346.         kp_error(ks, "array index should be number\n");
  347.         return;
  348.     }
  349.     idx = nvalue(key);
  350.     if (unlikely(idx < 0 || (cd_ptr_nmemb(cd) >= 0
  351.                     && idx >= cd_ptr_nmemb(cd)))) {
  352.         kp_error(ks, "array index out of bound\n");
  353.         return;
  354.     }

  356.     cs_id = csym_ptr_deref_id(cd_csym(ks, cd));
  357.     cs = id_to_csym(ks, cs_id);
  358.     size = csym_size(ks, cs);
  359.     addr = cd_ptr(cd);
  360.     addr += size * idx;

  362.     kp_cdata_init(ks, val, addr, -1, cs_id);
  363.     kp_cdata_pack(ks, val, addr, cs);
  364. }

  366. ‌void kp_cdata_record_set(ktap_state_t *ks, ktap_cdata_t *cd,
  367.              ktap_val_t *key, ktap_val_t *val)
  368. {
  369.     const char *mb_name;
  370.     csymbol *cs, *mb_cs;
  371.     csymbol_struct *csst;
  372.     struct_member *mb;
  373.     char *addr;

  375.     if (!is_shrstring(key)) {
  376.         kp_error(ks, "struct member name should be string\n");
  377.         return;
  378.     }
  379.     mb_name = svalue(key);
  380.     cs = cd_csym(ks, cd);
  381.     csst = csym_struct(cs);
  382.     mb = csymst_mb_by_name(ks, csst, mb_name);
  383.     if (mb == NULL) {
  384.         kp_error(ks, "struct member %s doesn't exist\n", mb_name);
  385.         return;
  386.     }

  388.     mb_cs = id_to_csym(ks, mb->id);
  389.     if (kp_cdata_type_match(ks, mb_cs, val)) {
  390.         kp_error(ks, "struct member should be %s type\n",
  391.                  csym_name(mb_cs));
  392.         return;
  393.     }

  395.     addr = cd_record(cd);
  396.     addr += csym_record_mb_offset_by_name(ks, cs, mb_name);
  397.     kp_cdata_unpack(ks, addr, mb_cs, val);
  398. }

  400. ‌void kp_cdata_record_get(ktap_state_t *ks, ktap_cdata_t *cd,
  401.              ktap_val_t *key, ktap_val_t *val)
  402. {
  403.     const char *mb_name;
  404.     csymbol *cs, *mb_cs;
  405.     csymbol_struct *csst;
  406.     struct_member *mb;
  407.     char *addr;
  408.     csymbol_id mb_cs_id;

  410.     if (!is_shrstring(key)) {
  411.         kp_error(ks, "struct member name should be string\n");
  412.         return;
  413.     }

  415.     mb_name = svalue(key);
  416.     cs = cd_csym(ks, cd);
  417.     csst = csym_struct(cs);
  418.     mb = csymst_mb_by_name(ks, csst, mb_name);
  419.     if (mb == NULL) {
  420.         kp_error(ks, "struct member %s doesn't exist\n", mb_name);
  421.         return;
  422.     }

  424.     mb_cs_id = mb->id;
  425.     mb_cs = id_to_csym(ks, mb_cs_id);
  426.     addr = cd_record(cd);
  427.     addr += csym_record_mb_offset_by_name(ks, cs, mb_name);

  429.     kp_cdata_init(ks, val, addr, mb->len, mb_cs_id);
  430.     if (mb->len < 0)
  431.         kp_cdata_pack(ks, val, addr, mb_cs);
  432. }

One Level Up Top Level