1 /******************************************************************************
4 * Event generator. XML to logging C code converter.
9 * Will generate ltt-facility-name.h, ltt-facility-id-name.h
10 * ltt-facility-loader-name.c, ltt-facility-loader-name.h
11 * in the current directory.
15 * - C types : struct, union, enum, basic types.
16 * - Architectures : LP32, ILP32, ILP64, LLP64, LP64.
18 * Additionnal structures supported :
19 * - embedded variable size strings
20 * - embedded variable size arrays
21 * - embedded variable size sequences
25 * enums are limited to integer type, as this is what is used in C. Note,
26 * however, that ISO/IEC 9899:TC2 specify that the type of enum can be char,
27 * unsigned int or int. This is implementation defined (compiler). That's why we
28 * add a check for sizeof enum.
31 * Because of archtecture defined type sizes, we need to ask for ltt_align
32 * (which gives the alignment) by passing basic types, not their actual sizes.
33 * It's up to ltt_align to determine sizes of types.
36 * http://www.usenix.org/publications/login/standards/10.data.html
37 * (Andrew Josey <a.josey@opengroup.org>) :
39 * Data Type LP32 ILP32 ILP64 LLP64 LP64
41 * short 16 16 16 16 16
45 * long long (int64) 64
46 * pointer 32 32 64 64 64
48 * With these constraints :
49 * sizeof(char) <= sizeof(short) <= sizeof(int)
50 * <= sizeof(long) = sizeof(size_t)
52 * and therefore sizeof(long) <= sizeof(pointer) <= sizeof(size_t)
54 * Which means we only have to remember which is the biggest type in a structure
55 * to know the structure's alignment.
62 #include <sys/types.h>
77 /* Debugging printf */
79 #define dprintf(...) \
81 printf(__FILE__ ",%u,%s: ",\
89 void preset_field_type_size(event_t
*event_type
,
90 off_t offset_root
, off_t offset_parent
,
91 enum field_status
*fixed_root
, enum field_status
*fixed_parent
,
96 void print_tabs(unsigned int tabs
, FILE *fd
)
98 for(unsigned int i
= 0; i
<tabs
;i
++)
102 /* Type size checking */
103 /* Uses #error in the generated code to signal error and stop the compiler */
104 int print_check(int fd
);
109 * Copied from construct_types_and_fields in LTTV facility.c */
111 int print_type(type_descriptor_t
* td
, FILE *fd
, unsigned int tabs
,
112 char *nest_name
, char *field_name
)
114 char basename
[PATH_MAX
];
115 unsigned int basename_len
= 0;
117 strcpy(basename
, nest_name
);
118 basename_len
= strlen(basename
);
120 /* For a named type, we use the type_name directly */
121 if(td
->type_name
!= NULL
) {
122 strncpy(basename
, td
->type_name
, PATH_MAX
);
123 basename_len
= strlen(basename
);
125 /* For a unnamed type, there must be a field name */
126 if((basename_len
!= 0)
127 && (basename
[basename_len
-1] != '_')
128 && (field_name
[0] != '\0')) {
129 strncat(basename
, "_", PATH_MAX
- basename_len
);
130 basename_len
= strlen(basename
);
132 strncat(basename
, field_name
, PATH_MAX
- basename_len
);
137 fprintf(fd
, "%s", intOutputTypes
[getSizeindex(td
->size
)]);
140 fprintf(fd
, "%s", uintOutputTypes
[getSizeindex(td
->size
)]);
143 fprintf(fd
, "signed char");
146 fprintf(fd
, "unsigned char");
149 fprintf(fd
, "short");
152 fprintf(fd
, "unsigned short");
158 fprintf(fd
, "unsigned int");
161 fprintf(fd
, "%s", floatOutputTypes
[getSizeindex(td
->size
)]);
164 fprintf(fd
, "void *");
170 fprintf(fd
, "unsigned long");
173 fprintf(fd
, "size_t");
176 fprintf(fd
, "ssize_t");
179 fprintf(fd
, "off_t");
182 fprintf(fd
, "char *");
185 fprintf(fd
, "enum lttng_%s", basename
);
188 fprintf(fd
, "lttng_array_%s", basename
);
191 fprintf(fd
, "lttng_sequence_%s", basename
);
194 fprintf(fd
, "struct lttng_%s", basename
);
197 fprintf(fd
, "union lttng_%s", basename
);
200 printf("print_type : unknown type\n");
207 /* Print logging function argument */
208 int print_arg(type_descriptor_t
* td
, FILE *fd
, unsigned int tabs
,
209 char *nest_name
, char *field_name
)
211 char basename
[PATH_MAX
];
212 unsigned int basename_len
= 0;
214 strcpy(basename
, nest_name
);
215 basename_len
= strlen(basename
);
217 /* For a named type, we use the type_name directly */
218 if(td
->type_name
!= NULL
) {
219 strncpy(basename
, td
->type_name
, PATH_MAX
);
220 basename_len
= strlen(basename
);
222 /* For a unnamed type, there must be a field name */
223 if((basename_len
!= 0)
224 && (basename
[basename_len
-1] != '_')
225 && (field_name
[0] != '\0')) {
226 strncat(basename
, "_", PATH_MAX
- basename_len
);
227 basename_len
= strlen(basename
);
229 strncat(basename
, field_name
, PATH_MAX
- basename_len
);
232 print_tabs(tabs
, fd
);
236 fprintf(fd
, "%s", intOutputTypes
[getSizeindex(td
->size
)]);
237 fprintf(fd
, " %s", field_name
);
240 fprintf(fd
, "%s", uintOutputTypes
[getSizeindex(td
->size
)]);
241 fprintf(fd
, " %s", field_name
);
244 fprintf(fd
, "signed char");
245 fprintf(fd
, " %s", field_name
);
248 fprintf(fd
, "unsigned char");
249 fprintf(fd
, " %s", field_name
);
252 fprintf(fd
, "short");
253 fprintf(fd
, " %s", field_name
);
256 fprintf(fd
, "unsigned short");
257 fprintf(fd
, " %s", field_name
);
261 fprintf(fd
, " %s", field_name
);
264 fprintf(fd
, "unsigned int");
265 fprintf(fd
, " %s", field_name
);
268 fprintf(fd
, "%s", floatOutputTypes
[getSizeindex(td
->size
)]);
269 fprintf(fd
, " %s", field_name
);
272 fprintf(fd
, "void *");
273 fprintf(fd
, " %s", field_name
);
277 fprintf(fd
, " %s", field_name
);
280 fprintf(fd
, "unsigned long");
281 fprintf(fd
, " %s", field_name
);
284 fprintf(fd
, "size_t");
285 fprintf(fd
, " %s", field_name
);
288 fprintf(fd
, "ssize_t");
289 fprintf(fd
, " %s", field_name
);
292 fprintf(fd
, "off_t");
293 fprintf(fd
, " %s", field_name
);
296 fprintf(fd
, "char *");
297 fprintf(fd
, " %s", field_name
);
300 fprintf(fd
, "enum lttng_%s", basename
);
301 fprintf(fd
, " %s", field_name
);
304 fprintf(fd
, "lttng_array_%s", basename
);
305 fprintf(fd
, " %s", field_name
);
308 fprintf(fd
, "lttng_sequence_%s *", basename
);
309 fprintf(fd
, " %s", field_name
);
312 fprintf(fd
, "struct lttng_%s *", basename
);
313 fprintf(fd
, " %s", field_name
);
316 fprintf(fd
, "union lttng_%s *", basename
);
317 fprintf(fd
, " %s", field_name
);
320 printf("print_type : unknown type\n");
328 /* print type declaration.
330 * Copied from construct_types_and_fields in LTTV facility.c */
332 int print_type_declaration(type_descriptor_t
* td
, FILE *fd
, unsigned int tabs
,
333 char *nest_name
, char *field_name
)
335 char basename
[PATH_MAX
];
336 unsigned int basename_len
= 0;
338 strncpy(basename
, nest_name
, PATH_MAX
);
339 basename_len
= strlen(basename
);
341 /* For a named type, we use the type_name directly */
342 if(td
->type_name
!= NULL
) {
343 strncpy(basename
, td
->type_name
, PATH_MAX
);
344 basename_len
= strlen(basename
);
346 /* For a unnamed type, there must be a field name, except for
348 if((basename_len
!= 0)
349 && (basename
[basename_len
-1] != '_'
350 && (field_name
[0] != '\0'))) {
351 strncat(basename
, "_", PATH_MAX
- basename_len
);
352 basename_len
= strlen(basename
);
354 strncat(basename
, field_name
, PATH_MAX
- basename_len
);
359 fprintf(fd
, "enum lttng_%s", basename
);
361 for(unsigned int i
=0;i
<td
->labels
.position
;i
++){
363 fprintf(fd
, "LTTNG_%s", ((char*)(td
->labels
.array
[i
])));
371 dprintf("%s\n", basename
);
372 assert(td
->size
>= 0);
373 if(((field_t
*)td
->fields
.array
[0])->type
->type_name
== NULL
) {
374 /* Not a named nested type : we must print its declaration first */
375 if(print_type_declaration(((field_t
*)td
->fields
.array
[0])->type
,
376 fd
, 0, basename
, "")) return 1;
378 fprintf(fd
, "#define LTTNG_ARRAY_SIZE_%s %llu\n", basename
,
380 fprintf(fd
, "typedef ");
381 if(print_type(((field_t
*)td
->fields
.array
[0])->type
,
382 fd
, tabs
, basename
, "")) return 1;
383 fprintf(fd
, " lttng_array_%s[LTTNG_ARRAY_SIZE_%s];\n", basename
,
388 /* We assume that the sequence length type does not need to be declared.
390 if(((field_t
*)td
->fields
.array
[1])->type
->type_name
== NULL
) {
391 /* Not a named nested type : we must print its declaration first */
392 if(print_type_declaration(((field_t
*)td
->fields
.array
[1])->type
,
393 fd
, 0, basename
, "")) return 1;
395 fprintf(fd
, "typedef struct lttng_sequence_%s lttng_sequence_%s;\n",
398 fprintf(fd
, "struct lttng_sequence_%s", basename
);
401 fprintf(fd
, "unsigned int len;\n");
403 if(print_type(((field_t
*)td
->fields
.array
[1])->type
,
404 fd
, tabs
, basename
, "")) return 1;
405 fprintf(fd
, " *array;\n");
411 for(unsigned int i
=0;i
<td
->fields
.position
;i
++){
412 field_t
*field
= (field_t
*)(td
->fields
.array
[i
]);
413 type_descriptor_t
*type
= field
->type
;
414 if(type
->type_name
== NULL
) {
415 /* Not a named nested type : we must print its declaration first */
416 if(print_type_declaration(type
,
417 fd
, 0, basename
, field
->name
)) return 1;
420 fprintf(fd
, "struct lttng_%s", basename
);
422 for(unsigned int i
=0;i
<td
->fields
.position
;i
++){
423 field_t
*field
= (field_t
*)(td
->fields
.array
[i
]);
424 type_descriptor_t
*type
= field
->type
;
426 if(print_type(type
, fd
, tabs
, basename
, field
->name
)) return 1;
428 fprintf(fd
, "%s", field
->name
);
435 /* TODO : Do not allow variable length fields in a union */
436 for(unsigned int i
=0;i
<td
->fields
.position
;i
++){
437 field_t
*field
= (field_t
*)(td
->fields
.array
[i
]);
438 type_descriptor_t
*type
= field
->type
;
439 if(type
->type_name
== NULL
) {
440 /* Not a named nested type : we must print its declaration first */
441 if(print_type_declaration(type
,
442 fd
, 0, basename
, field
->name
)) return 1;
445 fprintf(fd
, "union lttng_%s", basename
);
447 for(unsigned i
=0;i
<td
->fields
.position
;i
++){
448 field_t
*field
= (field_t
*)(td
->fields
.array
[i
]);
449 type_descriptor_t
*type
= field
->type
;
451 if(print_type(type
, fd
, tabs
, basename
, field
->name
)) return 1;
453 fprintf(fd
, "%s", field
->name
);
460 dprintf("print_type_declaration : unknown type or nothing to declare.\n");
471 /*****************************************************************************
473 * set_named_type_offsets : set the precomputable offset of the named type
476 ****************************************************************************/
477 void set_named_type_offsets(type_descriptor_t
*type
)
479 enum field_status current_child_status
= FIELD_FIXED_GENEVENT
;
480 off_t current_offset
= 0;
484 ¤t_child_status
,
486 if(current_child_status
== FIELD_FIXED_GENEVENT
) {
487 current_offset
+= type
->size
;
494 /*****************************************************************************
496 * set_event_fields_offsets : set the precomputable offset of the fields
499 ****************************************************************************/
500 void set_event_fields_offsets(event_t
*event
)
502 enum field_status current_child_status
= FIELD_FIXED
;
503 off_t current_offset
= 0;
505 for(unsigned int i
= 0; i
< event
->type
->fields
.position
; i
++) {
506 /* For each field, set the field offset. */
507 field_t
*child_field
= (field_t
*)event
->type
->fields
.array
[i
];
508 type_descriptor_t
*t
= f
->type
;
509 /* Skip named types */
510 if(t
->type_name
!= NULL
) continue;
514 ¤t_child_status
,
516 if(current_child_status
== FIELD_FIXED_GENEVENT
) {
517 current_offset
+= type
->size
;
526 /*****************************************************************************
528 * print_type_size : print the fixed sizes of the field type
531 * use offset_parent as offset to calculate alignment.
533 * offset_parent : offset from the parent
534 * fixed_parent : Do we know a fixed offset to the parent ?
536 ****************************************************************************/
537 void print_type_size(
539 enum field_status
*fixed_parent
,
540 type_descriptor_t
*type
,
544 enum field_status local_fixed_parent
;
547 g_assert(type
->fixed_size
== FIELD_UNKNOWN
);
549 size_t current_offset
;
550 enum field_status current_child_status
, final_child_status
;
554 /* type sizes known by genevent/compiler */
563 fprintf(fd
, "%s += ltt_align(%s, %s)", size_name
);
565 type
->fixed_size
= FIELD_FIXED_GENEVENT
;
567 /* host type sizes unknown by genevent, but known by the compiler */
571 /* An enum is either : char or int. In gcc, always int. Hope
572 * it's always like this. */
573 type
->fixed_size
= FIELD_FIXED_COMPILER
;
574 type
->compiler_size
= COMPILER_INT
;
578 type
->fixed_size
= FIELD_FIXED_COMPILER
;
579 type
->compiler_size
= COMPILER_LONG
;
582 type
->fixed_size
= FIELD_FIXED_COMPILER
;
583 type
->compiler_size
= COMPILER_POINTER
;
588 type
->fixed_size
= FIELD_FIXED_COMPILER
;
589 type
->compiler_size
= COMPILER_SIZE_T
;
592 * if all children has fixed size, then the parent size can be
593 * known directly and the copy can be done efficiently.
594 * if only part of the children has fixed size, then the contiguous
595 * elements will be copied in one bulk, but the variable size elements
596 * will be copied separately. This is necessary because those variable
597 * size elements are referenced by pointer in C.
601 local_fixed_parent
= FIELD_FIXED_GENEVENT
;
605 ((field_t
*)type
->fields
.array
[0])->type
);
606 preset_field_type_size(
609 ((field_t
*)type
->fields
.array
[1])->type
);
610 type
->fixed_size
= FIELD_VARIABLE
;
611 *fixed_parent
= FIELD_VARIABLE
;
614 field
->fixed_size
= FIELD_VARIABLE
;
615 *fixed_parent
= FIELD_VARIABLE
;
618 local_fixed_parent
= FIELD_FIXED_GENEVENT
;
622 ((field_t
*)type
->fields
.array
[0])->type
);
623 type
->fixed_size
= local_fixed_parent
;
624 if(type
->fixed_size
== FIELD_FIXED_GENEVENT
) {
626 type
->element_number
* ((field_t
*)type
->fields
.array
[0])->type
->size
;
627 } else if(type
->fixed_size
== FIELD_FIXED_COMPILER
) {
629 type
->element_number
;
632 *fixed_parent
= FIELD_VARIABLE
;
637 current_child_status
= FIELD_FIXED_GENEVENT
;
638 for(i
=0;i
<type
->element_number
;i
++) {
639 preset_field_type_size(
641 ¤t_child_status
,
642 ((field_t
*)type
->fields
.array
[i
])->type
);
643 if(current_child_status
== FIELD_FIXED_GENEVENT
) {
644 current_offset
+= field
->child
[i
]->field_size
;
649 if(current_child_status
!= FIELD_FIXED_GENEVENT
) {
650 *fixed_parent
= current_child_status
;
652 type
->fixed_size
= current_child_status
;
654 type
->size
= current_offset
;
655 type
->fixed_size
= FIELD_FIXED_GENEVENT
;
661 final_child_status
= FIELD_FIXED_GENEVENT
;
662 for(i
=0;i
<type
->element_number
;i
++) {
663 enum field_status current_child_status
= FIELD_FIXED
;
664 preset_field_type_size(
666 ¤t_child_status
,
667 ((field_t
*)type
->fields
.array
[i
])->type
);
668 if(current_child_status
!= FIELD_FIXED_GENEVENT
)
669 final_child_status
= current_child_status
;
672 max(max_size
, ((field_t
*)type
->fields
.array
[i
])->type
->size
);
674 if(final_child_status
!= FIELD_FIXED_GENEVENT AND COMPILER
) {
675 g_error("LTTV does not support variable size fields in unions.");
676 /* This will stop the application. */
677 *fixed_parent
= final_child_status
;
679 type
->fixed_size
= current_child_status
;
681 type
->size
= max_size
;
682 type
->fixed_size
= FIELD_FIXED_GENEVENT
;
690 size_t get_field_type_size(LttTracefile
*tf
, LttEventType
*event_type
,
691 off_t offset_root
, off_t offset_parent
,
692 LttField
*field
, void *data
)
698 g_assert(field
->fixed_root
!= FIELD_UNKNOWN
);
699 g_assert(field
->fixed_parent
!= FIELD_UNKNOWN
);
700 g_assert(field
->fixed_size
!= FIELD_UNKNOWN
);
702 field
->offset_root
= offset_root
;
703 field
->offset_parent
= offset_parent
;
705 type
= field
->field_type
;
707 switch(type
->type_class
) {
718 g_assert(field
->fixed_size
== FIELD_FIXED
);
719 size
= field
->field_size
;
723 gint seqnum
= ltt_get_uint(LTT_GET_BO(tf
),
724 field
->sequ_number_size
,
727 if(field
->child
[0]->fixed_size
== FIELD_FIXED
) {
728 size
= field
->sequ_number_size
+
729 (seqnum
* get_field_type_size(tf
, event_type
,
730 offset_root
, offset_parent
,
731 field
->child
[0], data
));
733 size
+= field
->sequ_number_size
;
734 for(i
=0;i
<seqnum
;i
++) {
736 child_size
= get_field_type_size(tf
, event_type
,
737 offset_root
, offset_parent
,
738 field
->child
[0], data
);
739 offset_root
+= child_size
;
740 offset_parent
+= child_size
;
744 field
->field_size
= size
;
748 size
= strlen((char*)(data
+offset_root
)) + 1;// length + \0
749 field
->field_size
= size
;
752 if(field
->fixed_size
== FIELD_FIXED
)
753 size
= field
->field_size
;
755 for(i
=0;i
<field
->field_type
->element_number
;i
++) {
757 child_size
= get_field_type_size(tf
, event_type
,
758 offset_root
, offset_parent
,
759 field
->child
[0], data
);
760 offset_root
+= child_size
;
761 offset_parent
+= child_size
;
764 field
->field_size
= size
;
768 if(field
->fixed_size
== FIELD_FIXED
)
769 size
= field
->field_size
;
771 size_t current_root_offset
= offset_root
;
772 size_t current_offset
= 0;
773 size_t child_size
= 0;
774 for(i
=0;i
<type
->element_number
;i
++) {
775 child_size
= get_field_type_size(tf
,
776 event_type
, current_root_offset
, current_offset
,
777 field
->child
[i
], data
);
778 current_offset
+= child_size
;
779 current_root_offset
+= child_size
;
782 size
= current_offset
;
783 field
->field_size
= size
;
787 if(field
->fixed_size
== FIELD_FIXED
)
788 size
= field
->field_size
;
790 size_t current_root_offset
= field
->offset_root
;
791 size_t current_offset
= 0;
792 for(i
=0;i
<type
->element_number
;i
++) {
793 size
= get_field_type_size(tf
, event_type
,
794 current_root_offset
, current_offset
,
795 field
->child
[i
], data
);
796 size
= max(size
, field
->child
[i
]->field_size
);
798 field
->field_size
= size
;
810 /* Print the code that calculates the length of an field */
811 int print_field_len(type_descriptor_t
* td
, FILE *fd
, unsigned int tabs
,
812 char *nest_type_name
, char *nest_field_name
, char *field_name
,
813 char *output_var
, char *member_var
)
815 /* Type name : basename */
816 char basename
[PATH_MAX
];
817 unsigned int basename_len
= 0;
819 strcpy(basename
, nest_type_name
);
820 basename_len
= strlen(basename
);
822 /* For a named type, we use the type_name directly */
823 if(td
->type_name
!= NULL
) {
824 strncpy(basename
, td
->type_name
, PATH_MAX
);
825 basename_len
= strlen(basename
);
827 /* For a unnamed type, there must be a field name */
828 if((basename_len
!= 0)
829 && (basename
[basename_len
-1] != '_')
830 && (field_name
[0] != '\0')) {
831 strncat(basename
, "_", PATH_MAX
- basename_len
);
832 basename_len
= strlen(basename
);
834 strncat(basename
, field_name
, PATH_MAX
- basename_len
);
837 /* Field name : basefieldname */
838 char basefieldname
[PATH_MAX
];
839 unsigned int basefieldname_len
= 0;
841 strcpy(basefieldname
, nest_field_name
);
842 basefieldname_len
= strlen(basefieldname
);
844 /* there must be a field name */
845 strncat(basefieldname
, field_name
, PATH_MAX
- basefieldname_len
);
846 basefieldname_len
= strlen(basefieldname
);
848 print_tabs(tabs
, fd
);
867 fprintf(fd
, "/* Size of %s */", field_name
);
868 print_tabs(tabs
, fd
);
869 fprintf(fd
, "%s = sizeof(", member_var
);
870 if(print_type(td
, fd
, tabs
, basename
, "")) return 1;
872 fprintf(fd
, "%s += ltt_align(%s, %s);\n", output_var
, member_var
);
873 print_tabs(tabs
, fd
);
874 fprintf(fd
, "%s += %s;\n", output_var
, member_var
);
877 /* strings are made of bytes : no alignment. */
878 fprintf(fd
, "/* Size of %s */", basefieldname
);
879 print_tabs(tabs
, fd
);
880 fprintf(fd
, "%s = strlen(%s);", member_var
, basefieldname
);
883 fprintf(fd
, "/* Size of %s */", basefieldname
);
884 print_tabs(tabs
, fd
);
886 strncat(basefieldname
, ".", PATH_MAX
- basefieldname_len
);
887 basefieldname_len
= strlen(basefieldname
);
889 if(print_field_len(((field_t
*)td
->fields
.array
[0])->type
,
891 basename
, basefieldname
,
892 output_var
, member_var
)) return 1;
894 fprintf(fd
, "%s = strlen(%s);", member_var
, basefieldname
);
896 fprintf(fd
, "lttng_array_%s", basename
);
897 fprintf(fd
, " %s", field_name
);
900 fprintf(fd
, "lttng_sequence_%s *", basename
);
901 fprintf(fd
, " %s", field_name
);
904 fprintf(fd
, "struct lttng_%s *", basename
);
905 fprintf(fd
, " %s", field_name
);
908 fprintf(fd
, "union lttng_%s *", basename
);
909 fprintf(fd
, " %s", field_name
);
912 printf("print_type : unknown type\n");
922 /* Print the logging function of an event. This is the core of genevent */
923 int print_event_logging_function(char *basename
, event_t
*event
, FILE *fd
)
925 fprintf(fd
, "static inline void trace_%s(\n", basename
);
926 for(unsigned int j
= 0; j
< event
->fields
.position
; j
++) {
927 /* For each field, print the function argument */
928 field_t
*f
= (field_t
*)event
->fields
.array
[j
];
929 type_descriptor_t
*t
= f
->type
;
930 if(print_arg(t
, fd
, 2, basename
, f
->name
)) return 1;
931 if(j
< event
->fields
.position
-1) {
936 if(event
->fields
.position
== 0) {
941 fprintf(fd
, "#ifndef CONFIG_LTT\n");
944 fprintf(fd
,"#else\n");
946 /* Print the function variables */
948 fprintf(fd
, "size_t member_length;");
949 fprintf(fd
, "size_t event_length = 0;");
951 /* Calculate event variable len + event data alignment offset.
952 * Assume that the padding for alignment starts at a void*
954 * This excludes the header size and alignment. */
957 for(unsigned int j
= 0; j
< event
->fields
.position
; j
++) {
958 /* For each field, calculate the field size. */
959 field_t
*f
= (field_t
*)event
->fields
.array
[j
];
960 type_descriptor_t
*t
= f
->type
;
961 if(print_field_len(t
, fd
, 1, basename
, "",
964 "member_length")) return 1;
965 if(j
< event
->fields
.position
-1) {
971 /* Take locks : make sure the trace does not vanish while we write on
972 * it. A simple preemption disabling is enough (using rcu traces). */
977 /* If error, increment counter and return */
986 fprintf(fd
, "#endif //CONFIG_LTT\n\n");
991 /* ltt-facility-name.h : main logging header.
994 void print_log_header_head(facility_t
*fac
, FILE *fd
)
996 fprintf(fd
, "#ifndef _LTT_FACILITY_%s_H_\n", fac
->capname
);
997 fprintf(fd
, "#define _LTT_FACILITY_%s_H_\n\n", fac
->capname
);
999 fprintf(fd
, "/* Facility activation at compile time. */\n");
1000 fprintf(fd
, "#ifdef CONFIG_LTT_FACILITY_%s\n\n", fac
->capname
);
1005 int print_log_header_types(facility_t
*fac
, FILE *fd
)
1007 sequence_t
*types
= &fac
->named_types
.values
;
1008 fprintf(fd
, "/* Named types */\n");
1011 for(unsigned int i
= 0; i
< types
->position
; i
++) {
1012 /* For each named type, print the definition */
1013 if((print_type_declaration(types
->array
[i
], fd
,
1014 0, "", ""))) return 1;
1019 int print_log_header_events(facility_t
*fac
, FILE *fd
)
1021 sequence_t
*events
= &fac
->events
;
1022 char basename
[PATH_MAX
];
1023 unsigned int facname_len
;
1025 strncpy(basename
, fac
->name
, PATH_MAX
);
1026 facname_len
= strlen(basename
);
1027 strncat(basename
, "_", PATH_MAX
-facname_len
);
1028 facname_len
= strlen(basename
);
1030 for(unsigned int i
= 0; i
< events
->position
; i
++) {
1031 event_t
*event
= (event_t
*)events
->array
[i
];
1032 strncpy(&basename
[facname_len
], event
->name
, PATH_MAX
-facname_len
);
1034 /* For each event, print structure, and then logging function */
1035 fprintf(fd
, "/* Event %s structures */\n",
1037 for(unsigned int j
= 0; j
< event
->fields
.position
; j
++) {
1038 /* For each unnamed type, print the definition */
1039 field_t
*f
= (field_t
*)event
->fields
.array
[j
];
1040 type_descriptor_t
*t
= f
->type
;
1041 if(t
->type_name
== NULL
)
1042 if((print_type_declaration(t
, fd
, 0, basename
, f
->name
))) return 1;
1046 fprintf(fd
, "/* Event %s logging function */\n",
1049 if(print_event_logging_function(basename
, event
, fd
)) return 1;
1058 void print_log_header_tail(facility_t
*fac
, FILE *fd
)
1060 fprintf(fd
, "#endif //CONFIG_LTT_FACILITY_%s\n\n", fac
->capname
);
1061 fprintf(fd
, "#endif //_LTT_FACILITY_%s_H_\n",fac
->capname
);
1064 int print_log_header(facility_t
*fac
)
1066 char filename
[PATH_MAX
];
1067 unsigned int filename_size
= 0;
1069 dprintf("%s\n", fac
->name
);
1071 strcpy(filename
, "ltt-facility-");
1072 filename_size
= strlen(filename
);
1074 strncat(filename
, fac
->name
, PATH_MAX
- filename_size
);
1075 filename_size
= strlen(filename
);
1077 strncat(filename
, ".h", PATH_MAX
- filename_size
);
1078 filename_size
= strlen(filename
);
1081 fd
= fopen(filename
, "w");
1083 printf("Error opening file %s for writing : %s\n",
1084 filename
, strerror(errno
));
1088 /* Print file head */
1089 print_log_header_head(fac
, fd
);
1091 /* print named types in declaration order */
1092 if(print_log_header_types(fac
, fd
)) return 1;
1095 if(print_log_header_events(fac
, fd
)) return 1;
1097 /* Print file tail */
1098 print_log_header_tail(fac
, fd
);
1107 /* ltt-facility-id-name.h : facility id.
1109 int print_id_header(facility_t
*fac
)
1111 char filename
[PATH_MAX
];
1112 unsigned int filename_size
= 0;
1114 dprintf("%s\n", fac
->name
);
1116 strcpy(filename
, "ltt-facility-id-");
1117 filename_size
= strlen(filename
);
1119 strncat(filename
, fac
->name
, PATH_MAX
- filename_size
);
1120 filename_size
= strlen(filename
);
1122 strncat(filename
, ".h", PATH_MAX
- filename_size
);
1123 filename_size
= strlen(filename
);
1126 fd
= fopen(filename
, "w");
1128 printf("Error opening file %s for writing : %s\n",
1129 filename
, strerror(errno
));
1139 /* ltt-facility-loader-name.h : facility specific loader info.
1141 int print_loader_header(facility_t
*fac
)
1143 char filename
[PATH_MAX
];
1144 unsigned int filename_size
= 0;
1146 dprintf("%s\n", fac
->name
);
1148 strcpy(filename
, "ltt-facility-loader-");
1149 filename_size
= strlen(filename
);
1151 strncat(filename
, fac
->name
, PATH_MAX
- filename_size
);
1152 filename_size
= strlen(filename
);
1154 strncat(filename
, ".h", PATH_MAX
- filename_size
);
1155 filename_size
= strlen(filename
);
1158 fd
= fopen(filename
, "w");
1160 printf("Error opening file %s for writing : %s\n",
1161 filename
, strerror(errno
));
1170 /* ltt-facility-loader-name.c : generic faciilty loader
1172 int print_loader_c(facility_t
*fac
)
1174 char filename
[PATH_MAX
];
1175 unsigned int filename_size
= 0;
1177 dprintf("%s\n", fac
->name
);
1179 strcpy(filename
, "ltt-facility-loader-");
1180 filename_size
= strlen(filename
);
1182 strncat(filename
, fac
->name
, PATH_MAX
- filename_size
);
1183 filename_size
= strlen(filename
);
1185 strncat(filename
, ".c", PATH_MAX
- filename_size
);
1186 filename_size
= strlen(filename
);
1189 fd
= fopen(filename
, "w");
1191 printf("Error opening file %s for writing : %s\n",
1192 filename
, strerror(errno
));
1205 /* code taken from ltt_facility_open in ltt/facility.c in lttv */
1207 /*****************************************************************************
1209 * ltt_facility_open : open facilities
1211 * pathname : the path name of the facility
1213 * Open the facility corresponding to the right checksum.
1215 *returns the facility on success, NULL on error.
1216 ****************************************************************************/
1217 facility_t
*ltt_facility_open(char * pathname
)
1222 facility_t
* fac
= NULL
;
1223 unsigned long checksum
;
1224 char buffer
[BUFFER_SIZE
];
1225 int generated
= FALSE
;
1227 in
.buffer
= &(buffer
[0]);
1229 in
.error
= error_callback
;
1233 in
.fp
= fopen(in
.name
, "r");
1240 token
= getToken(&in
);
1241 if(in
.type
== ENDFILE
) break;
1244 printf("More than one facility in the file. Only using the first one.\n");
1248 if(strcmp(token
, "<")) in
.error(&in
,"not a facility file");
1249 token
= getName(&in
);
1251 if(strcmp("facility",token
) == 0) {
1252 fac
= malloc(sizeof(facility_t
));
1254 fac
->description
= NULL
;
1255 sequence_init(&(fac
->events
));
1256 table_init(&(fac
->named_types
));
1257 sequence_init(&(fac
->unnamed_types
));
1259 parseFacility(&in
, fac
);
1261 //check if any namedType is not defined
1262 checkNamedTypesImplemented(&fac
->named_types
);
1264 generateChecksum(fac
->name
, &checksum
, &fac
->events
);
1269 printf("facility token was expected in file %s\n", in
.name
);
1280 printf("Cannot find facility %s\n", pathname
);
1287 /* Close the facility */
1288 void ltt_facility_close(facility_t
*fac
)
1292 free(fac
->description
);
1293 freeEvents(&fac
->events
);
1294 sequence_dispose(&fac
->events
);
1295 freeNamedType(&fac
->named_types
);
1296 table_dispose(&fac
->named_types
);
1297 freeTypes(&fac
->unnamed_types
);
1298 sequence_dispose(&fac
->unnamed_types
);
1304 void show_help(int argc
, char ** argv
)
1306 printf("Genevent help : \n");
1308 printf("Use %s name.xml\n", argv
[0]);
1309 printf("to create :\n");
1310 printf("ltt-facility-name.h\n");
1311 printf("ltt-facility-id-name.h\n");
1312 printf("ltt-facility-loader-name.h\n");
1313 printf("ltt-facility-loader-name.c\n");
1314 printf("In the current directory.\n");
1318 /* Parse program arguments */
1320 * 0 : continue program
1321 * -1 : stop program, return 0
1322 * > 0 : stop program, return value as exit.
1324 int check_args(int argc
, char **argv
)
1327 printf("Not enough arguments\n");
1328 show_help(argc
, argv
);
1332 if(strcmp(argv
[1], "-h") == 0) {
1333 show_help(argc
, argv
);
1340 int main(int argc
, char **argv
)
1345 err
= check_args(argc
, argv
);
1346 if(err
> 0) return err
;
1347 else if(err
< 0) return 0;
1349 /* open the facility */
1350 fac
= ltt_facility_open(argv
[1]);
1352 printf("Error opening file %s for reading : %s\n",
1353 argv
[1], strerror(errno
));
1357 /* generate the output C files */
1360 /* ltt-facility-name.h : main logging header.
1362 err
= print_log_header(fac
);
1365 /* ltt-facility-id-name.h : facility id.
1367 err
= print_id_header(fac
);
1370 /* ltt-facility-loader-name.h : facility specific loader info.
1372 err
= print_loader_header(fac
);
1375 /* ltt-facility-loader-name.c : generic faciilty loader
1377 err
= print_loader_c(fac
);
1380 /* close the facility */
1381 ltt_facility_close(fac
);