projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
kernel state dump XML facility for genevent new
[lttv.git] / genevent-new / genevent.c
CommitLineData
92d82357 1/******************************************************************************
2 * Genevent
3 *
4 * Event generator. XML to logging C code converter.
5 *
6 * Program parameters :
7 * ./genevent name.xml
8 *
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.
12 *
13 * Supports :
14 * - C Alignment
15 * - C types : struct, union, enum, basic types.
16 * - Architectures : LP32, ILP32, ILP64, LLP64, LP64.
17 *
18 * Additionnal structures supported :
19 * - embedded variable size strings
20 * - embedded variable size arrays
21 * - embedded variable size sequences
22 *
23 * Notes :
24 * (1)
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.
29 *
30 * (2)
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.
34 *
35 * Note that, from
36 * http://www.usenix.org/publications/login/standards/10.data.html
37 * (Andrew Josey <a.josey@opengroup.org>) :
38 *
39 * Data Type LP32 ILP32 ILP64 LLP64 LP64
40 * char 8 8 8 8 8
41 * short 16 16 16 16 16
42 * int32 32
43 * int 16 32 64 32 32
44 * long 32 32 64 32 64
45 * long long (int64) 64
46 * pointer 32 32 64 64 64
47 *
48 * With these constraints :
49 * sizeof(char) <= sizeof(short) <= sizeof(int)
50 * <= sizeof(long) = sizeof(size_t)
51 *
52 * and therefore sizeof(long) <= sizeof(pointer) <= sizeof(size_t)
53 *
54 * Which means we only have to remember which is the biggest type in a structure
55 * to know the structure's alignment.
56 */
57
2d2d14a7 58#define _GNU_SOURCE
59#include <limits.h>
60#include <stdlib.h>
92d82357 61#include <errno.h>
62#include <sys/types.h>
63#include <sys/stat.h>
64#include <fcntl.h>
65#include <stdio.h>
66#include <string.h>
67#include <unistd.h>
2d2d14a7 68#include <assert.h>
92d82357 69
70#include "genevent.h"
71#include "parser.h"
72
73
74#define TRUE 1
75#define FALSE (!TRUE)
76
2d2d14a7 77/* Debugging printf */
78#ifdef DEBUG
79#define dprintf(...) \
80 do {\
81 printf(__FILE__ ",%u,%s: ",\
82 __LINE__, __func__);\
83 printf(__VA_ARGS__);\
84 } while(0)
85#else
86#define dprintf(...)
87#endif
88
92d82357 89/* Code printing */
90
2d2d14a7 91void print_tabs(unsigned int tabs, FILE *fd)
92{
93 for(unsigned int i = 0; i<tabs;i++)
94 fprintf(fd, "\t");
95}
96
2d2d14a7 97/* print type.
98 *
99 * Copied from construct_types_and_fields in LTTV facility.c */
100
101int print_type(type_descriptor_t * td, FILE *fd, unsigned int tabs,
102 char *nest_name, char *field_name)
103{
104 char basename[PATH_MAX];
105 unsigned int basename_len = 0;
106
107 strcpy(basename, nest_name);
108 basename_len = strlen(basename);
109
110 /* For a named type, we use the type_name directly */
111 if(td->type_name != NULL) {
112 strncpy(basename, td->type_name, PATH_MAX);
113 basename_len = strlen(basename);
114 } else {
115 /* For a unnamed type, there must be a field name */
7b175edc 116 if((basename_len != 0)
117 && (basename[basename_len-1] != '_')
118 && (field_name[0] != '\0')) {
2d2d14a7 119 strncat(basename, "_", PATH_MAX - basename_len);
120 basename_len = strlen(basename);
121 }
122 strncat(basename, field_name, PATH_MAX - basename_len);
123 }
124
125 switch(td->type) {
126 case INT_FIXED:
127 fprintf(fd, "%s", intOutputTypes[getSizeindex(td->size)]);
128 break;
129 case UINT_FIXED:
130 fprintf(fd, "%s", uintOutputTypes[getSizeindex(td->size)]);
131 break;
132 case CHAR:
133 fprintf(fd, "signed char");
134 break;
135 case UCHAR:
136 fprintf(fd, "unsigned char");
137 break;
138 case SHORT:
139 fprintf(fd, "short");
140 break;
141 case USHORT:
142 fprintf(fd, "unsigned short");
143 break;
144 case INT:
145 fprintf(fd, "int");
146 break;
147 case UINT:
148 fprintf(fd, "unsigned int");
149 break;
150 case FLOAT:
151 fprintf(fd, "%s", floatOutputTypes[getSizeindex(td->size)]);
152 break;
153 case POINTER:
154 fprintf(fd, "void *");
155 break;
156 case LONG:
157 fprintf(fd, "long");
158 break;
159 case ULONG:
160 fprintf(fd, "unsigned long");
161 break;
162 case SIZE_T:
163 fprintf(fd, "size_t");
164 break;
165 case SSIZE_T:
166 fprintf(fd, "ssize_t");
167 break;
168 case OFF_T:
169 fprintf(fd, "off_t");
170 break;
171 case STRING:
172 fprintf(fd, "char *");
173 break;
174 case ENUM:
175 fprintf(fd, "enum lttng_%s", basename);
176 break;
177 case ARRAY:
178 fprintf(fd, "lttng_array_%s", basename);
179 break;
180 case SEQUENCE:
181 fprintf(fd, "lttng_sequence_%s", basename);
182 break;
183 case STRUCT:
184 fprintf(fd, "struct lttng_%s", basename);
185 break;
186 case UNION:
187 fprintf(fd, "union lttng_%s", basename);
188 break;
189 default:
190 printf("print_type : unknown type\n");
191 return 1;
192 }
193
194 return 0;
195}
196
7e97b039 197/* Print logging function argument */
198int print_arg(type_descriptor_t * td, FILE *fd, unsigned int tabs,
199 char *nest_name, char *field_name)
200{
201 char basename[PATH_MAX];
202 unsigned int basename_len = 0;
203
204 strcpy(basename, nest_name);
205 basename_len = strlen(basename);
206
207 /* For a named type, we use the type_name directly */
208 if(td->type_name != NULL) {
209 strncpy(basename, td->type_name, PATH_MAX);
210 basename_len = strlen(basename);
211 } else {
212 /* For a unnamed type, there must be a field name */
213 if((basename_len != 0)
214 && (basename[basename_len-1] != '_')
215 && (field_name[0] != '\0')) {
216 strncat(basename, "_", PATH_MAX - basename_len);
217 basename_len = strlen(basename);
218 }
219 strncat(basename, field_name, PATH_MAX - basename_len);
220 }
221
222 print_tabs(tabs, fd);
223
224 switch(td->type) {
225 case INT_FIXED:
226 fprintf(fd, "%s", intOutputTypes[getSizeindex(td->size)]);
227 fprintf(fd, " %s", field_name);
228 break;
229 case UINT_FIXED:
230 fprintf(fd, "%s", uintOutputTypes[getSizeindex(td->size)]);
231 fprintf(fd, " %s", field_name);
232 break;
233 case CHAR:
234 fprintf(fd, "signed char");
235 fprintf(fd, " %s", field_name);
236 break;
237 case UCHAR:
238 fprintf(fd, "unsigned char");
239 fprintf(fd, " %s", field_name);
240 break;
241 case SHORT:
242 fprintf(fd, "short");
243 fprintf(fd, " %s", field_name);
244 break;
245 case USHORT:
246 fprintf(fd, "unsigned short");
247 fprintf(fd, " %s", field_name);
248 break;
249 case INT:
250 fprintf(fd, "int");
251 fprintf(fd, " %s", field_name);
252 break;
253 case UINT:
254 fprintf(fd, "unsigned int");
255 fprintf(fd, " %s", field_name);
256 break;
257 case FLOAT:
258 fprintf(fd, "%s", floatOutputTypes[getSizeindex(td->size)]);
259 fprintf(fd, " %s", field_name);
260 break;
261 case POINTER:
262 fprintf(fd, "void *");
263 fprintf(fd, " %s", field_name);
264 break;
265 case LONG:
266 fprintf(fd, "long");
267 fprintf(fd, " %s", field_name);
268 break;
269 case ULONG:
270 fprintf(fd, "unsigned long");
271 fprintf(fd, " %s", field_name);
272 break;
273 case SIZE_T:
274 fprintf(fd, "size_t");
275 fprintf(fd, " %s", field_name);
276 break;
277 case SSIZE_T:
278 fprintf(fd, "ssize_t");
279 fprintf(fd, " %s", field_name);
280 break;
281 case OFF_T:
282 fprintf(fd, "off_t");
283 fprintf(fd, " %s", field_name);
284 break;
285 case STRING:
286 fprintf(fd, "char *");
287 fprintf(fd, " %s", field_name);
288 break;
289 case ENUM:
290 fprintf(fd, "enum lttng_%s", basename);
291 fprintf(fd, " %s", field_name);
292 break;
293 case ARRAY:
294 fprintf(fd, "lttng_array_%s", basename);
295 fprintf(fd, " %s", field_name);
296 break;
297 case SEQUENCE:
298 fprintf(fd, "lttng_sequence_%s *", basename);
299 fprintf(fd, " %s", field_name);
300 break;
301 case STRUCT:
302 fprintf(fd, "struct lttng_%s *", basename);
303 fprintf(fd, " %s", field_name);
304 break;
305 case UNION:
306 fprintf(fd, "union lttng_%s *", basename);
307 fprintf(fd, " %s", field_name);
308 break;
309 default:
310 printf("print_type : unknown type\n");
311 return 1;
312 }
313
314 return 0;
315}
316
317
a3e6ce64 318/* Does the type has a fixed size ? (as know from the compiler)
319 *
320 * 1 : fixed size
321 * 0 : variable length
322 */
323int has_type_fixed_size(type_descriptor_t *td)
324{
325 switch(td->type) {
326 case INT_FIXED:
327 case UINT_FIXED:
328 case CHAR:
329 case UCHAR:
330 case SHORT:
331 case USHORT:
332 case INT:
333 case UINT:
334 case FLOAT:
335 case POINTER:
336 case LONG:
337 case ULONG:
338 case SIZE_T:
339 case SSIZE_T:
340 case OFF_T:
341 case ENUM:
342 case UNION: /* The union must have fixed size children. Must be checked by
343 the parser */
344 return 1;
345 break;
346 case STRING:
347 case SEQUENCE:
348 return 0;
349 break;
350 case STRUCT:
351 {
352 int has_type_fixed = 0;
353 for(unsigned int i=0;i<td->fields.position;i++){
354 field_t *field = (field_t*)(td->fields.array[i]);
355 type_descriptor_t *type = field->type;
356
357 has_type_fixed = has_type_fixed_size(type);
358 if(!has_type_fixed) return 0;
359 }
360 return 1;
361 }
362 break;
363 case ARRAY:
364 assert(td->size >= 0);
2e415130 365 return has_type_fixed_size(((field_t*)td->fields.array[0])->type);
366 break;
367 case NONE:
368 printf("There is a type defined to NONE : bad.\n");
369 assert(0);
a3e6ce64 370 break;
371 }
2e415130 372 return 0; //make gcc happy.
a3e6ce64 373}
374
375
376
377
378
2d2d14a7 379/* print type declaration.
380 *
381 * Copied from construct_types_and_fields in LTTV facility.c */
382
383int print_type_declaration(type_descriptor_t * td, FILE *fd, unsigned int tabs,
384 char *nest_name, char *field_name)
385{
386 char basename[PATH_MAX];
387 unsigned int basename_len = 0;
388
7b175edc 389 strncpy(basename, nest_name, PATH_MAX);
2d2d14a7 390 basename_len = strlen(basename);
391
392 /* For a named type, we use the type_name directly */
393 if(td->type_name != NULL) {
394 strncpy(basename, td->type_name, PATH_MAX);
395 basename_len = strlen(basename);
396 } else {
7b175edc 397 /* For a unnamed type, there must be a field name, except for
398 * the array. */
399 if((basename_len != 0)
400 && (basename[basename_len-1] != '_'
401 && (field_name[0] != '\0'))) {
2d2d14a7 402 strncat(basename, "_", PATH_MAX - basename_len);
403 basename_len = strlen(basename);
404 }
405 strncat(basename, field_name, PATH_MAX - basename_len);
2d2d14a7 406 }
407
408 switch(td->type) {
409 case ENUM:
410 fprintf(fd, "enum lttng_%s", basename);
411 fprintf(fd, " {\n");
412 for(unsigned int i=0;i<td->labels.position;i++){
413 print_tabs(1, fd);
414 fprintf(fd, "LTTNG_%s", ((char*)(td->labels.array[i])));
415 fprintf(fd, ",\n");
416 }
417 fprintf(fd, "};\n");
418 fprintf(fd, "\n");
419 break;
420
421 case ARRAY:
7b175edc 422 dprintf("%s\n", basename);
2d2d14a7 423 assert(td->size >= 0);
a67cd958 424 if(((field_t*)td->fields.array[0])->type->type_name == NULL) {
2d2d14a7 425 /* Not a named nested type : we must print its declaration first */
a67cd958 426 if(print_type_declaration(((field_t*)td->fields.array[0])->type,
2d2d14a7 427 fd, 0, basename, "")) return 1;
428 }
2e415130 429 fprintf(fd, "#define LTTNG_ARRAY_SIZE_%s %zu\n", basename,
2d2d14a7 430 td->size);
7e97b039 431 fprintf(fd, "typedef ");
a67cd958 432 if(print_type(((field_t*)td->fields.array[0])->type,
433 fd, tabs, basename, "")) return 1;
2d2d14a7 434 fprintf(fd, " lttng_array_%s[LTTNG_ARRAY_SIZE_%s];\n", basename,
435 basename);
436 fprintf(fd, "\n");
437 break;
438 case SEQUENCE:
a67cd958 439 /* We assume that the sequence length type does not need to be declared.
440 */
441 if(((field_t*)td->fields.array[1])->type->type_name == NULL) {
2d2d14a7 442 /* Not a named nested type : we must print its declaration first */
a67cd958 443 if(print_type_declaration(((field_t*)td->fields.array[1])->type,
2d2d14a7 444 fd, 0, basename, "")) return 1;
445 }
446 fprintf(fd, "typedef struct lttng_sequence_%s lttng_sequence_%s;\n",
447 basename,
448 basename);
449 fprintf(fd, "struct lttng_sequence_%s", basename);
450 fprintf(fd, " {\n");
451 print_tabs(1, fd);
a3e6ce64 452 if(print_type(((field_t*)td->fields.array[0])->type,
453 fd, tabs, basename, "")) return 1;
40c18b13 454 fprintf(fd, " len;\n");
2d2d14a7 455 print_tabs(1, fd);
a67cd958 456 if(print_type(((field_t*)td->fields.array[1])->type,
457 fd, tabs, basename, "")) return 1;
2d2d14a7 458 fprintf(fd, " *array;\n");
d428224c 459 fprintf(fd, "};\n"); /* We do not LTT_ALIGN, because we never copy
460 it to the buffer directly. */
2d2d14a7 461 fprintf(fd, "\n");
462 break;
463
464 case STRUCT:
465 for(unsigned int i=0;i<td->fields.position;i++){
466 field_t *field = (field_t*)(td->fields.array[i]);
467 type_descriptor_t *type = field->type;
468 if(type->type_name == NULL) {
469 /* Not a named nested type : we must print its declaration first */
470 if(print_type_declaration(type,
471 fd, 0, basename, field->name)) return 1;
472 }
473 }
474 fprintf(fd, "struct lttng_%s", basename);
475 fprintf(fd, " {\n");
476 for(unsigned int i=0;i<td->fields.position;i++){
477 field_t *field = (field_t*)(td->fields.array[i]);
478 type_descriptor_t *type = field->type;
479 print_tabs(1, fd);
47299663 480 if(print_type(type, fd, tabs, basename, field->name)) return 1;
2d2d14a7 481 fprintf(fd, " ");
482 fprintf(fd, "%s", field->name);
483 fprintf(fd, ";\n");
484 }
d428224c 485 fprintf(fd, "} LTT_ALIGN;\n");
2d2d14a7 486 fprintf(fd, "\n");
487 break;
488 case UNION:
2d2d14a7 489 for(unsigned int i=0;i<td->fields.position;i++){
490 field_t *field = (field_t*)(td->fields.array[i]);
491 type_descriptor_t *type = field->type;
492 if(type->type_name == NULL) {
493 /* Not a named nested type : we must print its declaration first */
47299663 494 if(print_type_declaration(type,
495 fd, 0, basename, field->name)) return 1;
2d2d14a7 496 }
497 }
498 fprintf(fd, "union lttng_%s", basename);
499 fprintf(fd, " {\n");
500 for(unsigned i=0;i<td->fields.position;i++){
501 field_t *field = (field_t*)(td->fields.array[i]);
502 type_descriptor_t *type = field->type;
503 print_tabs(1, fd);
47299663 504 if(print_type(type, fd, tabs, basename, field->name)) return 1;
2d2d14a7 505 fprintf(fd, " ");
506 fprintf(fd, "%s", field->name);
507 fprintf(fd, ";\n");
508 }
d428224c 509 fprintf(fd, "} LTT_ALIGN;\n");
2d2d14a7 510 fprintf(fd, "\n");
511 break;
512 default:
513 dprintf("print_type_declaration : unknown type or nothing to declare.\n");
514 break;
515 }
516
517 return 0;
518}
519
a67cd958 520
a3e6ce64 521/* print type alignment.
522 *
523 * Copied from construct_types_and_fields in LTTV facility.c
524 *
525 * basename is the name which identifies the type (along with a prefix
526 * (possibly)). */
a67cd958 527
a3e6ce64 528int print_type_alignment(type_descriptor_t * td, FILE *fd, unsigned int tabs,
529 char *nest_name, char *field_name)
a67cd958 530{
a3e6ce64 531 char basename[PATH_MAX];
532 unsigned int basename_len = 0;
533
534 strncpy(basename, nest_name, PATH_MAX);
535 basename_len = strlen(basename);
536
537 /* For a named type, we use the type_name directly */
538 if(td->type_name != NULL) {
539 strncpy(basename, td->type_name, PATH_MAX);
540 basename_len = strlen(basename);
a67cd958 541 } else {
a3e6ce64 542 /* For a unnamed type, there must be a field name, except for
543 * the array. */
544 if((basename_len != 0)
545 && (basename[basename_len-1] != '_'
34c1d1b5 546 && field_name != NULL
a3e6ce64 547 && (field_name[0] != '\0'))) {
548 strncat(basename, "_", PATH_MAX - basename_len);
549 basename_len = strlen(basename);
a67cd958 550 }
34c1d1b5 551 if(field_name != NULL)
552 strncat(basename, field_name, PATH_MAX - basename_len);
a67cd958 553 }
a3e6ce64 554
555 switch(td->type) {
a67cd958 556 case INT_FIXED:
557 case UINT_FIXED:
a67cd958 558 case CHAR:
559 case UCHAR:
560 case SHORT:
561 case USHORT:
a3e6ce64 562 case INT:
563 case UINT:
564 case FLOAT:
565 case POINTER:
566 case LONG:
567 case ULONG:
568 case SIZE_T:
569 case SSIZE_T:
570 case OFF_T:
571 case ENUM:
572 fprintf(fd, "sizeof(");
2e415130 573 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 574 fprintf(fd, ")");
575 break;
576 case STRING:
577 fprintf(fd, "sizeof(char)");
578 break;
579 case SEQUENCE:
580 fprintf(fd, "lttng_get_alignment_sequence_%s(&obj->%s)", basename,
581 field_name);
582 break;
583 case STRUCT:
584 fprintf(fd, "lttng_get_alignment_struct_%s(&obj->%s)", basename,
585 field_name);
586 break;
587 case UNION:
588 fprintf(fd, "lttng_get_alignment_union_%s(&obj->%s)", basename,
589 field_name);
590 break;
591 case ARRAY:
592 fprintf(fd, "lttng_get_alignment_array_%s(obj->%s)", basename,
593 field_name);
594 break;
2e415130 595 case NONE:
596 printf("error : type NONE unexpected\n");
597 return 1;
598 break;
a3e6ce64 599 }
a67cd958 600
a3e6ce64 601 return 0;
a67cd958 602}
603
a3e6ce64 604/* print type write.
605 *
606 * Copied from construct_types_and_fields in LTTV facility.c
607 *
608 * basename is the name which identifies the type (along with a prefix
609 * (possibly)). */
a67cd958 610
a3e6ce64 611int print_type_write(type_descriptor_t * td, FILE *fd, unsigned int tabs,
612 char *nest_name, char *field_name)
a67cd958 613{
a67cd958 614 char basename[PATH_MAX];
615 unsigned int basename_len = 0;
a3e6ce64 616
617 strncpy(basename, nest_name, PATH_MAX);
a67cd958 618 basename_len = strlen(basename);
619
620 /* For a named type, we use the type_name directly */
621 if(td->type_name != NULL) {
622 strncpy(basename, td->type_name, PATH_MAX);
623 basename_len = strlen(basename);
624 } else {
a3e6ce64 625 /* For a unnamed type, there must be a field name, except for
626 * the array. */
a67cd958 627 if((basename_len != 0)
a3e6ce64 628 && (basename[basename_len-1] != '_'
629 && (field_name[0] != '\0'))) {
a67cd958 630 strncat(basename, "_", PATH_MAX - basename_len);
631 basename_len = strlen(basename);
632 }
633 strncat(basename, field_name, PATH_MAX - basename_len);
634 }
635
a67cd958 636 switch(td->type) {
637 case INT_FIXED:
638 case UINT_FIXED:
639 case CHAR:
640 case UCHAR:
641 case SHORT:
642 case USHORT:
643 case INT:
644 case UINT:
645 case FLOAT:
646 case POINTER:
647 case LONG:
648 case ULONG:
649 case SIZE_T:
650 case SSIZE_T:
651 case OFF_T:
652 case ENUM:
a67cd958 653 print_tabs(tabs, fd);
a3e6ce64 654 fprintf(fd, "size = ");
655 fprintf(fd, "sizeof(");
2e415130 656 if(print_type(td, fd, 0, basename, "")) return 1;
a67cd958 657 fprintf(fd, ");\n");
a67cd958 658 print_tabs(tabs, fd);
30d72138 659 fprintf(fd, "size += ltt_align(*to+*len, size) + size;\n");
a3e6ce64 660 print_tabs(tabs, fd);
661 fprintf(fd, "*len += size;");
a67cd958 662 break;
663 case STRING:
a67cd958 664 print_tabs(tabs, fd);
2e415130 665 fprintf(fd, "lttng_write_string_%s(buffer, to_base, to, from, len, obj->%s);\n", basename, field_name);
a3e6ce64 666 break;
667 case SEQUENCE:
668 print_tabs(tabs, fd);
34c1d1b5 669 fprintf(fd, "lttng_write_%s(buffer, to_base, to, from, len, &obj->%s)", basename,
a3e6ce64 670 field_name);
671 break;
672 case STRUCT:
673 print_tabs(tabs, fd);
34c1d1b5 674 fprintf(fd, "lttng_write_struct_%s(buffer, to_base, to, from, len, &obj->%s)", basename,
a3e6ce64 675 field_name);
676 break;
677 case UNION:
678 print_tabs(tabs, fd);
34c1d1b5 679 fprintf(fd, "lttng_write_union_%s(buffer, to_base, to, from, len, &obj->%s)", basename,
a3e6ce64 680 field_name);
a67cd958 681 break;
682 case ARRAY:
a67cd958 683 print_tabs(tabs, fd);
a3e6ce64 684 fprintf(fd, "lttng_write_array_%s(buffer, to_base, to, from, len, obj->%s)", basename,
685 field_name);
686 break;
2e415130 687 case NONE:
688 printf("Error : type NONE unexpected\n");
689 return 1;
690 break;
a3e6ce64 691 }
a67cd958 692
a3e6ce64 693 return 0;
694}
a67cd958 695
a67cd958 696
a67cd958 697
a3e6ce64 698/* print type alignment function.
699 *
700 * Copied from construct_types_and_fields in LTTV facility.c
701 *
702 * basename is the name which identifies the type (along with a prefix
703 * (possibly)). */
704
705int print_type_alignment_fct(type_descriptor_t * td, FILE *fd,
706 unsigned int tabs,
707 char *nest_name, char *field_name)
708{
709 char basename[PATH_MAX];
710 unsigned int basename_len = 0;
711
712 strncpy(basename, nest_name, PATH_MAX);
713 basename_len = strlen(basename);
714
715 /* For a named type, we use the type_name directly */
716 if(td->type_name != NULL) {
717 strncpy(basename, td->type_name, PATH_MAX);
718 basename_len = strlen(basename);
719 } else {
720 /* For a unnamed type, there must be a field name, except for
721 * the array. */
722 if((basename_len != 0)
723 && (basename[basename_len-1] != '_'
724 && (field_name[0] != '\0'))) {
725 strncat(basename, "_", PATH_MAX - basename_len);
726 basename_len = strlen(basename);
727 }
728 strncat(basename, field_name, PATH_MAX - basename_len);
729 }
730
731 switch(td->type) {
732 case SEQUENCE:
733 /* Function header */
734 fprintf(fd, "static inline size_t lttng_get_alignment_sequence_%s(\n",
735 basename);
736 print_tabs(2, fd);
2e415130 737 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 738 fprintf(fd, " *obj)\n");
739 fprintf(fd, "{\n");
740 print_tabs(1, fd);
741 fprintf(fd, "size_t align=0, localign;");
742 fprintf(fd, "\n");
743 print_tabs(1, fd);
744 fprintf(fd, "localign = ");
745 if(print_type_alignment(((field_t*)td->fields.array[0])->type,
2e415130 746 fd, 0, basename, ((field_t*)td->fields.array[0])->name)) return 1;
a3e6ce64 747 fprintf(fd, ";\n");
748 print_tabs(1, fd);
749 fprintf(fd, "align = max(align, localign);\n");
750 fprintf(fd, "\n");
751 print_tabs(1, fd);
752 fprintf(fd, "localign = ");
753 if(print_type_alignment(((field_t*)td->fields.array[1])->type,
2e415130 754 fd, 0, basename, ((field_t*)td->fields.array[1])->name)) return 1;
a3e6ce64 755 fprintf(fd, ";\n");
756 print_tabs(1, fd);
757 fprintf(fd, "align = max(align, localign);\n");
758 fprintf(fd, "\n");
759 print_tabs(1, fd);
760 fprintf(fd, "return align;\n");
761 break;
762 case STRUCT:
763 /* Function header */
764 fprintf(fd, "static inline size_t lttng_get_alignment_struct_%s(\n",
765 basename);
766 print_tabs(2, fd);
2e415130 767 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 768 fprintf(fd, " *obj)\n");
769 fprintf(fd, "{\n");
770 print_tabs(1, fd);
771 fprintf(fd, "size_t align=0, localign;");
772 fprintf(fd, "\n");
773 for(unsigned int i=0;i<td->fields.position;i++){
774 field_t *field = (field_t*)(td->fields.array[i]);
775 type_descriptor_t *type = field->type;
776 print_tabs(1, fd);
777 fprintf(fd, "localign = ");
778 if(print_type_alignment(type, fd, 0, basename, field->name)) return 1;
779 fprintf(fd, ";\n");
780 print_tabs(1, fd);
781 fprintf(fd, "align = max(align, localign);\n");
782 fprintf(fd, "\n");
783 }
784 print_tabs(1, fd);
785 fprintf(fd, "return align;\n");
786
a67cd958 787 break;
a3e6ce64 788 case UNION:
789 /* Function header */
790 fprintf(fd, "static inline size_t lttng_get_alignment_union_%s(\n",
791 basename);
792 print_tabs(2, fd);
2e415130 793 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 794 fprintf(fd, " *obj)\n");
795 fprintf(fd, "{\n");
796 print_tabs(1, fd);
797 fprintf(fd, "size_t align=0, localign;");
798 fprintf(fd, "\n");
799 for(unsigned int i=0;i<td->fields.position;i++){
800 field_t *field = (field_t*)(td->fields.array[i]);
801 type_descriptor_t *type = field->type;
802 print_tabs(1, fd);
803 fprintf(fd, "localign = ");
804 if(print_type_alignment(type, fd, 0, basename, field->name)) return 1;
805 fprintf(fd, ";\n");
806 print_tabs(1, fd);
807 fprintf(fd, "align = max(align, localign);\n");
808 fprintf(fd, "\n");
809 }
810 print_tabs(1, fd);
811 fprintf(fd, "return align;\n");
812
813 break;
814 case ARRAY:
815 /* Function header */
816 fprintf(fd, "static inline size_t lttng_get_alignment_array_%s(\n",
817 basename);
818 print_tabs(2, fd);
2e415130 819 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 820 fprintf(fd, " obj)\n");
821 fprintf(fd, "{\n");
822 print_tabs(1, fd);
823 fprintf(fd, "return \n");
824 if(print_type_alignment(((field_t*)td->fields.array[0])->type,
2e415130 825 fd, 0, basename, ((field_t*)td->fields.array[0])->name)) return 1;
a3e6ce64 826 fprintf(fd, ";\n");
827 break;
828 default:
829 printf("print_type_alignment_fct : type has no alignment function.\n");
34c1d1b5 830 return 0;
a3e6ce64 831 break;
832 }
833
834
835 /* Function footer */
836 fprintf(fd, "}\n");
837 fprintf(fd, "\n");
838
2e415130 839 return 0;
a3e6ce64 840}
841
842/* print type write function.
843 *
844 * Copied from construct_types_and_fields in LTTV facility.c
845 *
846 * basename is the name which identifies the type (along with a prefix
847 * (possibly)). */
848
849int print_type_write_fct(type_descriptor_t * td, FILE *fd, unsigned int tabs,
850 char *nest_name, char *field_name)
851{
852 char basename[PATH_MAX];
853 unsigned int basename_len = 0;
854
855 strncpy(basename, nest_name, PATH_MAX);
856 basename_len = strlen(basename);
857
858 /* For a named type, we use the type_name directly */
859 if(td->type_name != NULL) {
860 strncpy(basename, td->type_name, PATH_MAX);
861 basename_len = strlen(basename);
862 } else {
863 /* For a unnamed type, there must be a field name, except for
864 * the array. */
865 if((basename_len != 0)
866 && (basename[basename_len-1] != '_'
867 && (field_name[0] != '\0'))) {
868 strncat(basename, "_", PATH_MAX - basename_len);
869 basename_len = strlen(basename);
870 }
871 strncat(basename, field_name, PATH_MAX - basename_len);
872 }
873
34c1d1b5 874 switch(td->type) {
875 case SEQUENCE:
876 case STRUCT:
877 case UNION:
878 case ARRAY:
879 break;
880 default:
881 printf("print_type_write_fct : type has no write function.\n");
882 return 0;
883 break;
884 }
885
a3e6ce64 886 /* Print header */
887 switch(td->type) {
a67cd958 888 case SEQUENCE:
34c1d1b5 889 fprintf(fd, "static inline void lttng_write_sequence_%s(\n",
a3e6ce64 890 basename);
a67cd958 891 break;
a3e6ce64 892 case STRUCT:
6e27ba88 893 fprintf(fd, "static inline void lttng_write_struct_%s(\n", basename);
a67cd958 894 break;
a3e6ce64 895 case UNION:
6e27ba88 896 fprintf(fd, "static inline void lttng_write_union_%s(\n", basename);
a3e6ce64 897 break;
898 case ARRAY:
6e27ba88 899 fprintf(fd, "static inline void lttng_write_array_%s(\n", basename);
a3e6ce64 900 break;
901 default:
902 printf("print_type_write_fct : type has no write function.\n");
a67cd958 903 break;
a67cd958 904 }
905
a3e6ce64 906 print_tabs(2, fd);
907 fprintf(fd, "void *buffer,\n");
908 print_tabs(2, fd);
909 fprintf(fd, "size_t *to_base,\n");
910 print_tabs(2, fd);
911 fprintf(fd, "size_t *to,\n");
912 print_tabs(2, fd);
913 fprintf(fd, "void **from,\n");
914 print_tabs(2, fd);
915 fprintf(fd, "size_t *len,\n");
916 print_tabs(2, fd);
2e415130 917 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 918
919 switch(td->type) {
920 case SEQUENCE:
921 fprintf(fd, " *obj)\n");
922 break;
923 case STRUCT:
924 fprintf(fd, " *obj)\n");
925 break;
926 case UNION:
927 fprintf(fd, " *obj)\n");
928 break;
929 case ARRAY:
930 fprintf(fd, " obj)\n");
931 break;
932 default:
933 printf("print_type_write_fct : type has no write function.\n");
934 break;
935 }
936
937 fprintf(fd, "{\n");
938 print_tabs(1, fd);
939 fprintf(fd, "size_t align, size;\n");
940 fprintf(fd, "\n");
941
942 switch(td->type) {
943 case SEQUENCE:
944 case STRING:
945 print_tabs(1, fd);
946 fprintf(fd, "/* Flush pending memcpy */\n");
947 print_tabs(1, fd);
948 fprintf(fd, "if(*len != 0) {\n");
949 print_tabs(2, fd);
950 fprintf(fd, "if(buffer != NULL)\n");
951 print_tabs(3, fd);
952 fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
953 print_tabs(1, fd);
954 fprintf(fd, "}\n");
955 print_tabs(1, fd);
956 fprintf(fd, "*to += *len;\n");
957 print_tabs(1, fd);
958 fprintf(fd, "*len = 0;\n");
959 fprintf(fd, "\n");
960 break;
961 case STRUCT:
962 case UNION:
963 case ARRAY:
964 break;
965 default:
966 printf("print_type_write_fct : type has no write function.\n");
967 break;
968 }
969
970 print_tabs(1, fd);
34c1d1b5 971 fprintf(fd, "align = ");
2e415130 972 if(print_type_alignment(td, fd, 0, basename, field_name)) return 1;
a3e6ce64 973 fprintf(fd, ";\n");
974 fprintf(fd, "\n");
975 print_tabs(1, fd);
976 fprintf(fd, "if(*len == 0) {\n");
977 print_tabs(2, fd);
978 fprintf(fd, "*to += ltt_align(*to, align); /* align output */\n");
979 print_tabs(1, fd);
980 fprintf(fd, "} else {\n");
981 print_tabs(2, fd);
982 fprintf(fd, "*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */\n");
983 print_tabs(1, fd);
984 fprintf(fd, "}\n");
985 fprintf(fd, "\n");
986
987 /* First, check if the type has a fixed size. If it is the case, then the size
988 * to write is know by the compiler : simply use a sizeof() */
989 if(has_type_fixed_size(td)) {
990 print_tabs(1, fd);
991 fprintf(fd, "/* Contains only fixed size fields : use compiler sizeof() */\n");
992 fprintf(fd, "\n");
993 print_tabs(1, fd);
994 fprintf(fd, "*len += sizeof(");
2e415130 995 if(print_type(td, fd, 0, basename, field_name)) return 1;
a3e6ce64 996 fprintf(fd, ");\n");
997 } else {
998 /* The type contains nested variable size subtypes :
999 * we must write field by field. */
1000 print_tabs(1, fd);
1001 fprintf(fd, "/* Contains variable sized fields : must explode the structure */\n");
1002 fprintf(fd, "\n");
1003
1004 switch(td->type) {
1005 case SEQUENCE:
1006 print_tabs(1, fd);
1007 fprintf(fd, "/* Copy members */\n");
1008 print_tabs(1, fd);
1009 fprintf(fd, "size = sizeof(\n");
1010 if(print_type_write(((field_t*)td->fields.array[0])->type,
2e415130 1011 fd, 1, basename, ((field_t*)td->fields.array[0])->name)) return 1;
a3e6ce64 1012 fprintf(fd, ");\n");
1013 print_tabs(1, fd);
1014 fprintf(fd, "*to += ltt_align(*to, size);\n");
1015 print_tabs(1, fd);
1016 fprintf(fd, "if(buffer != NULL)\n");
1017 print_tabs(2, fd);
1018 fprintf(fd, "memcpy(buffer+*to_base+*to, &obj->len, size);\n");
1019 print_tabs(1, fd);
1020 fprintf(fd, "*to += size;\n");
1021 fprintf(fd, "\n");
1022
1023 /* Write the child : varlen child or not ? */
1024 if(has_type_fixed_size(((field_t*)td->fields.array[1])->type)) {
1025 /* Fixed size len child : use a multiplication of its size */
1026 print_tabs(1, fd);
1027 fprintf(fd, "size = sizeof(\n");
1028 if(print_type_write(((field_t*)td->fields.array[1])->type,
2e415130 1029 fd, 1, basename, ((field_t*)td->fields.array[1])->name)) return 1;
a3e6ce64 1030 fprintf(fd, ");\n");
1031 print_tabs(1, fd);
1032 fprintf(fd, "*to += ltt_align(*to, size);\n");
1033 print_tabs(1, fd);
1034 fprintf(fd, "size = obj->len * size;\n");
1035 print_tabs(1, fd);
1036 fprintf(fd, "if(buffer != NULL)\n");
1037 print_tabs(2, fd);
1038 fprintf(fd, "memcpy(buffer+*to_base+*to, obj->array, size);\n");
1039 print_tabs(1, fd);
1040 fprintf(fd, "*to += size;\n");
1041 fprintf(fd, "\n");
1042 } else {
1043 print_tabs(1, fd);
1044 fprintf(fd, "/* Variable length child : iter. */\n");
1045 print_tabs(1, fd);
1046 fprintf(fd, "for(unsigned int i=0; i<obj->len; i++) {\n");
1047 if(print_type_write(((field_t*)td->fields.array[1])->type,
2e415130 1048 fd, 2, basename, ((field_t*)td->fields.array[1])->name)) return 1;
a3e6ce64 1049 print_tabs(1, fd);
1050 fprintf(fd, "}\n");
1051 }
1052 fprintf(fd, "\n");
1053 print_tabs(1, fd);
1054 fprintf(fd, "/* Realign the *to_base on arch size, set *to to 0 */\n");
1055 print_tabs(1, fd);
1056 fprintf(fd, "*to = ltt_align(*to, sizeof(void *));\n");
1057 print_tabs(1, fd);
1058 fprintf(fd, "*to_base = *to_base+*to;\n");
1059 print_tabs(1, fd);
1060 fprintf(fd, "*to = 0;\n");
1061 fprintf(fd, "\n");
1062 fprintf(fd, "/* Put source *from just after the C sequence */\n");
1063 print_tabs(1, fd);
1064 fprintf(fd, "*from = obj+1;\n");
1065 break;
1066 case STRING:
1067 fprintf(fd, "size = strlen(obj);\n");
1068 print_tabs(1, fd);
1069 fprintf(fd, "if(buffer != NULL)\n");
1070 print_tabs(2, fd);
1071 fprintf(fd, "memcpy(buffer+*to_base+*to, obj, size);\n");
1072 print_tabs(1, fd);
1073 fprintf(fd, "*to += size;\n");
1074 fprintf(fd, "\n");
1075 print_tabs(1, fd);
1076 fprintf(fd, "/* Realign the *to_base on arch size, set *to to 0 */\n");
1077 print_tabs(1, fd);
1078 fprintf(fd, "*to = ltt_align(*to, sizeof(void *));\n");
1079 print_tabs(1, fd);
1080 fprintf(fd, "*to_base = *to_base+*to;\n");
1081 print_tabs(1, fd);
1082 fprintf(fd, "*to = 0;\n");
1083 fprintf(fd, "\n");
1084 fprintf(fd, "/* Put source *from just after the C sequence */\n");
1085 print_tabs(1, fd);
1086 fprintf(fd, "*from = obj+1;\n");
1087 break;
1088 case STRUCT:
1089 for(unsigned int i=0;i<td->fields.position;i++){
1090 field_t *field = (field_t*)(td->fields.array[i]);
1091 type_descriptor_t *type = field->type;
1092 if(print_type_write(type,
1093 fd, 1, basename, field->name)) return 1;
1094 fprintf(fd, "\n");
1095 }
1096 break;
1097 case UNION:
1098 printf("ERROR : A union CANNOT contain a variable size child.\n");
1099 return 1;
1100 break;
1101 case ARRAY:
1102 /* Write the child : varlen child or not ? */
1103 if(has_type_fixed_size(((field_t*)td->fields.array[0])->type)) {
1104 /* Error : if an array has a variable size, then its child must also
1105 * have a variable size. */
1106 assert(0);
1107 } else {
1108 print_tabs(1, fd);
1109 fprintf(fd, "/* Variable length child : iter. */\n");
1110 print_tabs(1, fd);
1111 fprintf(fd, "for(unsigned int i=0; i<LTTNG_ARRAY_SIZE_%s; i++) {\n", basename);
1112 if(print_type_write(((field_t*)td->fields.array[1])->type,
2e415130 1113 fd, 2, basename, ((field_t*)td->fields.array[1])->name)) return 1;
a3e6ce64 1114 print_tabs(1, fd);
1115 fprintf(fd, "}\n");
1116 }
1117 break;
1118 default:
1119 printf("print_type_write_fct : type has no write function.\n");
1120 break;
1121 }
1122
1123
1124 }
1125
1126
1127 /* Function footer */
1128 fprintf(fd, "}\n");
1129 fprintf(fd, "\n");
a67cd958 1130 return 0;
1131}
1132
1133
1134
47299663 1135/* Print the logging function of an event. This is the core of genevent */
a3e6ce64 1136int print_event_logging_function(char *basename, facility_t *fac,
1137 event_t *event, FILE *fd)
47299663 1138{
1139 fprintf(fd, "static inline void trace_%s(\n", basename);
1140 for(unsigned int j = 0; j < event->fields.position; j++) {
1141 /* For each field, print the function argument */
1142 field_t *f = (field_t*)event->fields.array[j];
1143 type_descriptor_t *t = f->type;
7e97b039 1144 if(print_arg(t, fd, 2, basename, f->name)) return 1;
47299663 1145 if(j < event->fields.position-1) {
1146 fprintf(fd, ",");
1147 fprintf(fd, "\n");
1148 }
1149 }
1150 if(event->fields.position == 0) {
1151 print_tabs(2, fd);
1152 fprintf(fd, "void");
1153 }
1154 fprintf(fd,")\n");
1155 fprintf(fd, "#ifndef CONFIG_LTT\n");
1156 fprintf(fd, "{\n");
1157 fprintf(fd, "}\n");
1158 fprintf(fd,"#else\n");
1159 fprintf(fd, "{\n");
7e97b039 1160 /* Print the function variables */
a67cd958 1161 print_tabs(1, fd);
a3e6ce64 1162 fprintf(fd, "unsigned int index;\n");
1163 print_tabs(1, fd);
1164 fprintf(fd, "struct ltt_channel_struct *channel;\n");
1165 print_tabs(1, fd);
1166 fprintf(fd, "struct ltt_trace_struct *trace;\n");
1167 print_tabs(1, fd);
1168 fprintf(fd, "struct rchan_buf *relayfs_buf;\n");
1169 print_tabs(1, fd);
1170 fprintf(fd, "void *buffer = NULL;\n");
1171 print_tabs(1, fd);
1172 fprintf(fd, "size_t to_base = 0; /* The buffer is allocated on arch_size alignment */\n");
1173 print_tabs(1, fd);
1174 fprintf(fd, "size_t to = 0;\n");
1175 print_tabs(1, fd);
1176 fprintf(fd, "void *from;");
1177 print_tabs(1, fd);
1178 fprintf(fd, "size_t len = 0;\n");
30d72138 1179 print_tabs(1, fd);
6e27ba88 1180 fprintf(fd, "size_t reserve_size;\n");
1181 print_tabs(1, fd);
a3e6ce64 1182 fprintf(fd, "size_t slot_size;\n");
30d72138 1183 print_tabs(1, fd);
a3e6ce64 1184 fprintf(fd, "cycles_t tsc;\n");
30d72138 1185 print_tabs(1, fd);
a3e6ce64 1186 fprintf(fd, "size_t before_hdr_pad, size_t after_hdr_pad;\n");
1187 fprintf(fd, "\n");
7e97b039 1188
a3e6ce64 1189 print_tabs(1, fd);
1190 fprintf(fd, "if(ltt_traces.num_active_traces == 0) return;\n");
1191 fprintf(fd, "\n");
1192
a67cd958 1193 /* Calculate event variable len + event data alignment offset.
7e97b039 1194 * Assume that the padding for alignment starts at a void*
a67cd958 1195 * address.
1196 * This excludes the header size and alignment. */
1197
a3e6ce64 1198 print_tabs(1, fd);
1199 fprintf(fd, "/* For each field, calculate the field size. */\n");
1200 print_tabs(1, fd);
1201 fprintf(fd, "/* size = to_base + to + len */\n");
1202 print_tabs(1, fd);
30d72138 1203 fprintf(fd, "/* Assume that the padding for alignment starts at a\n");
a3e6ce64 1204 print_tabs(1, fd);
30d72138 1205 fprintf(fd, " * sizeof(void *) address. */\n");
a3e6ce64 1206 fprintf(fd, "\n");
a67cd958 1207
a3e6ce64 1208 for(unsigned int i=0;i<event->fields.position;i++){
2e415130 1209 field_t *field = (field_t*)(event->fields.array[i]);
a3e6ce64 1210 type_descriptor_t *type = field->type;
1211 if(print_type_write(type,
1212 fd, 1, basename, field->name)) return 1;
1213 fprintf(fd, "\n");
a67cd958 1214 }
6e27ba88 1215 print_tabs(1, fd);
1216 fprintf(fd, "reserve_size = to_base + to + len;\n");
1217 print_tabs(1, fd);
1218 fprintf(fd, "to_base = to = len = 0;\n");
30d72138 1219 fprintf(fd, "\n");
47299663 1220
7e97b039 1221 /* Take locks : make sure the trace does not vanish while we write on
1222 * it. A simple preemption disabling is enough (using rcu traces). */
a3e6ce64 1223 print_tabs(1, fd);
1224 fprintf(fd, "preempt_disable();\n");
1225 print_tabs(1, fd);
1226 fprintf(fd, "ltt_nesting[smp_processor_id()]++;\n");
1227
1228 /* Get facility index */
1229
1230 if(event->per_tracefile) {
1231 print_tabs(1, fd);
1232 fprintf(fd, "index = tracefile_index;\n");
1233 } else {
1234 print_tabs(1, fd);
1235 fprintf(fd,
1236 "index = ltt_get_index_from_facility(ltt_facility_%s_%X,\n"\
30d72138 1237 "\t\t\t\t\t\tevent_%s);\n",
a3e6ce64 1238 fac->name, fac->checksum, event->name);
1239 }
1240 fprintf(fd,"\n");
1241
7e97b039 1242
1243 /* For each trace */
a3e6ce64 1244 print_tabs(1, fd);
1245 fprintf(fd, "list_for_each_entry_rcu(trace, &ltt_traces.head, list) {\n");
1246 print_tabs(2, fd);
1247 fprintf(fd, "if(!trace->active) continue;\n\n");
1248
1249 if(event->per_trace) {
1250 print_tabs(2, fd);
1251 fprintf(fd, "if(dest_trace != trace) continue;\n\n");
1252 }
1253
1254 print_tabs(2, fd);
2e415130 1255 fprintf(fd, "channel = ltt_get_channel_from_index(trace, index);\n");
a3e6ce64 1256 print_tabs(2, fd);
1257 fprintf(fd, "relayfs_buf = channel->rchan->buf[channel->rchan->buf->cpu];\n");
1258 fprintf(fd, "\n");
1259
7e97b039 1260
1261 /* Relay reserve */
a3e6ce64 1262 /* If error, increment event lost counter (done by ltt_reserve_slot) and
1263 * return */
1264 print_tabs(2, fd);
1265 fprintf(fd, "slot_size = 0;\n");
1266 print_tabs(2, fd);
30d72138 1267 fprintf(fd, "buffer = ltt_reserve_slot(trace, relayfs_buf,\n");
1268 print_tabs(3, fd);
6e27ba88 1269 fprintf(fd, "reserve_size, &slot_size, &tsc,\n");
30d72138 1270 print_tabs(3, fd);
1271 fprintf(fd, "&before_hdr_pad, &after_hdr_pad);\n");
a3e6ce64 1272 /* If error, return */
1273 print_tabs(2, fd);
1274 fprintf(fd, "if(!buffer) return;\n\n");
7e97b039 1275
a3e6ce64 1276 /* write data : assume stack alignment is the same as struct alignment. */
1277
1278 for(unsigned int i=0;i<event->fields.position;i++){
2e415130 1279 field_t *field = (field_t*)(event->fields.array[i]);
a3e6ce64 1280 type_descriptor_t *type = field->type;
1281
1282 /* Set from */
30d72138 1283 print_tabs(2, fd);
1284 switch(type->type) {
1285 case SEQUENCE:
1286 case UNION:
1287 case ARRAY:
1288 case STRUCT:
1289 case STRING:
1290 fprintf(fd, "from = %s;\n", field->name);
1291 break;
1292 default:
1293 fprintf(fd, "from = &%s;\n", field->name);
1294 break;
1295 }
1296
a3e6ce64 1297
1298 if(print_type_write(type,
1299 fd, 2, basename, field->name)) return 1;
1300 fprintf(fd, "\n");
7e97b039 1301
a3e6ce64 1302 /* Don't forget to flush pending memcpy */
1303 print_tabs(2, fd);
1304 fprintf(fd, "/* Flush pending memcpy */\n");
1305 print_tabs(2, fd);
1306 fprintf(fd, "if(len != 0) {\n");
1307 print_tabs(3, fd);
1308 fprintf(fd, "memcpy(buffer+to_base+to, from, len);\n");
1309 print_tabs(3, fd);
1310 fprintf(fd, "to += len;\n");
1311 //print_tabs(3, fd);
1312 //fprintf(fd, "from += len;\n");
1313 print_tabs(3, fd);
1314 fprintf(fd, "len = 0;\n");
1315 print_tabs(2, fd);
1316 fprintf(fd, "}\n");
1317 fprintf(fd, "\n");
1318 }
1319
1320
7e97b039 1321 /* commit */
a3e6ce64 1322 print_tabs(2, fd);
1323 fprintf(fd, "ltt_commit_slot(relayfs_buf, buffer, slot_size);\n\n");
7e97b039 1324
a3e6ce64 1325 print_tabs(1, fd);
1326 fprintf(fd, "}\n\n");
1327
7e97b039 1328 /* Release locks */
a3e6ce64 1329 print_tabs(1, fd);
1330 fprintf(fd, "ltt_nesting[smp_processor_id()]--;\n");
1331 print_tabs(1, fd);
1332 fprintf(fd, "preempt_enable_no_resched();\n");
2d2d14a7 1333
47299663 1334 fprintf(fd, "}\n");
1335 fprintf(fd, "#endif //CONFIG_LTT\n\n");
1336 return 0;
1337}
2d2d14a7 1338
1339
1340/* ltt-facility-name.h : main logging header.
1341 * log_header */
1342
1343void print_log_header_head(facility_t *fac, FILE *fd)
1344{
1345 fprintf(fd, "#ifndef _LTT_FACILITY_%s_H_\n", fac->capname);
1346 fprintf(fd, "#define _LTT_FACILITY_%s_H_\n\n", fac->capname);
47299663 1347 fprintf(fd, "\n");
1348 fprintf(fd, "/* Facility activation at compile time. */\n");
1349 fprintf(fd, "#ifdef CONFIG_LTT_FACILITY_%s\n\n", fac->capname);
2d2d14a7 1350}
1351
1352
1353
2d2d14a7 1354int print_log_header_types(facility_t *fac, FILE *fd)
1355{
1356 sequence_t *types = &fac->named_types.values;
1357 fprintf(fd, "/* Named types */\n");
1358 fprintf(fd, "\n");
1359
1360 for(unsigned int i = 0; i < types->position; i++) {
1361 /* For each named type, print the definition */
1362 if((print_type_declaration(types->array[i], fd,
1363 0, "", ""))) return 1;
34c1d1b5 1364 /* Print also the align function */
1365 if((print_type_alignment_fct(types->array[i], fd,
1366 0, "", ""))) return 1;
1367 /* Print also the write function */
1368 if((print_type_write_fct(types->array[i], fd,
1369 0, "", ""))) return 1;
2d2d14a7 1370 }
1371 return 0;
1372}
1373
1374int print_log_header_events(facility_t *fac, FILE *fd)
1375{
47299663 1376 sequence_t *events = &fac->events;
1377 char basename[PATH_MAX];
1378 unsigned int facname_len;
1379
1380 strncpy(basename, fac->name, PATH_MAX);
1381 facname_len = strlen(basename);
1382 strncat(basename, "_", PATH_MAX-facname_len);
1383 facname_len = strlen(basename);
1384
1385 for(unsigned int i = 0; i < events->position; i++) {
1386 event_t *event = (event_t*)events->array[i];
1387 strncpy(&basename[facname_len], event->name, PATH_MAX-facname_len);
1388
1389 /* For each event, print structure, and then logging function */
1390 fprintf(fd, "/* Event %s structures */\n",
1391 event->name);
1392 for(unsigned int j = 0; j < event->fields.position; j++) {
1393 /* For each unnamed type, print the definition */
1394 field_t *f = (field_t*)event->fields.array[j];
1395 type_descriptor_t *t = f->type;
34c1d1b5 1396 if(t->type_name == NULL) {
47299663 1397 if((print_type_declaration(t, fd, 0, basename, f->name))) return 1;
34c1d1b5 1398 /* Print also the align function */
1399 if((print_type_alignment_fct(t, fd, 0, basename, f->name))) return 1;
1400 /* Print also the write function */
1401 if((print_type_write_fct(t, fd, 0, basename, f->name))) return 1;
1402 }
47299663 1403 }
34c1d1b5 1404
47299663 1405 fprintf(fd, "\n");
2d2d14a7 1406
47299663 1407 fprintf(fd, "/* Event %s logging function */\n",
1408 event->name);
1409
a3e6ce64 1410 if(print_event_logging_function(basename, fac, event, fd)) return 1;
47299663 1411
1412 fprintf(fd, "\n");
1413 }
1414
2d2d14a7 1415 return 0;
1416}
1417
1418
1419void print_log_header_tail(facility_t *fac, FILE *fd)
1420{
47299663 1421 fprintf(fd, "#endif //CONFIG_LTT_FACILITY_%s\n\n", fac->capname);
2d2d14a7 1422 fprintf(fd, "#endif //_LTT_FACILITY_%s_H_\n",fac->capname);
1423}
1424
1425int print_log_header(facility_t *fac)
1426{
1427 char filename[PATH_MAX];
1428 unsigned int filename_size = 0;
1429 FILE *fd;
1430 dprintf("%s\n", fac->name);
1431
1432 strcpy(filename, "ltt-facility-");
1433 filename_size = strlen(filename);
1434
1435 strncat(filename, fac->name, PATH_MAX - filename_size);
1436 filename_size = strlen(filename);
1437
1438 strncat(filename, ".h", PATH_MAX - filename_size);
1439 filename_size = strlen(filename);
1440
1441
1442 fd = fopen(filename, "w");
1443 if(fd == NULL) {
1444 printf("Error opening file %s for writing : %s\n",
1445 filename, strerror(errno));
1446 return errno;
1447 }
1448
1449 /* Print file head */
1450 print_log_header_head(fac, fd);
1451
1452 /* print named types in declaration order */
1453 if(print_log_header_types(fac, fd)) return 1;
1454
1455 /* Print events */
1456 if(print_log_header_events(fac, fd)) return 1;
1457
1458 /* Print file tail */
1459 print_log_header_tail(fac, fd);
1460
1461
1462 fclose(fd);
1463
1464 return 0;
1465}
1466
1467
1468/* ltt-facility-id-name.h : facility id.
1469 * log_id_header */
1470int print_id_header(facility_t *fac)
1471{
1472 char filename[PATH_MAX];
1473 unsigned int filename_size = 0;
1474 FILE *fd;
1475 dprintf("%s\n", fac->name);
1476
1477 strcpy(filename, "ltt-facility-id-");
1478 filename_size = strlen(filename);
1479
1480 strncat(filename, fac->name, PATH_MAX - filename_size);
1481 filename_size = strlen(filename);
1482
1483 strncat(filename, ".h", PATH_MAX - filename_size);
1484 filename_size = strlen(filename);
1485
1486
1487 fd = fopen(filename, "w");
1488 if(fd == NULL) {
1489 printf("Error opening file %s for writing : %s\n",
1490 filename, strerror(errno));
1491 return errno;
1492 }
1493
1494 fclose(fd);
1495
1496 return 0;
1497}
1498
1499
1500/* ltt-facility-loader-name.h : facility specific loader info.
1501 * loader_header */
1502int print_loader_header(facility_t *fac)
1503{
1504 char filename[PATH_MAX];
1505 unsigned int filename_size = 0;
1506 FILE *fd;
1507 dprintf("%s\n", fac->name);
1508
1509 strcpy(filename, "ltt-facility-loader-");
1510 filename_size = strlen(filename);
1511
1512 strncat(filename, fac->name, PATH_MAX - filename_size);
1513 filename_size = strlen(filename);
1514
1515 strncat(filename, ".h", PATH_MAX - filename_size);
1516 filename_size = strlen(filename);
1517
1518
1519 fd = fopen(filename, "w");
1520 if(fd == NULL) {
1521 printf("Error opening file %s for writing : %s\n",
1522 filename, strerror(errno));
1523 return errno;
1524 }
1525
1526 fclose(fd);
1527
1528 return 0;
1529}
1530
1531/* ltt-facility-loader-name.c : generic faciilty loader
1532 * loader_c */
1533int print_loader_c(facility_t *fac)
1534{
1535 char filename[PATH_MAX];
1536 unsigned int filename_size = 0;
1537 FILE *fd;
1538 dprintf("%s\n", fac->name);
1539
1540 strcpy(filename, "ltt-facility-loader-");
1541 filename_size = strlen(filename);
1542
1543 strncat(filename, fac->name, PATH_MAX - filename_size);
1544 filename_size = strlen(filename);
1545
1546 strncat(filename, ".c", PATH_MAX - filename_size);
1547 filename_size = strlen(filename);
1548
1549
1550 fd = fopen(filename, "w");
1551 if(fd == NULL) {
1552 printf("Error opening file %s for writing : %s\n",
1553 filename, strerror(errno));
1554 return errno;
1555 }
1556
1557
1558 fclose(fd);
1559
1560 return 0;
1561}
1562
1563
1564
92d82357 1565/* open facility */
1566/* code taken from ltt_facility_open in ltt/facility.c in lttv */
1567
1568/*****************************************************************************
1569 *Function name
1570 * ltt_facility_open : open facilities
1571 *Input params
1572 * pathname : the path name of the facility
1573 *
1574 * Open the facility corresponding to the right checksum.
1575 *
1576 *returns the facility on success, NULL on error.
1577 ****************************************************************************/
1578facility_t *ltt_facility_open(char * pathname)
1579{
1580 int ret = 0;
1581 char *token;
1582 parse_file_t in;
1583 facility_t * fac = NULL;
92d82357 1584 char buffer[BUFFER_SIZE];
1585 int generated = FALSE;
1586
1587 in.buffer = &(buffer[0]);
1588 in.lineno = 0;
1589 in.error = error_callback;
1590 in.name = pathname;
1591 in.unget = 0;
1592
1593 in.fp = fopen(in.name, "r");
1594 if(in.fp == NULL) {
1595 ret = 1;
1596 goto open_error;
1597 }
1598
1599 while(1){
1600 token = getToken(&in);
1601 if(in.type == ENDFILE) break;
1602
1603 if(generated) {
1604 printf("More than one facility in the file. Only using the first one.\n");
1605 break;
1606 }
1607
1608 if(strcmp(token, "<")) in.error(&in,"not a facility file");
1609 token = getName(&in);
1610
1611 if(strcmp("facility",token) == 0) {
1612 fac = malloc(sizeof(facility_t));
1613 fac->name = NULL;
1614 fac->description = NULL;
1615 sequence_init(&(fac->events));
1616 table_init(&(fac->named_types));
1617 sequence_init(&(fac->unnamed_types));
1618
1619 parseFacility(&in, fac);
1620
1621 //check if any namedType is not defined
1622 checkNamedTypesImplemented(&fac->named_types);
1623
2e415130 1624 generateChecksum(fac->name, &fac->checksum, &fac->events);
a67cd958 1625
92d82357 1626 generated = TRUE;
1627 }
1628 else {
1629 printf("facility token was expected in file %s\n", in.name);
1630 ret = 1;
1631 goto parse_error;
1632 }
1633 }
1634
1635 parse_error:
1636 fclose(in.fp);
1637open_error:
1638
1639 if(!generated) {
1640 printf("Cannot find facility %s\n", pathname);
1641 fac = NULL;
1642 }
1643
1644 return fac;
1645}
1646
1647/* Close the facility */
1648void ltt_facility_close(facility_t *fac)
1649{
1650 free(fac->name);
1651 free(fac->capname);
1652 free(fac->description);
1653 freeEvents(&fac->events);
1654 sequence_dispose(&fac->events);
1655 freeNamedType(&fac->named_types);
1656 table_dispose(&fac->named_types);
1657 freeTypes(&fac->unnamed_types);
1658 sequence_dispose(&fac->unnamed_types);
1659 free(fac);
1660}
1661
1662
1663/* Show help */
1664void show_help(int argc, char ** argv)
1665{
1666 printf("Genevent help : \n");
1667 printf("\n");
1668 printf("Use %s name.xml\n", argv[0]);
1669 printf("to create :\n");
1670 printf("ltt-facility-name.h\n");
1671 printf("ltt-facility-id-name.h\n");
1672 printf("ltt-facility-loader-name.h\n");
1673 printf("ltt-facility-loader-name.c\n");
1674 printf("In the current directory.\n");
1675 printf("\n");
1676}
1677
1678/* Parse program arguments */
1679/* Return values :
1680 * 0 : continue program
1681 * -1 : stop program, return 0
1682 * > 0 : stop program, return value as exit.
1683 */
1684int check_args(int argc, char **argv)
1685{
1686 if(argc < 2) {
1687 printf("Not enough arguments\n");
1688 show_help(argc, argv);
1689 return EINVAL;
1690 }
1691
1692 if(strcmp(argv[1], "-h") == 0) {
1693 show_help(argc, argv);
1694 return -1;
1695 }
1696
1697 return 0;
1698}
1699
1700int main(int argc, char **argv)
1701{
1702 int err = 0;
1703 facility_t *fac;
1704
1705 err = check_args(argc, argv);
1706 if(err > 0) return err;
1707 else if(err < 0) return 0;
1708
1709 /* open the facility */
1710 fac = ltt_facility_open(argv[1]);
1711 if(fac == NULL) {
1712 printf("Error opening file %s for reading : %s\n",
1713 argv[1], strerror(errno));
1714 return errno;
1715 }
1716
1717 /* generate the output C files */
1718
1719
2d2d14a7 1720 /* ltt-facility-name.h : main logging header.
1721 * log_header */
1722 err = print_log_header(fac);
1723 if(err) return err;
92d82357 1724
2d2d14a7 1725 /* ltt-facility-id-name.h : facility id.
1726 * log_id_header */
1727 err = print_id_header(fac);
1728 if(err) return err;
92d82357 1729
2d2d14a7 1730 /* ltt-facility-loader-name.h : facility specific loader info.
1731 * loader_header */
1732 err = print_loader_header(fac);
1733 if(err) return err;
1734
1735 /* ltt-facility-loader-name.c : generic faciilty loader
1736 * loader_c */
1737 err = print_loader_c(fac);
1738 if(err) return err;
92d82357 1739
1740 /* close the facility */
1741 ltt_facility_close(fac);
1742
1743 return 0;
1744}
1745
1746
LTTng 2.x Viewer (LTTV)
This page took 0.097355 seconds and 4 git commands to generate.