One Level Up Top Level

userspace/ffi/ctype.c - ktap

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. #include "../../include/ktap_types.h"
  2. #include "../../include/ktap_opcodes.h"
  3. #include "../ktapc.h"
  4. #include "../cparser.h"


  7. /* for ktap vm */
  8. ‌cp_csymbol_state csym_state;

  10. ‌#define cs_nr (csym_state.cs_nr)
  11. ‌#define cs_arr_size (csym_state.cs_arr_size)
  12. ‌#define cs_arr (csym_state.cs_arr)

  14. ‌csymbol *cp_id_to_csym(int id)
  15. {
  16.     return &cs_arr[id];
  17. }


  20. ‌typedef struct cp_ctype_entry {
  21.     char name[MAX_TYPE_NAME_LEN];
  22.     struct cp_ctype ct;
  23. ‌} cp_ctype_entry;

  25. ‌#define DEFAULT_CTYPE_ARR_SIZE 100
  26. ‌static int cte_nr;
  27. ‌static int cte_arr_size;
  28. ‌static cp_ctype_entry *cte_arr;


  31. /* stack to help maintain state during parsing */
  32. ‌typedef struct cp_ctype_stack {
  33.     int size;
  34.     int top;
  35.     cp_ctype_entry *stack;
  36. ‌} ctype_stack;


  39. ‌static ctype_stack cts;

  41. ‌#define ct_stack(id) (&(cts.stack[id]))
  42. ‌#define ct_stack_ct(id) (&(cts.stack[id].ct))



  46. csymbol_id cp_ctype_reg_csymbol(csymbol *cs);
  47. csymbol_id ctype_lookup_csymbol_id(const char *name);


  50. ‌size_t ctype_size(const struct cp_ctype *ct)
  51. {
  52.     if (ct->pointers - ct->is_array) {
  53.         return sizeof(void*) * (ct->is_array ? ct->array_size : 1);

  55.     } else if (!ct->is_defined || ct->type == VOID_TYPE) {
  56.         cp_error("can't calculate size of an undefined type");
  57.         return 0;
  58.     } else if (ct->variable_size_known) {
  59.         assert(ct->is_variable_struct && !ct->is_array);
  60.         return ct->base_size + ct->variable_increment;
  61.     } else if (ct->is_variable_array || ct->is_variable_struct) {
  62.         cp_error("internal error: calc size of variable type with "
  63.                 "unknown size");
  64.         return 0;
  65.     } else {
  66.         return ct->base_size * (ct->is_array ? ct->array_size : 1);
  67.     }
  68. }

  70. ‌#define MAX_STACK_SIZE 100
  71. ‌int ctype_stack_grow(int size)
  72. {
  73.     struct cp_ctype_entry *new_st;

  75.     assert(cts.size + size < MAX_STACK_SIZE);

  77.     new_st = realloc(cts.stack, (cts.size+size)*sizeof(cp_ctype_entry));
  78.     if (new_st)
  79.         cts.stack = new_st;
  80.     else
  81.         return -1;

  83.     cts.size += size;

  85.     return size;
  86. }

  88. ‌int ctype_stack_free_space()
  89. {
  90.     return cts.size - cts.top;
  91. }

  93. ‌int ctype_stack_top()
  94. {
  95.     return cts.top;
  96. }

  98. ‌void ctype_stack_reset(int top)
  99. {
  100.     cts.top = top;
  101. }

  103. /* This function should be called before you would fetch
  104. * ffi_cs_id from ctype */
  105. ‌void cp_update_csym_in_ctype(struct cp_ctype *ct)
  106. {
  107.     int i;
  108.     struct cp_ctype *nct;

  110.     assert(ct->ffi_cs_id >= 0);
  111.     /* we have to check pointer here because cparser does type lookup by name
  112.      * before parsing '*', and for pointers, ct will always be the
  113.      * original type */
  114.     if (ct->pointers) {
  115.         for (i = 0; i < cte_nr; i++) {
  116.             nct = &(cte_arr[i].ct);
  117.             if (nct->type == ct->type &&
  118.                     ct->ffi_base_cs_id == nct->ffi_base_cs_id &&
  119.                     nct->pointers == ct->pointers) {
  120.                 break;
  121.             }
  122.         }

  124.         if (i == cte_nr) {
  125.             /* pointer type not found
  126.              * create a new pointer symbol for this type */
  127.             /* associate ctype with new csymbol */
  128.             ct->ffi_cs_id = cp_symbol_build_pointer(ct);
  129.             /* register wit new pointer name */
  130.             cp_ctype_reg_type(csym_name(ct_ffi_cs(ct)), ct);
  131.         } else {
  132.             /* pointer type already registered, reinstantiate ct */
  133.             ct->ffi_cs_id = cte_arr[i].ct.ffi_cs_id;
  134.         }
  135.     }
  136. }

  138. /* push ctype to stack, create new csymbol if needed */
  139. ‌void cp_push_ctype_with_name(struct cp_ctype *ct, const char *name, int nlen)
  140. {
  141.     if (ctype_stack_free_space() < 1)
  142.         ctype_stack_grow(4);

  144.     cp_update_csym_in_ctype(ct);
  145.     memset(ct_stack(cts.top), 0, sizeof(cp_ctype_entry));
  146.     ct_stack(cts.top)->ct = *ct;
  147.     if (name)
  148.         strncpy(ct_stack(cts.top)->name, name, nlen);
  149.     cts.top++;
  150. }

  152. ‌void cp_push_ctype(struct cp_ctype *ct)
  153. {
  154.     cp_push_ctype_with_name(ct, NULL, 0);
  155. }

  157. ‌void cp_set_defined(struct cp_ctype *ct)
  158. {
  159.     ct->is_defined = 1;

  161.     /* @TODO: update ctypes and cdatas that were created before the
  162.      * definition came in */
  163. }

  165. ‌void cp_ctype_dump_stack()
  166. {
  167.     int i;
  168.     struct cp_ctype *ct;

  170.     printf("---------------------------\n");
  171.     printf("start of ctype stack (%d) dump: \n", cts.top);
  172.     for (i = 0; i < cts.top; i++) {
  173.         ct = ct_stack_ct(i);
  174.         printf("[%d] -> cp_ctype: %d, sym_type: %d, pointer: %d "
  175.             "symbol_id: %d, name: %s\n",
  176.             i, ct->type,
  177.             csym_type(ct_ffi_cs(ct)), ct->pointers, ct->ffi_cs_id,
  178.             ct_stack(i)->name);
  179.     }
  180. }

  182. ‌int ctype_reg_table_grow()
  183. {
  184.     cp_ctype_entry *new_arr;

  186.     new_arr = realloc(cte_arr, sizeof(cp_ctype_entry)*cte_arr_size*2);
  187.     if (!new_arr)
  188.         cp_error("failed to allocate memory for ctype array\n");

  190.     cte_arr_size = cte_arr_size * 2;
  191.     return 0;
  192. }

  194. /* return index in csymbol array */
  195. ‌csymbol_id cp_ctype_reg_csymbol(csymbol *cs)
  196. {
  197.     if (cs_nr >= cs_arr_size) {
  198.         cs_arr_size *= 2;
  199.         cs_arr = realloc(cs_arr, cs_arr_size*sizeof(csymbol));
  200.         if (!cs_arr)
  201.             cp_error("failed to extend csymbol array!\n");
  202.     }

  204.     cs_arr[cs_nr] = *cs;
  205.     cs_nr++;

  207.     return cs_nr-1;
  208. }

  210. /* start csymbol reg table */
  211. ‌csymbol_id ctype_lookup_csymbol_id(const char *name)
  212. {
  213.     int i;
  214.     csymbol *ct;

  216.     for (i = 0; i < cs_nr; i++) {
  217.         ct = cp_id_to_csym(i);
  218.         if (!strcmp(name, ct->name))
  219.             return i;
  220.     }

  222.     return -1;
  223. }

  225. ‌void __cp_symbol_dump_struct(csymbol *cs)
  226. {
  227.     int i;
  228.     csymbol *ncs;
  229.     csymbol_struct *stcs = csym_struct(cs);

  231.     printf("=== [%s] definition ==================\n", csym_name(cs));
  232.     for (i = 0; i < stcs->memb_nr; i++) {
  233.         printf("\t(%d) ", i);
  234.         printf("csym_id: %d, ", stcs->members[i].id);
  235.         ncs = cp_id_to_csym(stcs->members[i].id);
  236.         printf("name: %s, ffi_ctype: %d, %s\n",
  237.             stcs->members[i].name, ncs->type, csym_name(ncs));
  238.     }
  239. }

  241. ‌void cp_symbol_dump_struct(int id)
  242. {
  243.     __cp_symbol_dump_struct(cp_id_to_csym(id));
  244. }

  246. ‌int cp_symbol_build_record(const char *stname, int type, int start_top)
  247. {
  248.     int i, id, memb_size;
  249.     cp_ctype_entry *cte;
  250.     csymbol nst;
  251.     struct_member *st_membs;
  252.     csymbol_struct *stcs;
  253.     struct cp_ctype *ct;

  255.     if (cts.top <= start_top || !stname ||
  256.             (type != STRUCT_TYPE && type != UNION_TYPE)) {
  257.         cp_error("invalid struct/union definition.\n");
  258.     }

  260.     id = ctype_lookup_csymbol_id(stname);
  261.     if (id >= 0) {
  262.         assert(cp_id_to_csym(id)->type == FFI_STRUCT ||
  263.                 cp_id_to_csym(id)->type == FFI_UNION);
  264.         assert(csym_struct(cp_id_to_csym(id))->memb_nr == -1);
  265.     }

  267.     memb_size = cts.top - start_top;
  268.     st_membs = malloc(memb_size*sizeof(struct_member));
  269.     if (!st_membs)
  270.         cp_error("failed to allocate memory for struct members.\n");
  271.     memset(st_membs, 0, memb_size*sizeof(struct_member));

  273.     if (type == STRUCT_TYPE)
  274.         nst.type = FFI_STRUCT;
  275.     else
  276.         nst.type = FFI_UNION;
  277.     strcpy(nst.name, stname);

  279.     stcs = csym_struct(&nst);
  280.     stcs->align = 0;
  281.     stcs->memb_nr = memb_size;
  282.     stcs->members = st_membs;

  284.     for (i = 0; i < memb_size; i++) {
  285.         cte = ct_stack(i + start_top);
  286.         if (cte->name)
  287.             strcpy(st_membs[i].name, cte->name);
  288.         ct = ct_stack_ct(i + start_top);
  289.         st_membs[i].id = ct->ffi_cs_id;
  290.         if (!ct->is_array)
  291.             st_membs[i].len = -1;
  292.         else
  293.             st_membs[i].len = ct->array_size;
  294.     }

  296.     if (id < 0)
  297.         id = cp_ctype_reg_csymbol(&nst);
  298.     else
  299.         cs_arr[id] = nst;

  301.     ctype_stack_reset(start_top);

  303.     return id;
  304. }

  306. ‌int cp_symbol_build_fake_record(const char *stname, int type)
  307. {
  308.     int id;
  309.     csymbol nst;
  310.     csymbol_struct *stcs;

  312.     if (!stname || (type != STRUCT_TYPE && type != UNION_TYPE)) {
  313.         cp_error("invalid fake struct/union definition.\n");
  314.     }

  316.     id = ctype_lookup_csymbol_id(stname);
  317.     if (id >= 0)
  318.         return id;

  320.     if (type == STRUCT_TYPE)
  321.         nst.type = FFI_STRUCT;
  322.     else
  323.         nst.type = FFI_UNION;
  324.     strcpy(nst.name, stname);

  326.     stcs = csym_struct(&nst);
  327.     stcs->align = 0;
  328.     stcs->memb_nr = -1;
  329.     stcs->members = NULL;

  331.     id = cp_ctype_reg_csymbol(&nst);

  333.     return id;
  334. }


  337. /* build pointer symbol from given csymbol */
  338. ‌int cp_symbol_build_pointer(struct cp_ctype *ct)
  339. {
  340.     int id, ret;
  341.     csymbol ncspt;
  342.     csymbol *ref_cs = ct_ffi_cs(ct);

  344.     /* TODO: Check correctness of multi-level pointer 24.11.2013(unihorn) */
  345.     memset(&ncspt, 0, sizeof(csymbol));
  346.     ncspt.type = FFI_PTR;
  347.     ret = sprintf(ncspt.name, "%s *", csym_name(ref_cs));
  348.     assert(ret < MAX_TYPE_NAME_LEN);

  350.     csym_set_ptr_deref_id(&ncspt, ct->ffi_cs_id);
  351.     id = cp_ctype_reg_csymbol(&ncspt);

  353.     return id;
  354. }

  356. ‌void __cp_symbol_dump_func(csymbol *cs)
  357. {
  358.     int i;
  359.     csymbol *ncs;
  360.     csymbol_func *fcs = csym_func(cs);

  362.     printf("=== [%s] function definition =============\n", csym_name(cs));
  363.     ncs = cp_csymf_ret(fcs);
  364.     printf("address: %p\n", fcs->addr);
  365.     printf("return type: \n");
  366.     printf("\tcsym_id: %d, ffi_ctype: %d, %s\n",
  367.             fcs->ret_id, ncs->type, csym_name(ncs));
  368.     printf("args type (%d): \n", fcs->arg_nr);
  369.     for (i = 0; i < csymf_arg_nr(fcs); i++) {
  370.         printf("\t (%d) ", i);
  371.         printf("csym_id: %d, ", fcs->arg_ids[i]);
  372.         ncs = cp_csymf_arg(fcs, i);
  373.         printf("ffi_ctype: %d, %s\n", ncs->type, csym_name(ncs));
  374.     }
  375. }

  377. ‌void cp_symbol_dump_func(int id)
  378. {
  379.     __cp_symbol_dump_func(cp_id_to_csym(id));
  380. }

  382. ‌int cp_symbol_build_func(struct cp_ctype *type, const char *fname, int fn_size)
  383. {
  384.     int i = 1, arg_nr, id;
  385.     int *argsym_id_arr;
  386.     csymbol nfcs;
  387.     csymbol_func *fcs;

  389.     if (cts.top == 0 || fn_size < 0 || !fname) {
  390.         cp_error("invalid function definition.\n");
  391.     }

  393.     argsym_id_arr = NULL;
  394.     memset(&nfcs, 0, sizeof(csymbol));
  395.     csym_type(&nfcs) = FFI_FUNC;

  397.     strncpy(csym_name(&nfcs), fname, fn_size);

  399.     fcs = csym_func(&nfcs);
  400.     fcs->has_var_arg = type->has_var_arg;
  401.     /* Type needed for handling variable args handle */
  402.     if (fcs->has_var_arg && !ctype_lookup_type("void *"))
  403.         cp_symbol_build_pointer(ctype_lookup_type("void"));

  405.     /* Fetch start address of function  */
  406.     fcs->addr = (void *)find_kernel_symbol(csym_name(&nfcs));
  407.     if (!fcs->addr)
  408.         cp_error("wrong function address for %s\n", csym_name(&nfcs));

  410.     /* bottom of the stack is return type */
  411.     fcs->ret_id = ct_stack_ct(0)->ffi_cs_id;

  413.     /* the rest is argument type */
  414.     if (cts.top == 1) {
  415.         /* function takes no argument */
  416.         arg_nr = 0;
  417.     } else {
  418.         arg_nr = cts.top - 1;
  419.         argsym_id_arr = malloc(arg_nr * sizeof(int));
  420.         if (!argsym_id_arr)
  421.             cp_error("failed to allocate memory for function args.\n");
  422.         for (i = 0; i < arg_nr; i++) {
  423.             argsym_id_arr[i] = ct_stack_ct(i+1)->ffi_cs_id;
  424.         }
  425.     }
  426.     fcs->arg_nr = arg_nr;
  427.     fcs->arg_ids = argsym_id_arr;

  429.     id = cp_ctype_reg_csymbol(&nfcs);

  431.     /* clear stack since we have consumed all the ctypes */
  432.     ctype_stack_reset(0);

  434.     return id;
  435. }

  437. ‌struct cp_ctype *cp_ctype_reg_type(char *name, struct cp_ctype *ct)
  438. {
  439.     if (cte_nr >= cte_arr_size)
  440.         ctype_reg_table_grow();

  442.     memset(cte_arr[cte_nr].name, 0, MAX_TYPE_NAME_LEN);
  443.     strcpy(cte_arr[cte_nr].name, name);

  445.     cte_arr[cte_nr].ct = *ct;
  446.     cte_nr++;

  448.     return &(cte_arr[cte_nr-1].ct);
  449. }

  451. #if 0
  452. /* TODO: used for size calculation */
  453. static ffi_type ffi_int_type(ktap_state *ks, int size, bool sign)
  454. {
  455.     switch(size) {
  456.     case 1:
  457.         if (!sign)
  458.             return FFI_UINT8;
  459.         else
  460.             return FFI_INT8;
  461.     case 2:
  462.         if (!sign)
  463.             return FFI_UINT16;
  464.         else
  465.             return FFI_INT16;
  466.     case 4:
  467.         if (!sign)
  468.             return FFI_UINT32;
  469.         else
  470.             return FFI_INT32;
  471.     case 8:
  472.         if (!sign)
  473.             return FFI_UINT64;
  474.         else
  475.             return FFI_INT64;
  476.     default:
  477.         kp_error(ks, "Error: Have not support int type of size %d\n", size);
  478.         return FFI_UNKNOWN;
  479.     }

  481.     /* NEVER reach here, silence compiler */
  482.     return -1;
  483. }
  484. #endif


  487. ‌static inline void ct_set_type(struct cp_ctype *ct, int type, int is_unsigned)
  488. {
  489.     ct->type = type;
  490.     ct->is_unsigned = is_unsigned;
  491. }

  493. ‌static void init_builtin_type(struct cp_ctype *ct, ffi_type ftype)
  494. {
  495.     csymbol cs;
  496.     int cs_id;

  498.     csym_type(&cs) = ftype;
  499.     strncpy(csym_name(&cs), ffi_type_name(ftype), CSYM_NAME_MAX_LEN);
  500.     cs_id = cp_ctype_reg_csymbol(&cs);

  502.     memset(ct, 0, sizeof(*ct));
  503.     ct->ffi_base_cs_id = ct->ffi_cs_id = cs_id;
  504.     switch (ftype) {
  505.     case FFI_VOID:        ct_set_type(ct, VOID_TYPE, 0); break;
  506.     case FFI_UINT8:        ct_set_type(ct, INT8_TYPE, 1); break;
  507.     case FFI_INT8:        ct_set_type(ct, INT8_TYPE, 0); break;
  508.     case FFI_UINT16:    ct_set_type(ct, INT16_TYPE, 1); break;
  509.     case FFI_INT16:        ct_set_type(ct, INT16_TYPE, 0); break;
  510.     case FFI_UINT32:    ct_set_type(ct, INT32_TYPE, 1); break;
  511.     case FFI_INT32:        ct_set_type(ct, INT32_TYPE, 0); break;
  512.     case FFI_UINT64:    ct_set_type(ct, INT64_TYPE, 1); break;
  513.     case FFI_INT64:        ct_set_type(ct, INT64_TYPE, 0); break;
  514.     default:        break;
  515.     }
  516.     ct->base_size = ffi_type_size(ftype);
  517.     ct->align_mask = ffi_type_align(ftype) - 1;
  518.     ct->is_defined = 1;
  519. }

  521. /*
  522. * lookup and register builtin C type on demand
  523. * You should ensure that the type with name doesn't appear in
  524. * csymbol table before calling.
  525. */
  526. ‌struct cp_ctype *ctype_lookup_builtin_type(char *name)
  527. {
  528.     struct cp_ctype ct;

  530.     if (!strncmp(name, "void", sizeof("void"))) {
  531.         init_builtin_type(&ct, FFI_VOID);
  532.         return cp_ctype_reg_type("void", &ct);
  533.     } else if (!strncmp(name, "int8_t", sizeof("int8_t"))) {
  534.         init_builtin_type(&ct, FFI_INT8);
  535.         return cp_ctype_reg_type("int8_t", &ct);
  536.     } else if (!strncmp(name, "uint8_t", sizeof("uint8_t"))) {
  537.         init_builtin_type(&ct, FFI_UINT8);
  538.         return cp_ctype_reg_type("uint8_t", &ct);
  539.     } else if (!strncmp(name, "int16_t", sizeof("int16_t"))) {
  540.         init_builtin_type(&ct, FFI_INT16);
  541.         return cp_ctype_reg_type("int16_t", &ct);
  542.     } else if (!strncmp(name, "uint16_t", sizeof("uint16_t"))) {
  543.         init_builtin_type(&ct, FFI_UINT16);
  544.         return cp_ctype_reg_type("uint16_t", &ct);
  545.     } else if (!strncmp(name, "int32_t", sizeof("int32_t"))) {
  546.         init_builtin_type(&ct, FFI_INT32);
  547.         return cp_ctype_reg_type("int32_t", &ct);
  548.     } else if (!strncmp(name, "uint32_t", sizeof("uint32_t"))) {
  549.         init_builtin_type(&ct, FFI_UINT32);
  550.         return cp_ctype_reg_type("uint32_t", &ct);
  551.     } else if (!strncmp(name, "int64_t", sizeof("int64_t"))) {
  552.         init_builtin_type(&ct, FFI_INT64);
  553.         return cp_ctype_reg_type("int64_t", &ct);
  554.     } else if (!strncmp(name, "uint64_t", sizeof("uint64_t"))) {
  555.         init_builtin_type(&ct, FFI_UINT64);
  556.         return cp_ctype_reg_type("uint64_t", &ct);
  557.     } else {
  558.         /* no builtin type matched */
  559.         return NULL;
  560.     }
  561. }

  563. /* start ctype reg table */
  564. ‌struct cp_ctype *ctype_lookup_type(char *name)
  565. {
  566.     int i;
  567.     struct cp_ctype *ct;

  569.     for (i = 0; i < cte_nr; i++) {
  570.         ct = &cte_arr[i].ct;
  571.         if (!strcmp(name, cte_arr[i].name))
  572.             return ct;
  573.     }

  575.     /* see if it's a builtin C type
  576.      * return NULL if still no match */
  577.     return ctype_lookup_builtin_type(name);
  578. }

  580. ‌cp_csymbol_state *ctype_get_csym_state(void)
  581. {
  582.     return &csym_state;
  583. }

  585. ‌#define DEFAULT_STACK_SIZE 20
  586. ‌#define DEFAULT_SYM_ARR_SIZE 20
  587. ‌int cp_ctype_init()
  588. {
  589.     cts.size = DEFAULT_STACK_SIZE;
  590.     cts.top = 0;
  591.     cts.stack = malloc(sizeof(cp_ctype_entry)*DEFAULT_STACK_SIZE);

  593.     cs_nr = 0;
  594.     cs_arr_size = DEFAULT_SYM_ARR_SIZE;
  595.     cs_arr = malloc(sizeof(csymbol)*DEFAULT_SYM_ARR_SIZE);
  596.     memset(cs_arr, 0, sizeof(csymbol)*DEFAULT_SYM_ARR_SIZE);

  598.     cte_nr = 0;
  599.     cte_arr_size = DEFAULT_CTYPE_ARR_SIZE;
  600.     cte_arr = malloc(sizeof(cp_ctype_entry)*DEFAULT_CTYPE_ARR_SIZE);

  602.     return 0;
  603. }

  605. ‌int cp_ctype_free()
  606. {
  607.     int i;
  608.     csymbol *cs;

  610.     if (cts.stack)
  611.         free(cts.stack);

  613.     if (cs_arr) {
  614.         for (i = 0; i < cs_nr; i++) {
  615.             cs = cp_id_to_csym(i);
  616.             if (csym_type(cs) == FFI_FUNC) {
  617.                 if (csym_func(cs)->arg_ids)
  618.                     free(csym_func(cs)->arg_ids);
  619.             } else if (csym_type(cs) == FFI_STRUCT) {
  620.                 if (csym_struct(cs)->members)
  621.                     free(csym_struct(cs)->members);
  622.             }
  623.         }
  624.         free(cs_arr);
  625.     }

  627.     if (cte_arr) {
  628.         free(cte_arr);
  629.     }

  631.     return 0;
  632. }

One Level Up Top Level