One Level Up Top Level

include/ktap_ffi.h - ktap

Data types defined

Macros defined

Source code

  1. #ifndef __KTAP_FFI_H__
  2. ‌#define __KTAP_FFI_H__

  4. #ifdef CONFIG_KTAP_FFI

  6. #include "../include/ktap_types.h"

  8. /*
  9. * Types design in FFI module
  10. *
  11. * ktap_cdata_t is an instance of csymbol, so it's a combination of csymbol
  12. * and it's actual data in memory.
  13. *
  14. * csymbol structs are globally unique and readonly type that represent C
  15. * types.  For non scalar C types like struct and function, helper structs are
  16. * used to store detailed information. See csymbol_func and csymbol_struct for
  17. * more information.
  18. */

  20. typedef enum {
  21.     /* 0 - 4 */
  22.     FFI_VOID,
  23.     FFI_UINT8,
  24.     FFI_INT8,
  25.     FFI_UINT16,
  26.     FFI_INT16,
  27.     /* 5 - 9 */
  28.     FFI_UINT32,
  29.     FFI_INT32,
  30.     FFI_UINT64,
  31.     FFI_INT64,
  32.     FFI_PTR,
  33.     /* 10 - 12 */
  34.     FFI_FUNC,
  35.     FFI_STRUCT,
  36.     FFI_UNION,
  37.     FFI_UNKNOWN,
  38. ‌} ffi_type;
  39. ‌#define NUM_FFI_TYPE ((int)FFI_UNKNOWN)


  42. /* following struct and macros are added for C typedef
  43. * size and alignment calculation */
  44. typedef struct {
  45.     size_t size;
  46.     size_t align;
  47.     const char *name;
  48. ‌} ffi_mode;
  49. extern const ffi_mode const ffi_type_modes[];

  51. ‌#define ffi_type_size(t) (ffi_type_modes[t].size)
  52. ‌#define ffi_type_align(t) (ffi_type_modes[t].align)
  53. ‌#define ffi_type_name(t) (ffi_type_modes[t].name)


  56. /* start of csymbol definition */
  57. ‌#define CSYM_NAME_MAX_LEN 64

  59. ‌typedef struct csymbol_func {
  60.     void *addr;        /* function address */
  61.     csymbol_id ret_id;    /* function return type */
  62.     int arg_nr;        /* number of arguments */
  63.     csymbol_id *arg_ids;    /* function argument types */
  64.     unsigned has_var_arg;    /* is this a var arg function? */
  65. ‌} csymbol_func;

  67. ‌typedef struct struct_member {
  68.     char name[CSYM_NAME_MAX_LEN];    /* name for this struct member */
  69.     csymbol_id id;            /* type for this struct member */
  70.     int len;                /* length of the array, -1 for non-array */
  71. ‌} struct_member;

  73. ‌typedef struct csymbol_struct {
  74.     int memb_nr;            /* number of members */
  75.     struct_member *members;        /* array for each member definition */
  76.     size_t size;            /* bytes used to store struct */
  77.     /* alignment of the struct, 0 indicates uninitialization */
  78.     size_t align;
  79. ‌} csymbol_struct;


  82. /* wrapper struct for all C symbols */
  83. ‌typedef struct csymbol {
  84.     char name[CSYM_NAME_MAX_LEN];    /* name for this symbol */
  85.     ffi_type type;            /* type for this symbol  */
  86.     /* following members are used only for non scalar C types */
  87.     union {
  88.         csymbol_id p;        /* pointer type */
  89.         csymbol_func f;        /* C function type */
  90.         csymbol_struct st;    /* struct/union type */
  91.         csymbol_id td;        /* typedef type */
  92.     } u;
  93. ‌} csymbol;


  96. /* helper macors for c symbols */
  97. ‌#define max_csym_id(ks) (G(ks)->ffis.csym_nr)

  99. /* lookup csymbol address by its id */
  100. inline csymbol *ffi_get_csym_by_id(ktap_state_t *ks, csymbol_id id);
  101. ‌#define id_to_csym(ks, id) (ffi_get_csym_by_id(ks, id))

  103. /* helper macros for struct csymbol */
  104. ‌#define csym_type(cs) ((cs)->type)
  105. ‌#define csym_name(cs) ((cs)->name)

  107. /*
  108. * helper macros for pointer symbol
  109. */
  110. ‌#define csym_ptr_deref_id(cs) ((cs)->u.p)
  111. ‌#define csym_set_ptr_deref_id(cs, id) ((cs)->u.p = (id))
  112. /* following macro gets csymbol address */
  113. ‌#define csym_ptr_deref(ks, cs) (id_to_csym(ks, csym_ptr_deref_id(cs)))

  115. /*
  116. * helper macros for function symbol
  117. * csym_* accepts csymbol type
  118. * csymf_* accepts csymbol_func type
  119. */
  120. ‌#define csymf_addr(csf) ((csf)->addr)
  121. ‌#define csymf_ret_id(csf) ((csf)->ret_id)
  122. ‌#define csymf_arg_nr(csf) ((csf)->arg_nr)
  123. ‌#define csymf_arg_ids(csf) ((csf)->arg_ids)
  124. /* get csymbol id for the nth argument */
  125. ‌#define csymf_arg_id(csf, n) ((csf)->arg_ids[n])
  126. ‌#define csym_func(cs) (&((cs)->u.f))
  127. ‌#define csym_func_addr(cs) (csymf_addr(csym_func(cs)))
  128. ‌#define csym_func_arg_ids(cs) (csymf_arg_ids(csym_func(cs)))
  129. /* following macros get csymbol address */
  130. ‌#define csymf_ret(ks, csf) (id_to_csym(ks, csymf_ret_id(csf)))
  131. /* get csymbol address for the nth argument */
  132. ‌#define csymf_arg(ks, csf, n) (id_to_csym(ks, csymf_arg_id(csf, n)))
  133. ‌#define csym_func_arg(ks, cs, n) (csymf_arg(ks, csym_func(cs), n))

  135. /*
  136. * helper macors for struct symbol
  137. * csym_* accepts csymbol type
  138. * csymst_* accepts csymbol_struct type
  139. */
  140. ‌#define csymst_mb_nr(csst) ((csst)->memb_nr)
  141. ‌#define csym_struct(cs) (&(cs)->u.st)
  142. ‌#define csym_struct_mb(cs, n) (csymst_mb(csym_struct(cs), n))
  143. ‌#define csym_struct_mb_nr(cs) (csymst_mb_nr(csym_struct(cs)))
  144. /* following macro gets csymbol address for the nth struct member */
  145. ‌#define csymst_mb(csst, n) (&(csst)->members[n])
  146. ‌#define csymst_mb_name(csst, n) ((csst)->members[n].name)
  147. ‌#define csymst_mb_id(csst, n) ((csst)->members[n].id)
  148. ‌#define csymst_mb_len(csst, n) ((csst)->members[n].len)
  149. ‌#define csymst_mb_csym(ks, csst, n) (id_to_csym(ks, (csst)->members[n].id))


  152. /*
  153. * helper macros for ktap_cdata_t type
  154. */
  155. ‌#define cd_csym_id(cd) ((cd)->id)
  156. ‌#define cd_set_csym_id(cd, id) (cd_csym_id(cd) = (id))
  157. ‌#define cd_csym(ks, cd) (id_to_csym(ks, cd_csym_id(cd)))
  158. ‌#define cd_type(ks, cd) (csym_type(cd_csym(ks, cd)))

  160. ‌#define cd_int(cd) ((cd)->u.i)
  161. ‌#define cd_ptr(cd) ((cd)->u.p.addr)
  162. ‌#define cd_ptr_nmemb(cd) ((cd)->u.p.nmemb)
  163. ‌#define cd_record(cd) ((cd)->u.rec)
  164. ‌#define cd_struct(cd) cd_record(cd)
  165. ‌#define cd_union(cd) cd_record(cd)

  167. #ifdef __KERNEL__
  168. size_t csym_size(ktap_state_t *ks, csymbol *sym);
  169. size_t csym_align(ktap_state_t *ks, csymbol *sym);
  170. size_t csym_record_mb_offset_by_name(ktap_state_t *ks,
  171.         csymbol *cs, const char *name);
  172. struct_member *csymst_mb_by_name(ktap_state_t *ks,
  173.         csymbol_struct *csst, const char *name);

  175. void ffi_free_symbols(ktap_state_t *ks);
  176. csymbol_id ffi_get_csym_id(ktap_state_t *ks, char *name);

  178. ktap_cdata_t *kp_cdata_new(ktap_state_t *ks, csymbol_id id);
  179. ktap_cdata_t *kp_cdata_new_ptr(ktap_state_t *ks, void *addr,
  180.         int nmemb, csymbol_id id, int to_allocate);
  181. ktap_cdata_t *kp_cdata_new_record(ktap_state_t *ks, void *val, csymbol_id id);
  182. void kp_cdata_dump(ktap_state_t *ks, ktap_cdata_t *cd);
  183. int kp_cdata_type_match(ktap_state_t *ks, csymbol *cs, ktap_val_t *val);
  184. void kp_cdata_unpack(ktap_state_t *ks, char *dst, csymbol *cs, ktap_val_t *val);
  185. void kp_cdata_ptr_set(ktap_state_t *ks, ktap_cdata_t *cd,
  186.         ktap_val_t *key, ktap_val_t *val);
  187. void kp_cdata_ptr_get(ktap_state_t *ks, ktap_cdata_t *cd,
  188.         ktap_val_t *key, ktap_val_t *val);
  189. void kp_cdata_record_set(ktap_state_t *ks, ktap_cdata_t *cd,
  190.          ktap_val_t *key, ktap_val_t *val);
  191. void kp_cdata_record_get(ktap_state_t *ks, ktap_cdata_t *cd,
  192.          ktap_val_t *key, ktap_val_t *val);

  194. int ffi_call(ktap_state_t *ks, csymbol_func *cf);

  196. #endif /* for CONFIG_FFI_KTAP */
  197. #endif /* for __KERNEL__ */
  198. #endif /* __KTAP_FFI_H__ */

One Level Up Top Level