One Level Up Top Level

test/ffi_test/cparser_test.c - ktap

Global variables defined

Functions defined

Macros defined

Source code

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <assert.h>

  6. #include "ktap_types.h"
  7. #include "ktap_opcodes.h"
  8. #include "../../userspace/ktapc.h"
  9. #include "cparser.h"

  11. void ffi_cparser_init(void);
  12. void ffi_cparser_free(void);
  13. int ffi_parse_cdef(const char *s);

  15. ‌static cp_csymbol_state *csym_state;

  17. ‌#define cs_nr (csym_state->cs_nr)
  18. ‌#define cs_arr_size (csym_state->cs_arr_size)
  19. ‌#define cs_arr (csym_state->cs_arr)


  22. ‌#define DO_TEST(name) do {                    \
  23.     ffi_cparser_init();                    \
  24.     int ret;                        \
  25.     printf("[*] start "#name" test...  ");            \
  26.     ret = test_##name();                    \
  27.     if (ret)                        \
  28.         fprintf(stderr, "\n[!] "#name" test failed.\n");\
  29.     else                            \
  30.         printf(" passed.\n");                \
  31.     ffi_cparser_free();                    \
  32. } while (0)

  34. ‌#define assert_csym_arr_type(cs_arr, n, t) do {            \
  35.     csymbol *ncs;                        \
  36.     ncs = &cs_arr[n];                    \
  37.     assert(ncs->type == t);                    \
  38. } while (0)

  40. ‌#define assert_fret_type(fcs, t) do {                \
  41.     csymbol *ncs;                        \
  42.     ncs = &cs_arr[fcs->ret_id];                \
  43.     assert(ncs->type == t);                    \
  44. } while (0)

  46. ‌#define assert_farg_type(fcs, n, t) do {            \
  47.     csymbol *ncs;                        \
  48.     ncs = &cs_arr[fcs->arg_ids[n]];                \
  49.     assert(ncs->type == t);                    \
  50. } while (0)




  55. /* mock find_kernel_symbol */
  56. ‌unsigned long find_kernel_symbol(const char *symbol)
  57. {
  58.     return 0xdeadbeef;
  59. }

  61. ‌int lookup_csymbol_id_by_name(char *name)
  62. {
  63.     int i;

  65.     for (i = 0; i < cs_nr; i++) {
  66.         if (!strcmp(name, cs_arr[i].name)) {
  67.             return i;
  68.         }
  69.     }

  71.     return -1;
  72. }

  74. ‌int test_func_sched_clock()
  75. {
  76.     int idx;
  77.     csymbol *cs;
  78.     csymbol_func *fcs;

  80.     ffi_parse_cdef("unsigned long long sched_clock();");

  82.     csym_state = ctype_get_csym_state();
  83.     assert(cs_arr);

  85.     idx = lookup_csymbol_id_by_name("sched_clock");
  86.     assert(idx >= 0);
  87.     cs = &cs_arr[idx];
  88.     assert(cs->type == FFI_FUNC);

  90.     fcs = csym_func(cs);

  92.     /* check return type */
  93.     assert_fret_type(fcs, FFI_UINT64);

  95.     /* check arguments */
  96.     assert(fcs->arg_nr == 0);

  98.     return 0;
  99. }

  101. ‌int test_func_funct_module()
  102. {
  103.     int idx;
  104.     csymbol *cs;
  105.     csymbol_func *fcs;

  107.     ffi_parse_cdef("void funct_void();");
  108.     ffi_parse_cdef("int funct_int1(unsigned char a, char b, unsigned short c, "
  109.             "short d);");
  110.     ffi_parse_cdef("long long funct_int2(unsigned int a, int b, "
  111.             "unsigned long c, long d, unsigned long long e, "
  112.             "long long f, long long g);");
  113.     ffi_parse_cdef("void *funct_pointer1(char *a);");

  115.     csym_state = ctype_get_csym_state();
  116.     assert(cs_arr);

  118.     /* check funct_void function */
  119.     idx = lookup_csymbol_id_by_name("funct_void");
  120.     assert(idx >= 0);
  121.     cs = &cs_arr[idx];
  122.     assert(cs->type == FFI_FUNC);
  123.     fcs = csym_func(cs);

  125.     /* check return type */
  126.     assert_fret_type(fcs, FFI_VOID);

  128.     /* check arguments */
  129.     assert(fcs->arg_nr == 0);



  133.     /* check funct_int1 function */
  134.     idx = lookup_csymbol_id_by_name("funct_int1");
  135.     assert(idx >= 0);
  136.     cs = &cs_arr[idx];
  137.     assert(cs);
  138.     assert(cs->type == FFI_FUNC);
  139.     fcs = csym_func(cs);

  141.     /* check return type */
  142.     assert_fret_type(fcs, FFI_INT32);

  144.     /* check arguments */
  145.     assert(fcs->arg_nr == 4);
  146.     assert_farg_type(fcs, 0, FFI_UINT8);
  147.     assert_farg_type(fcs, 1, FFI_INT8);
  148.     assert_farg_type(fcs, 2, FFI_UINT16);
  149.     assert_farg_type(fcs, 3, FFI_INT16);



  153.     /* check funct_int2 function */
  154.     idx = lookup_csymbol_id_by_name("funct_int2");
  155.     assert(idx >= 0);
  156.     cs = &cs_arr[idx];
  157.     assert(cs);
  158.     assert(cs->type == FFI_FUNC);
  159.     fcs = csym_func(cs);

  161.     /* check return type */
  162.     assert_fret_type(fcs, FFI_INT64);

  164.     /* check arguments */
  165.     assert(fcs->arg_nr == 7);
  166.     assert_farg_type(fcs, 0, FFI_UINT32);
  167.     assert_farg_type(fcs, 1, FFI_INT32);
  168.     assert_farg_type(fcs, 2, FFI_UINT64);
  169.     assert_farg_type(fcs, 3, FFI_INT64);
  170.     assert_farg_type(fcs, 4, FFI_UINT64);
  171.     assert_farg_type(fcs, 5, FFI_INT64);
  172.     assert_farg_type(fcs, 6, FFI_INT64);



  176.     /* check funct_pointer1 function */
  177.     idx = lookup_csymbol_id_by_name("funct_pointer1");
  178.     assert(idx >= 0);
  179.     cs = &cs_arr[idx];
  180.     assert(cs);
  181.     assert(cs->type == FFI_FUNC);
  182.     fcs = csym_func(cs);

  184.     /* check return type */
  185.     assert_fret_type(fcs, FFI_PTR);

  187.     /* check arguments */
  188.     assert(fcs->arg_nr == 1);
  189.     assert_farg_type(fcs, 0, FFI_PTR);
  190.     /*@TODO check pointer dereference type  18.11 2013 (houqp)*/

  192.     return 0;
  193. }

  195. ‌int test_struct_timespec()
  196. {
  197.     int idx;
  198.     csymbol *cs;
  199.     csymbol_struct *stcs;

  201.     ffi_parse_cdef("struct timespec { long ts_sec; long ts_nsec; };");

  203.     csym_state = ctype_get_csym_state();
  204.     assert(cs_arr);

  206.     idx = lookup_csymbol_id_by_name("struct timespec");
  207.     assert(idx >= 0);
  208.     cs = &cs_arr[idx];
  209.     assert(cs);
  210.     assert(cs->type == FFI_STRUCT);

  212.     stcs = csym_struct(cs);
  213.     assert(stcs->memb_nr == 2);

  215.     return 0;
  216. }

  218. ‌int test_func_time_to_tm()
  219. {
  220.     int idx;
  221.     csymbol *cs, *arg_cs;
  222.     csymbol_struct *stcs;
  223.     csymbol_func *fcs;

  225.     ffi_parse_cdef("typedef long time_t;");
  226.     ffi_parse_cdef("struct tm { "
  227.             "int tm_sec;"
  228.             "int tm_min;"
  229.             "int tm_hour;"
  230.             "int tm_mday;"
  231.             "int tm_mon;"
  232.             "long tm_year;"
  233.             "int tm_wday;"
  234.             "int tm_yday;"
  235.         "};");
  236.     ffi_parse_cdef("void time_to_tm(time_t totalsecs, int offset, struct tm *result);");

  238.     csym_state = ctype_get_csym_state();
  239.     assert(cs_arr);

  241.     idx = lookup_csymbol_id_by_name("struct tm");
  242.     assert(idx >= 0);
  243.     cs = cp_id_to_csym(idx);
  244.     assert(cs);
  245.     assert(cs->type == FFI_STRUCT);

  247.     stcs = csym_struct(cs);
  248.     assert(stcs->memb_nr == 8);


  251.     idx = lookup_csymbol_id_by_name("time_to_tm");
  252.     assert(idx >= 0);
  253.     cs = cp_id_to_csym(idx);
  254.     assert(cs);
  255.     assert(cs->type == FFI_FUNC);

  257.     fcs = csym_func(cs);
  258.     assert(csymf_arg_nr(fcs) == 3);
  259.     /* check first argument */
  260.     assert_farg_type(fcs, 0, FFI_INT64);

  262.     /* check second argument */
  263.     assert_farg_type(fcs, 1, FFI_INT32);
  264.     /* check third argument */
  265.     assert_farg_type(fcs, 2, FFI_PTR);
  266.     arg_cs = cp_csymf_arg(fcs, 2);
  267.     assert(!strcmp(csym_name(arg_cs), "struct tm *"));
  268.     assert(csym_ptr_deref_id(arg_cs) ==
  269.             lookup_csymbol_id_by_name("struct tm"));

  271.     return 0;
  272. }

  274. ‌int test_pointer_symbols()
  275. {
  276.     csymbol_func *fcs_foo, *fcs_bar;

  278.     /* int pointer symbol should be resolved to the same id */
  279.     ffi_parse_cdef("void foo(int *a);");
  280.     ffi_parse_cdef("int *bar(void);");

  282.     csym_state = ctype_get_csym_state();
  283.     assert(cs_arr);

  285.     fcs_foo = csym_func(cp_id_to_csym(lookup_csymbol_id_by_name("foo")));
  286.     fcs_bar = csym_func(cp_id_to_csym(lookup_csymbol_id_by_name("bar")));

  288.     assert(csymf_arg_ids(fcs_foo)[0] == csymf_ret_id(fcs_bar));
  289.     assert(cp_csymf_arg(fcs_foo, 0) == cp_csymf_ret(fcs_bar));

  291.     return 0;
  292. }

  294. ‌int test_var_arg_function()
  295. {
  296.     csymbol_func *fcs;

  298.     ffi_parse_cdef("int printk(char *fmt, ...);");

  300.     fcs = csym_func(cp_id_to_csym(lookup_csymbol_id_by_name("printk")));

  302.     /* var arg function needs void * type argument type checking */
  303.     assert(lookup_csymbol_id_by_name("void *") >= 0);

  305.     assert_fret_type(fcs, FFI_INT32);
  306.     assert_farg_type(fcs, 0, FFI_PTR);
  307.     assert(fcs->has_var_arg);

  309.     return 0;
  310. }

  312. ‌int main (int argc, char *argv[])
  313. {
  314.     DO_TEST(func_sched_clock);
  315.     DO_TEST(func_funct_module);
  316.     DO_TEST(struct_timespec);
  317.     DO_TEST(func_time_to_tm);
  318.     DO_TEST(pointer_symbols);
  319.     DO_TEST(var_arg_function);

  321.     return 0;
  322. }

One Level Up Top Level