projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
update quickstart
[lttv.git] / genevent / 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
922b1092 89
90enum user_fct_types { USER_FCT_PROTO, USER_FCT_DECLARATION } ;
91
92d82357 92/* Code printing */
93
2d2d14a7 94void print_tabs(unsigned int tabs, FILE *fd)
95{
96 for(unsigned int i = 0; i<tabs;i++)
97 fprintf(fd, "\t");
98}
99
2d2d14a7 100/* print type.
101 *
102 * Copied from construct_types_and_fields in LTTV facility.c */
103
104int print_type(type_descriptor_t * td, FILE *fd, unsigned int tabs,
105 char *nest_name, char *field_name)
106{
107 char basename[PATH_MAX];
108 unsigned int basename_len = 0;
109
110 strcpy(basename, nest_name);
111 basename_len = strlen(basename);
112
113 /* For a named type, we use the type_name directly */
114 if(td->type_name != NULL) {
115 strncpy(basename, td->type_name, PATH_MAX);
116 basename_len = strlen(basename);
117 } else {
118 /* For a unnamed type, there must be a field name */
7b175edc 119 if((basename_len != 0)
120 && (basename[basename_len-1] != '_')
121 && (field_name[0] != '\0')) {
2d2d14a7 122 strncat(basename, "_", PATH_MAX - basename_len);
123 basename_len = strlen(basename);
124 }
125 strncat(basename, field_name, PATH_MAX - basename_len);
126 }
127
128 switch(td->type) {
129 case INT_FIXED:
130 fprintf(fd, "%s", intOutputTypes[getSizeindex(td->size)]);
131 break;
132 case UINT_FIXED:
133 fprintf(fd, "%s", uintOutputTypes[getSizeindex(td->size)]);
134 break;
135 case CHAR:
136 fprintf(fd, "signed char");
137 break;
138 case UCHAR:
139 fprintf(fd, "unsigned char");
140 break;
141 case SHORT:
142 fprintf(fd, "short");
143 break;
144 case USHORT:
145 fprintf(fd, "unsigned short");
146 break;
147 case INT:
148 fprintf(fd, "int");
149 break;
150 case UINT:
151 fprintf(fd, "unsigned int");
152 break;
153 case FLOAT:
154 fprintf(fd, "%s", floatOutputTypes[getSizeindex(td->size)]);
155 break;
156 case POINTER:
458989d8 157 fprintf(fd, "const void *");
2d2d14a7 158 break;
159 case LONG:
160 fprintf(fd, "long");
161 break;
162 case ULONG:
163 fprintf(fd, "unsigned long");
164 break;
165 case SIZE_T:
166 fprintf(fd, "size_t");
167 break;
168 case SSIZE_T:
169 fprintf(fd, "ssize_t");
170 break;
171 case OFF_T:
172 fprintf(fd, "off_t");
173 break;
174 case STRING:
3d9b9b0c 175 fprintf(fd, "const char *");
2d2d14a7 176 break;
177 case ENUM:
178 fprintf(fd, "enum lttng_%s", basename);
179 break;
180 case ARRAY:
181 fprintf(fd, "lttng_array_%s", basename);
182 break;
183 case SEQUENCE:
184 fprintf(fd, "lttng_sequence_%s", basename);
185 break;
186 case STRUCT:
187 fprintf(fd, "struct lttng_%s", basename);
188 break;
189 case UNION:
190 fprintf(fd, "union lttng_%s", basename);
191 break;
192 default:
193 printf("print_type : unknown type\n");
194 return 1;
195 }
196
197 return 0;
198}
199
7e97b039 200/* Print logging function argument */
201int print_arg(type_descriptor_t * td, FILE *fd, unsigned int tabs,
202 char *nest_name, char *field_name)
203{
204 char basename[PATH_MAX];
205 unsigned int basename_len = 0;
206
207 strcpy(basename, nest_name);
208 basename_len = strlen(basename);
209
210 /* For a named type, we use the type_name directly */
211 if(td->type_name != NULL) {
212 strncpy(basename, td->type_name, PATH_MAX);
213 basename_len = strlen(basename);
214 } else {
215 /* For a unnamed type, there must be a field name */
216 if((basename_len != 0)
217 && (basename[basename_len-1] != '_')
218 && (field_name[0] != '\0')) {
219 strncat(basename, "_", PATH_MAX - basename_len);
220 basename_len = strlen(basename);
221 }
222 strncat(basename, field_name, PATH_MAX - basename_len);
223 }
224
225 print_tabs(tabs, fd);
226
227 switch(td->type) {
228 case INT_FIXED:
229 fprintf(fd, "%s", intOutputTypes[getSizeindex(td->size)]);
1f42154b 230 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 231 break;
232 case UINT_FIXED:
233 fprintf(fd, "%s", uintOutputTypes[getSizeindex(td->size)]);
1f42154b 234 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 235 break;
236 case CHAR:
237 fprintf(fd, "signed char");
3ace7bc4 238 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 239 break;
240 case UCHAR:
241 fprintf(fd, "unsigned char");
3ace7bc4 242 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 243 break;
244 case SHORT:
245 fprintf(fd, "short");
3ace7bc4 246 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 247 break;
248 case USHORT:
249 fprintf(fd, "unsigned short");
3ace7bc4 250 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 251 break;
252 case INT:
253 fprintf(fd, "int");
3ace7bc4 254 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 255 break;
256 case UINT:
257 fprintf(fd, "unsigned int");
3ace7bc4 258 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 259 break;
260 case FLOAT:
261 fprintf(fd, "%s", floatOutputTypes[getSizeindex(td->size)]);
3ace7bc4 262 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 263 break;
264 case POINTER:
458989d8 265 fprintf(fd, "const void *");
3ace7bc4 266 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 267 break;
268 case LONG:
269 fprintf(fd, "long");
3ace7bc4 270 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 271 break;
272 case ULONG:
273 fprintf(fd, "unsigned long");
3ace7bc4 274 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 275 break;
276 case SIZE_T:
277 fprintf(fd, "size_t");
3ace7bc4 278 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 279 break;
280 case SSIZE_T:
281 fprintf(fd, "ssize_t");
3ace7bc4 282 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 283 break;
284 case OFF_T:
285 fprintf(fd, "off_t");
3ace7bc4 286 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 287 break;
288 case STRING:
3d9b9b0c 289 fprintf(fd, "const char *");
3ace7bc4 290 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 291 break;
292 case ENUM:
293 fprintf(fd, "enum lttng_%s", basename);
3ace7bc4 294 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 295 break;
296 case ARRAY:
297 fprintf(fd, "lttng_array_%s", basename);
3ace7bc4 298 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 299 break;
300 case SEQUENCE:
301 fprintf(fd, "lttng_sequence_%s *", basename);
3ace7bc4 302 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 303 break;
304 case STRUCT:
305 fprintf(fd, "struct lttng_%s *", basename);
3ace7bc4 306 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 307 break;
308 case UNION:
309 fprintf(fd, "union lttng_%s *", basename);
3ace7bc4 310 fprintf(fd, " lttng_param_%s", field_name);
7e97b039 311 break;
312 default:
313 printf("print_type : unknown type\n");
314 return 1;
315 }
316
317 return 0;
318}
319
320
a3e6ce64 321/* Does the type has a fixed size ? (as know from the compiler)
322 *
323 * 1 : fixed size
324 * 0 : variable length
325 */
326int has_type_fixed_size(type_descriptor_t *td)
327{
328 switch(td->type) {
329 case INT_FIXED:
330 case UINT_FIXED:
331 case CHAR:
332 case UCHAR:
333 case SHORT:
334 case USHORT:
335 case INT:
336 case UINT:
337 case FLOAT:
338 case POINTER:
339 case LONG:
340 case ULONG:
341 case SIZE_T:
342 case SSIZE_T:
343 case OFF_T:
344 case ENUM:
345 case UNION: /* The union must have fixed size children. Must be checked by
346 the parser */
347 return 1;
348 break;
349 case STRING:
350 case SEQUENCE:
351 return 0;
352 break;
353 case STRUCT:
354 {
355 int has_type_fixed = 0;
356 for(unsigned int i=0;i<td->fields.position;i++){
357 field_t *field = (field_t*)(td->fields.array[i]);
358 type_descriptor_t *type = field->type;
359
360 has_type_fixed = has_type_fixed_size(type);
361 if(!has_type_fixed) return 0;
362 }
363 return 1;
364 }
365 break;
366 case ARRAY:
367 assert(td->size >= 0);
2e415130 368 return has_type_fixed_size(((field_t*)td->fields.array[0])->type);
369 break;
370 case NONE:
371 printf("There is a type defined to NONE : bad.\n");
372 assert(0);
a3e6ce64 373 break;
374 }
2e415130 375 return 0; //make gcc happy.
a3e6ce64 376}
377
378
379
380
381
2d2d14a7 382/* print type declaration.
383 *
384 * Copied from construct_types_and_fields in LTTV facility.c */
385
386int print_type_declaration(type_descriptor_t * td, FILE *fd, unsigned int tabs,
387 char *nest_name, char *field_name)
388{
389 char basename[PATH_MAX];
390 unsigned int basename_len = 0;
391
64a6ab10 392 if(td->custom_write) return 0; /* Does print custom type */
393
7b175edc 394 strncpy(basename, nest_name, PATH_MAX);
2d2d14a7 395 basename_len = strlen(basename);
396
397 /* For a named type, we use the type_name directly */
398 if(td->type_name != NULL) {
399 strncpy(basename, td->type_name, PATH_MAX);
400 basename_len = strlen(basename);
401 } else {
7b175edc 402 /* For a unnamed type, there must be a field name, except for
403 * the array. */
404 if((basename_len != 0)
405 && (basename[basename_len-1] != '_'
406 && (field_name[0] != '\0'))) {
2d2d14a7 407 strncat(basename, "_", PATH_MAX - basename_len);
408 basename_len = strlen(basename);
409 }
410 strncat(basename, field_name, PATH_MAX - basename_len);
2d2d14a7 411 }
412
413 switch(td->type) {
414 case ENUM:
415 fprintf(fd, "enum lttng_%s", basename);
416 fprintf(fd, " {\n");
417 for(unsigned int i=0;i<td->labels.position;i++){
418 print_tabs(1, fd);
70f46ac3 419 fprintf(fd, "LTTNG_%s = %d", ((char*)td->labels.array[i]),
420 (*(int*)td->labels_values.array[i]));
2d2d14a7 421 fprintf(fd, ",\n");
422 }
423 fprintf(fd, "};\n");
424 fprintf(fd, "\n");
425 break;
426
427 case ARRAY:
7b175edc 428 dprintf("%s\n", basename);
2d2d14a7 429 assert(td->size >= 0);
a67cd958 430 if(((field_t*)td->fields.array[0])->type->type_name == NULL) {
2d2d14a7 431 /* Not a named nested type : we must print its declaration first */
a67cd958 432 if(print_type_declaration(((field_t*)td->fields.array[0])->type,
2d2d14a7 433 fd, 0, basename, "")) return 1;
434 }
2e415130 435 fprintf(fd, "#define LTTNG_ARRAY_SIZE_%s %zu\n", basename,
2d2d14a7 436 td->size);
7e97b039 437 fprintf(fd, "typedef ");
a67cd958 438 if(print_type(((field_t*)td->fields.array[0])->type,
439 fd, tabs, basename, "")) return 1;
2d2d14a7 440 fprintf(fd, " lttng_array_%s[LTTNG_ARRAY_SIZE_%s];\n", basename,
441 basename);
442 fprintf(fd, "\n");
443 break;
444 case SEQUENCE:
a67cd958 445 /* We assume that the sequence length type does not need to be declared.
446 */
447 if(((field_t*)td->fields.array[1])->type->type_name == NULL) {
2d2d14a7 448 /* Not a named nested type : we must print its declaration first */
a67cd958 449 if(print_type_declaration(((field_t*)td->fields.array[1])->type,
2d2d14a7 450 fd, 0, basename, "")) return 1;
451 }
452 fprintf(fd, "typedef struct lttng_sequence_%s lttng_sequence_%s;\n",
453 basename,
454 basename);
455 fprintf(fd, "struct lttng_sequence_%s", basename);
456 fprintf(fd, " {\n");
457 print_tabs(1, fd);
a3e6ce64 458 if(print_type(((field_t*)td->fields.array[0])->type,
459 fd, tabs, basename, "")) return 1;
40c18b13 460 fprintf(fd, " len;\n");
2d2d14a7 461 print_tabs(1, fd);
8c9e9076 462 fprintf(fd, "const ");
a67cd958 463 if(print_type(((field_t*)td->fields.array[1])->type,
464 fd, tabs, basename, "")) return 1;
2d2d14a7 465 fprintf(fd, " *array;\n");
d428224c 466 fprintf(fd, "};\n"); /* We do not LTT_ALIGN, because we never copy
467 it to the buffer directly. */
2d2d14a7 468 fprintf(fd, "\n");
469 break;
470
471 case STRUCT:
472 for(unsigned int i=0;i<td->fields.position;i++){
473 field_t *field = (field_t*)(td->fields.array[i]);
474 type_descriptor_t *type = field->type;
475 if(type->type_name == NULL) {
476 /* Not a named nested type : we must print its declaration first */
477 if(print_type_declaration(type,
478 fd, 0, basename, field->name)) return 1;
479 }
480 }
481 fprintf(fd, "struct lttng_%s", basename);
482 fprintf(fd, " {\n");
483 for(unsigned int i=0;i<td->fields.position;i++){
484 field_t *field = (field_t*)(td->fields.array[i]);
485 type_descriptor_t *type = field->type;
486 print_tabs(1, fd);
47299663 487 if(print_type(type, fd, tabs, basename, field->name)) return 1;
2d2d14a7 488 fprintf(fd, " ");
489 fprintf(fd, "%s", field->name);
490 fprintf(fd, ";\n");
491 }
2fef3d3e 492 if(td->fac->align)
493 fprintf(fd, "} LTT_ALIGN;\n");
494 else
495 fprintf(fd, "};\n");
2d2d14a7 496 fprintf(fd, "\n");
497 break;
498 case UNION:
2d2d14a7 499 for(unsigned int i=0;i<td->fields.position;i++){
500 field_t *field = (field_t*)(td->fields.array[i]);
501 type_descriptor_t *type = field->type;
502 if(type->type_name == NULL) {
503 /* Not a named nested type : we must print its declaration first */
47299663 504 if(print_type_declaration(type,
505 fd, 0, basename, field->name)) return 1;
2d2d14a7 506 }
507 }
508 fprintf(fd, "union lttng_%s", basename);
509 fprintf(fd, " {\n");
510 for(unsigned i=0;i<td->fields.position;i++){
511 field_t *field = (field_t*)(td->fields.array[i]);
512 type_descriptor_t *type = field->type;
513 print_tabs(1, fd);
47299663 514 if(print_type(type, fd, tabs, basename, field->name)) return 1;
2d2d14a7 515 fprintf(fd, " ");
516 fprintf(fd, "%s", field->name);
517 fprintf(fd, ";\n");
518 }
2fef3d3e 519 if(td->fac->align)
520 fprintf(fd, "} LTT_ALIGN;\n");
521 else
522 fprintf(fd, "};\n");
2d2d14a7 523 fprintf(fd, "\n");
524 break;
525 default:
526 dprintf("print_type_declaration : unknown type or nothing to declare.\n");
527 break;
528 }
529
530 return 0;
531}
532
a67cd958 533
a3e6ce64 534/* print type alignment.
535 *
536 * Copied from construct_types_and_fields in LTTV facility.c
537 *
538 * basename is the name which identifies the type (along with a prefix
539 * (possibly)). */
a67cd958 540
a3e6ce64 541int print_type_alignment(type_descriptor_t * td, FILE *fd, unsigned int tabs,
3261899d 542 char *nest_name, char *field_name, char *obj_prefix)
a67cd958 543{
a3e6ce64 544 char basename[PATH_MAX];
545 unsigned int basename_len = 0;
546
547 strncpy(basename, nest_name, PATH_MAX);
548 basename_len = strlen(basename);
549
550 /* For a named type, we use the type_name directly */
551 if(td->type_name != NULL) {
552 strncpy(basename, td->type_name, PATH_MAX);
553 basename_len = strlen(basename);
a67cd958 554 } else {
a3e6ce64 555 /* For a unnamed type, there must be a field name, except for
556 * the array. */
557 if((basename_len != 0)
558 && (basename[basename_len-1] != '_'
34c1d1b5 559 && field_name != NULL
a3e6ce64 560 && (field_name[0] != '\0'))) {
561 strncat(basename, "_", PATH_MAX - basename_len);
562 basename_len = strlen(basename);
a67cd958 563 }
34c1d1b5 564 if(field_name != NULL)
565 strncat(basename, field_name, PATH_MAX - basename_len);
a67cd958 566 }
a3e6ce64 567
3d9b9b0c 568 if(field_name[0] == '\0') {
569 /* We are in a write function : it's the obj that we must align. */
570 switch(td->type) {
571 case SEQUENCE:
3261899d 572 fprintf(fd, "lttng_get_alignment_sequence_%s(%s)", basename,
573 obj_prefix);
3d9b9b0c 574 break;
575 case STRUCT:
3261899d 576 fprintf(fd, "lttng_get_alignment_struct_%s(%s)", basename,
577 obj_prefix);
3d9b9b0c 578 break;
579 case UNION:
3261899d 580 fprintf(fd, "lttng_get_alignment_union_%s(%s)", basename,
581 obj_prefix);
3d9b9b0c 582 break;
583 case ARRAY:
3261899d 584 fprintf(fd, "lttng_get_alignment_array_%s(%s)", basename,
585 obj_prefix);
a2ff13ed 586 case STRING:
587 fprintf(fd, "sizeof(char)");
3d9b9b0c 588 break;
8f78c30f 589 case INT_FIXED:
590 case UINT_FIXED:
591 case CHAR:
592 case UCHAR:
593 case SHORT:
594 case USHORT:
595 case INT:
596 case UINT:
597 case FLOAT:
598 case POINTER:
599 case LONG:
600 case ULONG:
601 case SIZE_T:
602 case SSIZE_T:
603 case OFF_T:
604 case ENUM:
605 fprintf(fd, "sizeof(");
606 if(print_type(td, fd, 0, basename, "")) return 1;
607 fprintf(fd, ")");
608 break;
609
3d9b9b0c 610 default:
611 printf("error : type unexpected\n");
612 return 1;
613 break;
614 }
615 } else {
616
617 switch(td->type) {
618 case INT_FIXED:
619 case UINT_FIXED:
620 case CHAR:
621 case UCHAR:
622 case SHORT:
623 case USHORT:
624 case INT:
625 case UINT:
626 case FLOAT:
627 case POINTER:
628 case LONG:
629 case ULONG:
630 case SIZE_T:
631 case SSIZE_T:
632 case OFF_T:
633 case ENUM:
634 fprintf(fd, "sizeof(");
635 if(print_type(td, fd, 0, basename, "")) return 1;
636 fprintf(fd, ")");
637 break;
638 case STRING:
639 fprintf(fd, "sizeof(char)");
640 break;
641 case SEQUENCE:
3261899d 642 fprintf(fd, "lttng_get_alignment_sequence_%s(&%s%s)", basename,
643 obj_prefix, field_name);
3d9b9b0c 644 break;
645 case STRUCT:
3261899d 646 fprintf(fd, "lttng_get_alignment_struct_%s(&%s%s)", basename,
647 obj_prefix, field_name);
3d9b9b0c 648 break;
649 case UNION:
3261899d 650 fprintf(fd, "lttng_get_alignment_union_%s(&%s%s)", basename,
651 obj_prefix, field_name);
3d9b9b0c 652 break;
653 case ARRAY:
3261899d 654 fprintf(fd, "lttng_get_alignment_array_%s(%s%s)", basename,
655 obj_prefix, field_name);
3d9b9b0c 656 break;
657 case NONE:
658 printf("error : type NONE unexpected\n");
659 return 1;
660 break;
661 }
a3e6ce64 662 }
3d9b9b0c 663
a3e6ce64 664 return 0;
a67cd958 665}
666
a3e6ce64 667/* print type write.
668 *
669 * Copied from construct_types_and_fields in LTTV facility.c
670 *
671 * basename is the name which identifies the type (along with a prefix
672 * (possibly)). */
a67cd958 673
a3e6ce64 674int print_type_write(type_descriptor_t * td, FILE *fd, unsigned int tabs,
458989d8 675 char *nest_name, char *field_name, char *obj_prefix, int get_ptr)
a67cd958 676{
a67cd958 677 char basename[PATH_MAX];
678 unsigned int basename_len = 0;
458989d8 679 char get_ptr_char[2] = "";
64a6ab10 680 char custom[PATH_MAX] = "";
a3e6ce64 681
682 strncpy(basename, nest_name, PATH_MAX);
a67cd958 683 basename_len = strlen(basename);
684
685 /* For a named type, we use the type_name directly */
686 if(td->type_name != NULL) {
687 strncpy(basename, td->type_name, PATH_MAX);
688 basename_len = strlen(basename);
689 } else {
a3e6ce64 690 /* For a unnamed type, there must be a field name, except for
691 * the array. */
a67cd958 692 if((basename_len != 0)
a3e6ce64 693 && (basename[basename_len-1] != '_'
694 && (field_name[0] != '\0'))) {
a67cd958 695 strncat(basename, "_", PATH_MAX - basename_len);
696 basename_len = strlen(basename);
697 }
698 strncat(basename, field_name, PATH_MAX - basename_len);
699 }
700
458989d8 701 if(get_ptr) {
702 strcpy(get_ptr_char, "&");
703 }
704
64a6ab10 705 if(td->custom_write) {
706 strcpy(custom, "_custom");
707 }
708
a67cd958 709 switch(td->type) {
710 case INT_FIXED:
711 case UINT_FIXED:
712 case CHAR:
713 case UCHAR:
714 case SHORT:
715 case USHORT:
716 case INT:
717 case UINT:
718 case FLOAT:
719 case POINTER:
720 case LONG:
721 case ULONG:
722 case SIZE_T:
723 case SSIZE_T:
724 case OFF_T:
725 case ENUM:
a67cd958 726 print_tabs(tabs, fd);
8f78c30f 727 fprintf(fd, "align = ");
2fef3d3e 728 if(td->fac->align) {
729 if(print_type_alignment(td, fd, 0, basename, "", "obj")) return 1;
730 } else
731 fprintf(fd, "0");
8f78c30f 732 fprintf(fd, ";\n");
733 fprintf(fd, "\n");
734 print_tabs(tabs, fd);
948f61b4 735 fprintf(fd, "if (*len == 0) {\n");
8f78c30f 736 print_tabs(tabs+1, fd);
737 fprintf(fd, "*to += ltt_align(*to, align); /* align output */\n");
738 print_tabs(tabs, fd);
739 fprintf(fd, "} else {\n");
740 print_tabs(tabs+1, fd);
741 fprintf(fd, "*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */\n");
742 print_tabs(tabs, fd);
743 fprintf(fd, "}\n");
744 fprintf(fd, "\n");
745
746 print_tabs(tabs, fd);
747 fprintf(fd, "*len += ");
a3e6ce64 748 fprintf(fd, "sizeof(");
2e415130 749 if(print_type(td, fd, 0, basename, "")) return 1;
a67cd958 750 fprintf(fd, ");\n");
8f78c30f 751
a67cd958 752 break;
753 case STRING:
a67cd958 754 print_tabs(tabs, fd);
3261899d 755 fprintf(fd,
64a6ab10 756 "lttng_write%s_string_%s(buffer, to_base, to, from, len, %s%s);\n",
757 custom, basename, obj_prefix, field_name);
a3e6ce64 758 break;
759 case SEQUENCE:
760 print_tabs(tabs, fd);
3261899d 761 fprintf(fd,
64a6ab10 762 "lttng_write%s_sequence_%s(buffer, to_base, to, from, len, %s%s%s);",
763 custom, basename, get_ptr_char, obj_prefix, field_name);
a3e6ce64 764 break;
765 case STRUCT:
766 print_tabs(tabs, fd);
3261899d 767 fprintf(fd,
64a6ab10 768 "lttng_write%s_struct_%s(buffer, to_base, to, from, len, %s%s%s);",
769 custom, basename, get_ptr_char, obj_prefix, field_name);
a3e6ce64 770 break;
771 case UNION:
772 print_tabs(tabs, fd);
3261899d 773 fprintf(fd,
64a6ab10 774 "lttng_write%s_union_%s(buffer, to_base, to, from, len, %s%s%s);",
775 custom, basename, get_ptr_char, obj_prefix, field_name);
a67cd958 776 break;
777 case ARRAY:
a67cd958 778 print_tabs(tabs, fd);
3261899d 779 fprintf(fd,
64a6ab10 780 "lttng_write%s_array_%s(buffer, to_base, to, from, len, %s%s);",
781 custom, basename, obj_prefix, field_name);
a3e6ce64 782 break;
2e415130 783 case NONE:
784 printf("Error : type NONE unexpected\n");
785 return 1;
786 break;
a3e6ce64 787 }
a67cd958 788
a3e6ce64 789 return 0;
790}
a67cd958 791
63c831c5 792/* print need local vars ?.
793 *
794 * Copied from print_type_write
795 *
796 * Does the type_write call needs local size and from variables ?
797 * return value : 1 yes, 0 no.
798 */
799
800int has_type_local(type_descriptor_t * td)
801{
802 switch(td->type) {
803 case INT_FIXED:
804 case UINT_FIXED:
805 case CHAR:
806 case UCHAR:
807 case SHORT:
808 case USHORT:
809 case INT:
810 case UINT:
811 case FLOAT:
812 case POINTER:
813 case LONG:
814 case ULONG:
815 case SIZE_T:
816 case SSIZE_T:
817 case OFF_T:
818 case ENUM:
819 return 1;
820 break;
821 case STRING:
822 case SEQUENCE:
823 case STRUCT:
824 case UNION:
825 case ARRAY:
826 return 0;
827 break;
828 case NONE:
829 printf("Error : type NONE unexpected\n");
830 return 1;
831 break;
832 }
833
834 return 0;
835}
836
a67cd958 837
a67cd958 838
a3e6ce64 839/* print type alignment function.
840 *
841 * Copied from construct_types_and_fields in LTTV facility.c
842 *
843 * basename is the name which identifies the type (along with a prefix
844 * (possibly)). */
845
846int print_type_alignment_fct(type_descriptor_t * td, FILE *fd,
847 unsigned int tabs,
848 char *nest_name, char *field_name)
849{
850 char basename[PATH_MAX];
851 unsigned int basename_len = 0;
852
64a6ab10 853 if(td->custom_write) return 0; /* Does print custom type */
2fef3d3e 854 if(td->fac->align == 0) return 0;
64a6ab10 855
a3e6ce64 856 strncpy(basename, nest_name, PATH_MAX);
857 basename_len = strlen(basename);
858
859 /* For a named type, we use the type_name directly */
860 if(td->type_name != NULL) {
861 strncpy(basename, td->type_name, PATH_MAX);
862 basename_len = strlen(basename);
863 } else {
864 /* For a unnamed type, there must be a field name, except for
865 * the array. */
866 if((basename_len != 0)
867 && (basename[basename_len-1] != '_'
868 && (field_name[0] != '\0'))) {
869 strncat(basename, "_", PATH_MAX - basename_len);
870 basename_len = strlen(basename);
871 }
872 strncat(basename, field_name, PATH_MAX - basename_len);
873 }
874
875 switch(td->type) {
876 case SEQUENCE:
ba899d3d 877 if(((field_t*)td->fields.array[1])->type->type_name == NULL) {
878 /* Not a named nested type : we must print its align fct */
879 if(print_type_alignment_fct(((field_t*)td->fields.array[1])->type, fd,
880 0, basename, "")) return 1;
881 }
a3e6ce64 882 /* Function header */
883 fprintf(fd, "static inline size_t lttng_get_alignment_sequence_%s(\n",
884 basename);
885 print_tabs(2, fd);
2e415130 886 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 887 fprintf(fd, " *obj)\n");
888 fprintf(fd, "{\n");
889 print_tabs(1, fd);
890 fprintf(fd, "size_t align=0, localign;");
891 fprintf(fd, "\n");
892 print_tabs(1, fd);
893 fprintf(fd, "localign = ");
894 if(print_type_alignment(((field_t*)td->fields.array[0])->type,
3261899d 895 fd, 0, basename, "len", "obj->")) return 1;
a3e6ce64 896 fprintf(fd, ";\n");
897 print_tabs(1, fd);
898 fprintf(fd, "align = max(align, localign);\n");
899 fprintf(fd, "\n");
900 print_tabs(1, fd);
901 fprintf(fd, "localign = ");
902 if(print_type_alignment(((field_t*)td->fields.array[1])->type,
3261899d 903 fd, 0, basename, "array[0]", "obj->")) return 1;
a3e6ce64 904 fprintf(fd, ";\n");
905 print_tabs(1, fd);
906 fprintf(fd, "align = max(align, localign);\n");
907 fprintf(fd, "\n");
908 print_tabs(1, fd);
909 fprintf(fd, "return align;\n");
910 break;
911 case STRUCT:
ba899d3d 912 for(unsigned int i=0;i<td->fields.position;i++){
913 field_t *field = (field_t*)(td->fields.array[i]);
914 type_descriptor_t *type = field->type;
915 if(type->type_name == NULL) {
916 /* Not a named nested type : we must print its align fct */
917 if(print_type_alignment_fct(type, fd,
918 0, basename, field->name)) return 1;
919 }
920 }
a3e6ce64 921 /* Function header */
922 fprintf(fd, "static inline size_t lttng_get_alignment_struct_%s(\n",
923 basename);
924 print_tabs(2, fd);
2e415130 925 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 926 fprintf(fd, " *obj)\n");
927 fprintf(fd, "{\n");
928 print_tabs(1, fd);
929 fprintf(fd, "size_t align=0, localign;");
930 fprintf(fd, "\n");
931 for(unsigned int i=0;i<td->fields.position;i++){
932 field_t *field = (field_t*)(td->fields.array[i]);
933 type_descriptor_t *type = field->type;
934 print_tabs(1, fd);
935 fprintf(fd, "localign = ");
3261899d 936 if(print_type_alignment(type, fd, 0, basename, field->name, "obj->"))
937 return 1;
a3e6ce64 938 fprintf(fd, ";\n");
939 print_tabs(1, fd);
940 fprintf(fd, "align = max(align, localign);\n");
941 fprintf(fd, "\n");
942 }
943 print_tabs(1, fd);
944 fprintf(fd, "return align;\n");
945
a67cd958 946 break;
a3e6ce64 947 case UNION:
ba899d3d 948 for(unsigned int i=0;i<td->fields.position;i++){
949 field_t *field = (field_t*)(td->fields.array[i]);
950 type_descriptor_t *type = field->type;
951 if(type->type_name == NULL) {
952 /* Not a named nested type : we must print its align fct */
953 if(print_type_alignment_fct(type, fd,
954 0, basename, field->name)) return 1;
955 }
956 }
a3e6ce64 957 /* Function header */
958 fprintf(fd, "static inline size_t lttng_get_alignment_union_%s(\n",
959 basename);
960 print_tabs(2, fd);
2e415130 961 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 962 fprintf(fd, " *obj)\n");
963 fprintf(fd, "{\n");
964 print_tabs(1, fd);
965 fprintf(fd, "size_t align=0, localign;");
966 fprintf(fd, "\n");
967 for(unsigned int i=0;i<td->fields.position;i++){
968 field_t *field = (field_t*)(td->fields.array[i]);
969 type_descriptor_t *type = field->type;
970 print_tabs(1, fd);
971 fprintf(fd, "localign = ");
3261899d 972 if(print_type_alignment(type, fd, 0, basename, field->name, "obj->"))
973 return 1;
a3e6ce64 974 fprintf(fd, ";\n");
975 print_tabs(1, fd);
976 fprintf(fd, "align = max(align, localign);\n");
977 fprintf(fd, "\n");
978 }
979 print_tabs(1, fd);
980 fprintf(fd, "return align;\n");
981
982 break;
983 case ARRAY:
ba899d3d 984 if(((field_t*)td->fields.array[0])->type->type_name == NULL) {
985 /* Not a named nested type : we must print its align fct */
986 if(print_type_alignment_fct(((field_t*)td->fields.array[0])->type, fd,
987 0, basename, "")) return 1;
988 }
a3e6ce64 989 /* Function header */
990 fprintf(fd, "static inline size_t lttng_get_alignment_array_%s(\n",
991 basename);
992 print_tabs(2, fd);
2e415130 993 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 994 fprintf(fd, " obj)\n");
995 fprintf(fd, "{\n");
996 print_tabs(1, fd);
997 fprintf(fd, "return \n");
998 if(print_type_alignment(((field_t*)td->fields.array[0])->type,
3261899d 999 fd, 0, basename, "", "obj[0]"))
1000 return 1;
a3e6ce64 1001 fprintf(fd, ";\n");
1002 break;
1003 default:
71e09db9 1004 dprintf("print_type_alignment_fct : type has no alignment function.\n");
34c1d1b5 1005 return 0;
a3e6ce64 1006 break;
1007 }
1008
1009
1010 /* Function footer */
1011 fprintf(fd, "}\n");
1012 fprintf(fd, "\n");
1013
2e415130 1014 return 0;
a3e6ce64 1015}
1016
1017/* print type write function.
1018 *
1019 * Copied from construct_types_and_fields in LTTV facility.c
1020 *
1021 * basename is the name which identifies the type (along with a prefix
1022 * (possibly)). */
1023
1024int print_type_write_fct(type_descriptor_t * td, FILE *fd, unsigned int tabs,
1025 char *nest_name, char *field_name)
1026{
1027 char basename[PATH_MAX];
1028 unsigned int basename_len = 0;
1029
64a6ab10 1030 if(td->custom_write) return 0; /* Does print custom type */
1031
a3e6ce64 1032 strncpy(basename, nest_name, PATH_MAX);
1033 basename_len = strlen(basename);
1034
1035 /* For a named type, we use the type_name directly */
1036 if(td->type_name != NULL) {
1037 strncpy(basename, td->type_name, PATH_MAX);
1038 basename_len = strlen(basename);
1039 } else {
1040 /* For a unnamed type, there must be a field name, except for
1041 * the array. */
1042 if((basename_len != 0)
1043 && (basename[basename_len-1] != '_'
1044 && (field_name[0] != '\0'))) {
1045 strncat(basename, "_", PATH_MAX - basename_len);
1046 basename_len = strlen(basename);
1047 }
1048 strncat(basename, field_name, PATH_MAX - basename_len);
1049 }
1050
34c1d1b5 1051 switch(td->type) {
1052 case SEQUENCE:
ba899d3d 1053 if(((field_t*)td->fields.array[1])->type->type_name == NULL) {
1054 /* Not a named nested type : we must print its write fct */
1055 if(print_type_write_fct(((field_t*)td->fields.array[1])->type, fd,
1056 0, basename, "")) return 1;
1057 }
1058 break;
34c1d1b5 1059 case STRUCT:
ba899d3d 1060 for(unsigned int i=0;i<td->fields.position;i++){
1061 field_t *field = (field_t*)(td->fields.array[i]);
1062 type_descriptor_t *type = field->type;
1063 if(type->type_name == NULL) {
1064 /* Not a named nested type : we must print its write fct */
1065 if(print_type_write_fct(type, fd,
1066 0, basename, field->name)) return 1;
1067 }
1068 }
1069 break;
34c1d1b5 1070 case UNION:
ba899d3d 1071 for(unsigned int i=0;i<td->fields.position;i++){
1072 field_t *field = (field_t*)(td->fields.array[i]);
1073 type_descriptor_t *type = field->type;
1074 if(type->type_name == NULL) {
1075 /* Not a named nested type : we must print its write fct */
1076 if(print_type_write_fct(type, fd,
1077 0, basename, field->name)) return 1;
1078 }
1079 }
1080 break;
34c1d1b5 1081 case ARRAY:
ba899d3d 1082 if(((field_t*)td->fields.array[0])->type->type_name == NULL) {
1083 /* Not a named nested type : we must print its write fct */
1084 if(print_type_write_fct(((field_t*)td->fields.array[0])->type, fd,
1085 0, basename, "")) return 1;
1086 }
1087 break;
a2ff13ed 1088 case STRING:
34c1d1b5 1089 break;
1090 default:
71e09db9 1091 dprintf("print_type_write_fct : type has no write function.\n");
34c1d1b5 1092 return 0;
1093 break;
1094 }
1095
a3e6ce64 1096 /* Print header */
1097 switch(td->type) {
a67cd958 1098 case SEQUENCE:
34c1d1b5 1099 fprintf(fd, "static inline void lttng_write_sequence_%s(\n",
a3e6ce64 1100 basename);
a67cd958 1101 break;
a3e6ce64 1102 case STRUCT:
6e27ba88 1103 fprintf(fd, "static inline void lttng_write_struct_%s(\n", basename);
a67cd958 1104 break;
a3e6ce64 1105 case UNION:
6e27ba88 1106 fprintf(fd, "static inline void lttng_write_union_%s(\n", basename);
a3e6ce64 1107 break;
1108 case ARRAY:
6e27ba88 1109 fprintf(fd, "static inline void lttng_write_array_%s(\n", basename);
a3e6ce64 1110 break;
a2ff13ed 1111 case STRING:
1112 fprintf(fd, "static inline void lttng_write_string_%s(\n", basename);
1113 break;
a3e6ce64 1114 default:
1115 printf("print_type_write_fct : type has no write function.\n");
a67cd958 1116 break;
a67cd958 1117 }
1118
a3e6ce64 1119 print_tabs(2, fd);
59a957df 1120 fprintf(fd, "char *buffer,\n");
a3e6ce64 1121 print_tabs(2, fd);
1122 fprintf(fd, "size_t *to_base,\n");
1123 print_tabs(2, fd);
1124 fprintf(fd, "size_t *to,\n");
1125 print_tabs(2, fd);
59a957df 1126 fprintf(fd, "const char **from,\n");
a3e6ce64 1127 print_tabs(2, fd);
1128 fprintf(fd, "size_t *len,\n");
1129 print_tabs(2, fd);
2e415130 1130 if(print_type(td, fd, 0, basename, "")) return 1;
a3e6ce64 1131
1132 switch(td->type) {
1133 case SEQUENCE:
1134 fprintf(fd, " *obj)\n");
1135 break;
1136 case STRUCT:
1137 fprintf(fd, " *obj)\n");
1138 break;
1139 case UNION:
1140 fprintf(fd, " *obj)\n");
1141 break;
1142 case ARRAY:
1143 fprintf(fd, " obj)\n");
1144 break;
a2ff13ed 1145 case STRING:
1146 fprintf(fd, " obj)\n");
1147 break;
a3e6ce64 1148 default:
1149 printf("print_type_write_fct : type has no write function.\n");
1150 break;
1151 }
1152
1153 fprintf(fd, "{\n");
3ace7bc4 1154
f5f2fde4 1155 switch(td->type) {
1156 case STRING:
1157 print_tabs(1, fd);
1158 fprintf(fd, "size_t size;\n");
1159 break;
1160 default:
1161 break;
1162 }
1163
a3e6ce64 1164 print_tabs(1, fd);
3ace7bc4 1165 fprintf(fd, "size_t align;\n");
a3e6ce64 1166 fprintf(fd, "\n");
1167
1168 switch(td->type) {
1169 case SEQUENCE:
1170 case STRING:
1171 print_tabs(1, fd);
1172 fprintf(fd, "/* Flush pending memcpy */\n");
1173 print_tabs(1, fd);
00b44fe0 1174 fprintf(fd, "if (*len != 0) {\n");
a3e6ce64 1175 print_tabs(2, fd);
00b44fe0 1176 fprintf(fd, "if (buffer != NULL)\n");
a3e6ce64 1177 print_tabs(3, fd);
1178 fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
1179 print_tabs(1, fd);
1180 fprintf(fd, "}\n");
1181 print_tabs(1, fd);
1182 fprintf(fd, "*to += *len;\n");
1183 print_tabs(1, fd);
1184 fprintf(fd, "*len = 0;\n");
1185 fprintf(fd, "\n");
1186 break;
1187 case STRUCT:
1188 case UNION:
1189 case ARRAY:
1190 break;
1191 default:
1192 printf("print_type_write_fct : type has no write function.\n");
1193 break;
1194 }
1195
1196 print_tabs(1, fd);
34c1d1b5 1197 fprintf(fd, "align = ");
2fef3d3e 1198 if(td->fac->align) {
1199 if(print_type_alignment(td, fd, 0, basename, "", "obj")) return 1;
1200 } else
1201 fprintf(fd, "0");
a3e6ce64 1202 fprintf(fd, ";\n");
1203 fprintf(fd, "\n");
1204 print_tabs(1, fd);
00b44fe0 1205 fprintf(fd, "if (*len == 0) {\n");
a3e6ce64 1206 print_tabs(2, fd);
1207 fprintf(fd, "*to += ltt_align(*to, align); /* align output */\n");
1208 print_tabs(1, fd);
1209 fprintf(fd, "} else {\n");
1210 print_tabs(2, fd);
1211 fprintf(fd, "*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */\n");
1212 print_tabs(1, fd);
1213 fprintf(fd, "}\n");
1214 fprintf(fd, "\n");
1215
1216 /* First, check if the type has a fixed size. If it is the case, then the size
1217 * to write is know by the compiler : simply use a sizeof() */
1218 if(has_type_fixed_size(td)) {
1219 print_tabs(1, fd);
1220 fprintf(fd, "/* Contains only fixed size fields : use compiler sizeof() */\n");
1221 fprintf(fd, "\n");
1222 print_tabs(1, fd);
f5f2fde4 1223 fprintf(fd, "*len += sizeof(");
2e415130 1224 if(print_type(td, fd, 0, basename, field_name)) return 1;
a3e6ce64 1225 fprintf(fd, ");\n");
1226 } else {
1227 /* The type contains nested variable size subtypes :
1228 * we must write field by field. */
1229 print_tabs(1, fd);
1230 fprintf(fd, "/* Contains variable sized fields : must explode the structure */\n");
1231 fprintf(fd, "\n");
1232
1233 switch(td->type) {
1234 case SEQUENCE:
1235 print_tabs(1, fd);
1236 fprintf(fd, "/* Copy members */\n");
3261899d 1237// print_tabs(1, fd);
1238// fprintf(fd, "size = sizeof(\n");
a3e6ce64 1239 if(print_type_write(((field_t*)td->fields.array[0])->type,
458989d8 1240 fd, 1, basename, "len", "obj->", 1)) return 1;
3261899d 1241 fprintf(fd, "\n");
1242// fprintf(fd, ");\n");
1243// print_tabs(1, fd);
1244// fprintf(fd, "*to += ltt_align(*to, size);\n");
a3e6ce64 1245 print_tabs(1, fd);
948f61b4 1246 fprintf(fd, "if (buffer != NULL)\n");
a3e6ce64 1247 print_tabs(2, fd);
8f78c30f 1248 fprintf(fd, "memcpy(buffer+*to_base+*to, &obj->len, *len);\n");
a3e6ce64 1249 print_tabs(1, fd);
8f78c30f 1250 fprintf(fd, "*to += *len;\n");
1251 print_tabs(1, fd);
1252 fprintf(fd, "*len = 0;\n");
a3e6ce64 1253 fprintf(fd, "\n");
8f78c30f 1254
a3e6ce64 1255 /* Write the child : varlen child or not ? */
1256 if(has_type_fixed_size(((field_t*)td->fields.array[1])->type)) {
1257 /* Fixed size len child : use a multiplication of its size */
3261899d 1258// print_tabs(1, fd);
1259// fprintf(fd, "size = sizeof(\n");
8f78c30f 1260
1261 //print_tabs(1, fd);
1262 /* We know that *len does not contain alignment because of the
1263 * previous align output. len is always 0 here. */
a3e6ce64 1264 if(print_type_write(((field_t*)td->fields.array[1])->type,
8f78c30f 1265 fd, 1, basename, "array[0]", "obj->", 1))
1266 return 1;
3261899d 1267// fprintf(fd, ");\n");
8f78c30f 1268 fprintf(fd, "\n");
a3e6ce64 1269 print_tabs(1, fd);
8f78c30f 1270 fprintf(fd, "*len = obj->len * (*len);\n");
a3e6ce64 1271 print_tabs(1, fd);
00b44fe0 1272 fprintf(fd, "if (buffer != NULL)\n");
a3e6ce64 1273 print_tabs(2, fd);
8f78c30f 1274 fprintf(fd, "memcpy(buffer+*to_base+*to, obj->array, *len);\n");
1275 print_tabs(1, fd);
1276 fprintf(fd, "*to += *len;\n");
a3e6ce64 1277 print_tabs(1, fd);
8f78c30f 1278 fprintf(fd, "*len = 0;\n");
a3e6ce64 1279 fprintf(fd, "\n");
1280 } else {
1281 print_tabs(1, fd);
1282 fprintf(fd, "/* Variable length child : iter. */\n");
1283 print_tabs(1, fd);
00b44fe0 1284 fprintf(fd, "for (unsigned int i = 0; i < obj->len; i++) {\n");
a3e6ce64 1285 if(print_type_write(((field_t*)td->fields.array[1])->type,
458989d8 1286 fd, 2, basename, "array[i]", "obj->", 1)) return 1;
a3e6ce64 1287 print_tabs(1, fd);
1288 fprintf(fd, "}\n");
1289 }
1290 fprintf(fd, "\n");
1291 print_tabs(1, fd);
1292 fprintf(fd, "/* Realign the *to_base on arch size, set *to to 0 */\n");
1293 print_tabs(1, fd);
2fef3d3e 1294 if(td->fac->align)
1295 fprintf(fd, "*to += ltt_align(*to, sizeof(void *));\n");
a3e6ce64 1296 print_tabs(1, fd);
1297 fprintf(fd, "*to_base = *to_base+*to;\n");
1298 print_tabs(1, fd);
1299 fprintf(fd, "*to = 0;\n");
1300 fprintf(fd, "\n");
a2ff13ed 1301 print_tabs(1, fd);
a3e6ce64 1302 fprintf(fd, "/* Put source *from just after the C sequence */\n");
1303 print_tabs(1, fd);
c07c0891 1304 fprintf(fd, "*from = (const char*)(obj+1);\n");
a3e6ce64 1305 break;
1306 case STRING:
a2ff13ed 1307 print_tabs(1, fd);
caabcb43 1308 fprintf(fd, "size = strlen(obj) + 1; /* Include final NULL char. */\n");
a3e6ce64 1309 print_tabs(1, fd);
00b44fe0 1310 fprintf(fd, "if (buffer != NULL)\n");
a3e6ce64 1311 print_tabs(2, fd);
1312 fprintf(fd, "memcpy(buffer+*to_base+*to, obj, size);\n");
1313 print_tabs(1, fd);
1314 fprintf(fd, "*to += size;\n");
1315 fprintf(fd, "\n");
1316 print_tabs(1, fd);
1317 fprintf(fd, "/* Realign the *to_base on arch size, set *to to 0 */\n");
1318 print_tabs(1, fd);
2fef3d3e 1319 if(td->fac->align)
1320 fprintf(fd, "*to += ltt_align(*to, sizeof(void *));\n");
a3e6ce64 1321 print_tabs(1, fd);
1322 fprintf(fd, "*to_base = *to_base+*to;\n");
1323 print_tabs(1, fd);
1324 fprintf(fd, "*to = 0;\n");
1325 fprintf(fd, "\n");
a3e6ce64 1326 print_tabs(1, fd);
a2ff13ed 1327 fprintf(fd, "/* Put source *from just after the C string */\n");
1328 print_tabs(1, fd);
1329 fprintf(fd, "*from += size;\n");
a3e6ce64 1330 break;
1331 case STRUCT:
1332 for(unsigned int i=0;i<td->fields.position;i++){
1333 field_t *field = (field_t*)(td->fields.array[i]);
1334 type_descriptor_t *type = field->type;
1335 if(print_type_write(type,
458989d8 1336 fd, 1, basename, field->name, "obj->", 1)) return 1;
a3e6ce64 1337 fprintf(fd, "\n");
1338 }
1339 break;
1340 case UNION:
1341 printf("ERROR : A union CANNOT contain a variable size child.\n");
1342 return 1;
1343 break;
1344 case ARRAY:
1345 /* Write the child : varlen child or not ? */
1346 if(has_type_fixed_size(((field_t*)td->fields.array[0])->type)) {
1347 /* Error : if an array has a variable size, then its child must also
1348 * have a variable size. */
1349 assert(0);
1350 } else {
1351 print_tabs(1, fd);
1352 fprintf(fd, "/* Variable length child : iter. */\n");
1353 print_tabs(1, fd);
00b44fe0 1354 fprintf(fd, "for (unsigned int i = 0; i < LTTNG_ARRAY_SIZE_%s; i++) {\n", basename);
3261899d 1355 if(print_type_write(((field_t*)td->fields.array[0])->type,
458989d8 1356 fd, 2, basename, "", "obj->array[i]", 1)) return 1;
a3e6ce64 1357 print_tabs(1, fd);
1358 fprintf(fd, "}\n");
1359 }
1360 break;
1361 default:
1362 printf("print_type_write_fct : type has no write function.\n");
1363 break;
1364 }
1365
1366
1367 }
1368
1369
1370 /* Function footer */
1371 fprintf(fd, "}\n");
1372 fprintf(fd, "\n");
a67cd958 1373 return 0;
1374}
1375
1376
1377
47299663 1378/* Print the logging function of an event. This is the core of genevent */
a3e6ce64 1379int print_event_logging_function(char *basename, facility_t *fac,
1380 event_t *event, FILE *fd)
47299663 1381{
1382 fprintf(fd, "static inline void trace_%s(\n", basename);
3d9b9b0c 1383 int has_argument = 0;
63c831c5 1384 int has_type_fixed = 0;
3d9b9b0c 1385
1386 /* Does it support per trace tracing ? */
1387 if(event->per_trace) {
1388 print_tabs(2, fd);
1389 fprintf(fd, "struct ltt_trace_struct *dest_trace");
1390 has_argument = 1;
1391 }
1392
1393 /* Does it support per tracefile tracing ? */
1394 if(event->per_tracefile) {
1395 if(has_argument) {
1396 fprintf(fd, ",");
1397 fprintf(fd, "\n");
1398 }
1399 fprintf(fd, "unsigned int tracefile_index");
1400 has_argument = 1;
1401 }
1402
47299663 1403 for(unsigned int j = 0; j < event->fields.position; j++) {
1404 /* For each field, print the function argument */
1405 field_t *f = (field_t*)event->fields.array[j];
1406 type_descriptor_t *t = f->type;
3d9b9b0c 1407 if(has_argument) {
47299663 1408 fprintf(fd, ",");
1409 fprintf(fd, "\n");
1410 }
3d9b9b0c 1411 if(print_arg(t, fd, 2, basename, f->name)) return 1;
1412 has_argument = 1;
47299663 1413 }
3d9b9b0c 1414 if(!has_argument) {
47299663 1415 print_tabs(2, fd);
1416 fprintf(fd, "void");
1417 }
1418 fprintf(fd,")\n");
c3fff9a4 1419#if 0
71e09db9 1420 fprintf(fd,
c3fff9a4 1421 "#if (!defined(CONFIG_LTT) || (!defined(CONFIG_LTT_FACILITY_%s) && !defined(CONFIG_LTT_FACILITY_%s_MODULE)))\n",
1422 fac->capname, fac->capname);
47299663 1423 fprintf(fd, "{\n");
1424 fprintf(fd, "}\n");
1425 fprintf(fd,"#else\n");
c3fff9a4 1426#endif //0
47299663 1427 fprintf(fd, "{\n");
7e97b039 1428 /* Print the function variables */
a67cd958 1429 print_tabs(1, fd);
a3e6ce64 1430 fprintf(fd, "unsigned int index;\n");
1431 print_tabs(1, fd);
1432 fprintf(fd, "struct ltt_channel_struct *channel;\n");
1433 print_tabs(1, fd);
1434 fprintf(fd, "struct ltt_trace_struct *trace;\n");
1435 print_tabs(1, fd);
db6c25a6 1436 fprintf(fd, "void *transport_data;\n");
a3e6ce64 1437 print_tabs(1, fd);
59a957df 1438 fprintf(fd, "char *buffer = NULL;\n");
a3e6ce64 1439 print_tabs(1, fd);
458989d8 1440 fprintf(fd, "size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */\n");
1441 print_tabs(1, fd);
1442 fprintf(fd, "size_t *to_base = &real_to_base;\n");
a3e6ce64 1443 print_tabs(1, fd);
458989d8 1444 fprintf(fd, "size_t real_to = 0;\n");
a3e6ce64 1445 print_tabs(1, fd);
458989d8 1446 fprintf(fd, "size_t *to = &real_to;\n");
a3e6ce64 1447 print_tabs(1, fd);
458989d8 1448 fprintf(fd, "size_t real_len = 0;\n");
1449 print_tabs(1, fd);
1450 fprintf(fd, "size_t *len = &real_len;\n");
30d72138 1451 print_tabs(1, fd);
6e27ba88 1452 fprintf(fd, "size_t reserve_size;\n");
1453 print_tabs(1, fd);
a3e6ce64 1454 fprintf(fd, "size_t slot_size;\n");
30d72138 1455 print_tabs(1, fd);
63c831c5 1456
ac963fe3 1457 if(event->fields.position > 0) {
63c831c5 1458 for(unsigned int i=0;i<event->fields.position;i++){
1459 /* Search for at least one child with fixed size. It means
1460 * we need local variables.*/
1461 field_t *field = (field_t*)(event->fields.array[i]);
1462 type_descriptor_t *type = field->type;
1463 has_type_fixed = has_type_local(type);
1464 if(has_type_fixed) break;
1465 }
1466
1467 if(has_type_fixed) {
8f78c30f 1468 fprintf(fd, "size_t align;\n");
63c831c5 1469 print_tabs(1, fd);
1470 }
1471
59a957df 1472 fprintf(fd, "const char *real_from;\n");
ac963fe3 1473 print_tabs(1, fd);
59a957df 1474 fprintf(fd, "const char **from = &real_from;\n");
ac963fe3 1475 print_tabs(1, fd);
1476 }
8e290e8b 1477 fprintf(fd, "u64 tsc;\n");
30d72138 1478 print_tabs(1, fd);
458989d8 1479 fprintf(fd, "size_t before_hdr_pad, after_hdr_pad, header_size;\n");
a3e6ce64 1480 fprintf(fd, "\n");
7e97b039 1481
2fef3d3e 1482 if(!event->force) {
1483 print_tabs(1, fd);
1484 fprintf(fd, "if (ltt_traces.num_active_traces == 0)\n");
1485 print_tabs(2, fd);
1486 fprintf(fd, "return;\n");
1487 fprintf(fd, "\n");
1488 }
a3e6ce64 1489
a67cd958 1490 /* Calculate event variable len + event data alignment offset.
7e97b039 1491 * Assume that the padding for alignment starts at a void*
a67cd958 1492 * address.
1493 * This excludes the header size and alignment. */
1494
a3e6ce64 1495 print_tabs(1, fd);
1496 fprintf(fd, "/* For each field, calculate the field size. */\n");
1497 print_tabs(1, fd);
458989d8 1498 fprintf(fd, "/* size = *to_base + *to + *len */\n");
a3e6ce64 1499 print_tabs(1, fd);
30d72138 1500 fprintf(fd, "/* Assume that the padding for alignment starts at a\n");
a3e6ce64 1501 print_tabs(1, fd);
30d72138 1502 fprintf(fd, " * sizeof(void *) address. */\n");
a3e6ce64 1503 fprintf(fd, "\n");
a67cd958 1504
a3e6ce64 1505 for(unsigned int i=0;i<event->fields.position;i++){
2e415130 1506 field_t *field = (field_t*)(event->fields.array[i]);
a3e6ce64 1507 type_descriptor_t *type = field->type;
458989d8 1508 /* Set from */
1509 print_tabs(1, fd);
1510 switch(type->type) {
1511 case SEQUENCE:
1512 case UNION:
1513 case ARRAY:
1514 case STRUCT:
1515 case STRING:
922b1092 1516 fprintf(fd, "*from = (const char*)lttng_param_%s;\n", field->name);
458989d8 1517 break;
1518 default:
922b1092 1519 fprintf(fd, "*from = (const char*)&lttng_param_%s;\n", field->name);
458989d8 1520 break;
1521 }
1522
a3e6ce64 1523 if(print_type_write(type,
3ace7bc4 1524 fd, 1, basename, field->name, "lttng_param_", 0)) return 1;
a3e6ce64 1525 fprintf(fd, "\n");
a67cd958 1526 }
6e27ba88 1527 print_tabs(1, fd);
458989d8 1528 fprintf(fd, "reserve_size = *to_base + *to + *len;\n");
47299663 1529
7e97b039 1530 /* Take locks : make sure the trace does not vanish while we write on
1531 * it. A simple preemption disabling is enough (using rcu traces). */
a3e6ce64 1532 print_tabs(1, fd);
1533 fprintf(fd, "preempt_disable();\n");
1534 print_tabs(1, fd);
358f8354 1535 fprintf(fd, "ltt_nesting[smp_processor_id()]++;\n");
a3e6ce64 1536
1537 /* Get facility index */
1538
1539 if(event->per_tracefile) {
1540 print_tabs(1, fd);
1541 fprintf(fd, "index = tracefile_index;\n");
1542 } else {
1543 print_tabs(1, fd);
1544 fprintf(fd,
aaa18042 1545 "index = ltt_get_index_from_facility_%s(" \
458989d8 1546 "\t\t\t\t\t\tevent_%s_%s);\n",
aaa18042 1547 fac->name, fac->name, event->name);
a3e6ce64 1548 }
1549 fprintf(fd,"\n");
1550
7e97b039 1551
1552 /* For each trace */
a3e6ce64 1553 print_tabs(1, fd);
1554 fprintf(fd, "list_for_each_entry_rcu(trace, &ltt_traces.head, list) {\n");
2fef3d3e 1555 if(!event->force) {
1556 print_tabs(2, fd);
1557 fprintf(fd, "if (!trace->active)\n");
1558 print_tabs(3, fd);
1559 fprintf(fd, "continue;\n\n");
1560 }
a3e6ce64 1561
1562 if(event->per_trace) {
1563 print_tabs(2, fd);
00b44fe0 1564 fprintf(fd, "if (dest_trace != trace)\n");
1565 print_tabs(3, fd);
1566 fprintf(fd, "continue;\n\n");
a3e6ce64 1567 }
1568
1569 print_tabs(2, fd);
2e415130 1570 fprintf(fd, "channel = ltt_get_channel_from_index(trace, index);\n");
a3e6ce64 1571 fprintf(fd, "\n");
1572
7e97b039 1573
1574 /* Relay reserve */
a3e6ce64 1575 /* If error, increment event lost counter (done by ltt_reserve_slot) and
1576 * return */
1577 print_tabs(2, fd);
1578 fprintf(fd, "slot_size = 0;\n");
1579 print_tabs(2, fd);
db6c25a6 1580 fprintf(fd, "buffer = ltt_reserve_slot(trace, channel, &transport_data,\n");
30d72138 1581 print_tabs(3, fd);
6e27ba88 1582 fprintf(fd, "reserve_size, &slot_size, &tsc,\n");
30d72138 1583 print_tabs(3, fd);
458989d8 1584 fprintf(fd, "&before_hdr_pad, &after_hdr_pad, &header_size);\n");
a3e6ce64 1585 /* If error, return */
1586 print_tabs(2, fd);
948f61b4 1587 fprintf(fd, "if (!buffer)\n");
00b44fe0 1588 print_tabs(3, fd);
1589 fprintf(fd, "continue; /* buffer full */\n\n");
8f78c30f 1590 //print_tabs(2, fd);
1591 // for DEBUG only
1592 // fprintf(fd, "goto commit; /* DEBUG : never actually write. */\n\n");
1593 print_tabs(2, fd);
1594 fprintf(fd, "*to_base = *to = *len = 0;\n");
1595 fprintf(fd, "\n");
1596
458989d8 1597 /* Write event header */
2fef3d3e 1598 if(strcmp("compact", fac->name) != 0) {
1599 print_tabs(2, fd);
1600 fprintf(fd, "ltt_write_event_header(trace, channel, buffer,\n");
1601 print_tabs(3, fd);
1602 fprintf(fd, "ltt_facility_%s_%X, event_%s_%s,\n", fac->name, fac->checksum,
1603 fac->name, event->name);
1604 print_tabs(3, fd);
1605 fprintf(fd, "reserve_size, before_hdr_pad, tsc);\n");
1606 } else {
1607 print_tabs(2, fd);
1608 fprintf(fd, "ltt_write_compact_header(trace, channel, buffer,\n");
1609 print_tabs(3, fd);
1610 fprintf(fd, "ltt_facility_%s_%X, event_%s_%s,\n", fac->name, fac->checksum,
1611 fac->name, event->name);
1612 print_tabs(3, fd);
c9024049 1613 if(event->compact_data) {
1614 assert(event->fields.position > 0);
1615 field_t *field = (field_t*)(event->fields.array[0]);
1616 fprintf(fd, "reserve_size, before_hdr_pad, tsc, lttng_param_%s);\n",
1617 field->name);
1618 } else
1619 fprintf(fd, "reserve_size, before_hdr_pad, tsc, 0);\n");
2fef3d3e 1620 }
458989d8 1621 print_tabs(2, fd);
1622 fprintf(fd, "*to_base += before_hdr_pad + after_hdr_pad + header_size;\n");
2a5eec7d 1623 fprintf(fd, "\n");
7e97b039 1624
8f78c30f 1625 /* write data. */
a3e6ce64 1626
1627 for(unsigned int i=0;i<event->fields.position;i++){
2e415130 1628 field_t *field = (field_t*)(event->fields.array[i]);
a3e6ce64 1629 type_descriptor_t *type = field->type;
c9024049 1630
1631 /* First param is compacted in the header */
1632 if(event->compact_data && i == 0)
1633 continue;
a3e6ce64 1634 /* Set from */
30d72138 1635 print_tabs(2, fd);
1636 switch(type->type) {
1637 case SEQUENCE:
1638 case UNION:
1639 case ARRAY:
1640 case STRUCT:
1641 case STRING:
922b1092 1642 fprintf(fd, "*from = (const char*)lttng_param_%s;\n", field->name);
30d72138 1643 break;
1644 default:
922b1092 1645 fprintf(fd, "*from = (const char*)&lttng_param_%s;\n", field->name);
30d72138 1646 break;
1647 }
1648
a3e6ce64 1649
1650 if(print_type_write(type,
3ace7bc4 1651 fd, 2, basename, field->name, "lttng_param_", 0)) return 1;
a3e6ce64 1652 fprintf(fd, "\n");
7e97b039 1653
a3e6ce64 1654 /* Don't forget to flush pending memcpy */
1655 print_tabs(2, fd);
1656 fprintf(fd, "/* Flush pending memcpy */\n");
1657 print_tabs(2, fd);
00b44fe0 1658 fprintf(fd, "if (*len != 0) {\n");
a3e6ce64 1659 print_tabs(3, fd);
458989d8 1660 fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
a3e6ce64 1661 print_tabs(3, fd);
458989d8 1662 fprintf(fd, "*to += *len;\n");
a3e6ce64 1663 //print_tabs(3, fd);
1664 //fprintf(fd, "from += len;\n");
1665 print_tabs(3, fd);
458989d8 1666 fprintf(fd, "*len = 0;\n");
a3e6ce64 1667 print_tabs(2, fd);
1668 fprintf(fd, "}\n");
1669 fprintf(fd, "\n");
1670 }
1671
1672
7e97b039 1673 /* commit */
8f78c30f 1674 // for DEBUG only.
1675 //fprintf(fd, "commit:\n"); /* DEBUG! */
a3e6ce64 1676 print_tabs(2, fd);
db6c25a6 1677 fprintf(fd, "ltt_commit_slot(channel, &transport_data, buffer, slot_size);\n\n");
7e97b039 1678
a3e6ce64 1679 print_tabs(1, fd);
1680 fprintf(fd, "}\n\n");
1681
7e97b039 1682 /* Release locks */
a3e6ce64 1683 print_tabs(1, fd);
358f8354 1684 fprintf(fd, "ltt_nesting[smp_processor_id()]--;\n");
a3e6ce64 1685 print_tabs(1, fd);
0c4a454e 1686 fprintf(fd, "preempt_enable();\n");
2d2d14a7 1687
47299663 1688 fprintf(fd, "}\n");
c3fff9a4 1689#if 0
1690 fprintf(fd, "#endif //(!defined(CONFIG_LTT) || (!defined(CONFIG_LTT_FACILITY_%s) && !defined(CONFIG_LTT_FACILITY_%s_MODULE)))\n\n",
1691 fac->capname, fac->capname);
1692#endif //0
47299663 1693 return 0;
1694}
2d2d14a7 1695
922b1092 1696int print_event_logging_function_header_user_generic(char *basename, facility_t *fac,
1697 event_t *event, FILE *fd, enum user_fct_types fct_type)
bd7b8ca6 1698{
4a6829e2 1699 char *attrib;
8a9103df 1700
922b1092 1701 if(event->no_instrument_function && fct_type == USER_FCT_PROTO) {
4a6829e2 1702 attrib = "__attribute__((no_instrument_function)) ";
1703 } else {
1704 attrib = "";
1705 }
1e08067e 1706 if(event->param_buffer) {
4a6829e2 1707 fprintf(fd, "static inline %sint trace_%s_param_buffer(\n", attrib, basename);
1e08067e 1708 } else {
4a6829e2 1709 fprintf(fd, "static inline %sint trace_%s(\n",attrib, basename);
1e08067e 1710 }
bd7b8ca6 1711 int has_argument = 0;
bd7b8ca6 1712
1e08067e 1713 if(event->param_buffer) {
bd7b8ca6 1714 if(has_argument) {
1e08067e 1715 fprintf(fd, ",");
1716 fprintf(fd, "\n");
bd7b8ca6 1717 }
1e08067e 1718 print_tabs(2, fd);
59a957df 1719 fprintf(fd, "char *buffer");
bd7b8ca6 1720 has_argument = 1;
1e08067e 1721 fprintf(fd, ",");
1722 fprintf(fd, "\n");
1723 print_tabs(2, fd);
1724 fprintf(fd, "size_t reserve_size");
1725 } else {
1726 for(unsigned int j = 0; j < event->fields.position; j++) {
1727 /* For each field, print the function argument */
1728 field_t *f = (field_t*)event->fields.array[j];
1729 type_descriptor_t *t = f->type;
1730 if(has_argument) {
1731 fprintf(fd, ",");
1732 fprintf(fd, "\n");
1733 }
1734 if(print_arg(t, fd, 2, basename, f->name)) return 1;
1735 has_argument = 1;
1736 }
bd7b8ca6 1737 }
1738 if(!has_argument) {
1739 print_tabs(2, fd);
1740 fprintf(fd, "void");
1741 }
922b1092 1742 fprintf(fd,")");
1743 return 0;
1744}
1745
1746
1747/* print_event_logging_function_user_generic
1748 * Print the logging function of an event for userspace tracing. This is the
1749 * core of genevent */
1750int print_event_logging_function_user_generic(char *basename, facility_t *fac,
1751 event_t *event, FILE *fd)
1752{
1753 int has_type_fixed = 0;
1754
1755 if(print_event_logging_function_header_user_generic(basename, fac, event, fd, USER_FCT_PROTO)) return 1;
1756 fprintf(fd,";\n");
1757 fprintf(fd,"\n");
1758 fprintf(fd, "#ifndef LTT_TRACE_FAST\n");
1759 if(print_event_logging_function_header_user_generic(basename, fac, event, fd, USER_FCT_DECLARATION)) return 1;
1760 fprintf(fd,"\n");
bd7b8ca6 1761 fprintf(fd,
1762 "#ifndef LTT_TRACE\n");
1763 fprintf(fd, "{\n");
1764 fprintf(fd, "}\n");
1765 fprintf(fd,"#else\n");
1766 fprintf(fd, "{\n");
1767 /* Print the function variables */
1768 print_tabs(1, fd);
1e08067e 1769 fprintf(fd, "int ret = 0;\n");
1770 if(event->param_buffer) {
0bdf8e98 1771 //FIX print_tabs(1, fd);
1772 //fprintf(fd, "reserve_size = ltt_align(reserve_size, sizeof(void *));\n");
1e08067e 1773 print_tabs(1, fd);
1774 fprintf(fd, "{\n");
1775 goto do_syscall;
1776 }
1777 print_tabs(1, fd);
59a957df 1778 fprintf(fd, "char *buffer = NULL;\n");
bd7b8ca6 1779 print_tabs(1, fd);
1780 fprintf(fd, "size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */\n");
1781 print_tabs(1, fd);
1782 fprintf(fd, "size_t *to_base = &real_to_base;\n");
1783 print_tabs(1, fd);
1784 fprintf(fd, "size_t real_to = 0;\n");
1785 print_tabs(1, fd);
1786 fprintf(fd, "size_t *to = &real_to;\n");
1787 print_tabs(1, fd);
1788 fprintf(fd, "size_t real_len = 0;\n");
1789 print_tabs(1, fd);
1790 fprintf(fd, "size_t *len = &real_len;\n");
1791 print_tabs(1, fd);
1792 fprintf(fd, "size_t reserve_size;\n");
1793 print_tabs(1, fd);
1794 fprintf(fd, "size_t slot_size;\n");
1795 print_tabs(1, fd);
bd7b8ca6 1796
1797 if(event->fields.position > 0) {
1798 for(unsigned int i=0;i<event->fields.position;i++){
1799 /* Search for at least one child with fixed size. It means
1800 * we need local variables.*/
1801 field_t *field = (field_t*)(event->fields.array[i]);
1802 type_descriptor_t *type = field->type;
1803 has_type_fixed = has_type_local(type);
1804 if(has_type_fixed) break;
1805 }
1806
1807 if(has_type_fixed) {
1808 fprintf(fd, "size_t align;\n");
1809 print_tabs(1, fd);
1810 }
1811
59a957df 1812 fprintf(fd, "const char *real_from;\n");
bd7b8ca6 1813 print_tabs(1, fd);
59a957df 1814 fprintf(fd, "const char **from = &real_from;\n");
bd7b8ca6 1815 print_tabs(1, fd);
1816 }
1817
1818 /* Calculate event variable len + event data alignment offset.
1819 * Assume that the padding for alignment starts at a void*
1820 * address.
1821 * This excludes the header size and alignment. */
1822
1823 print_tabs(1, fd);
1824 fprintf(fd, "/* For each field, calculate the field size. */\n");
1825 print_tabs(1, fd);
1826 fprintf(fd, "/* size = *to_base + *to + *len */\n");
1827 print_tabs(1, fd);
1828 fprintf(fd, "/* Assume that the padding for alignment starts at a\n");
1829 print_tabs(1, fd);
1830 fprintf(fd, " * sizeof(void *) address. */\n");
1831 fprintf(fd, "\n");
1832
1833 for(unsigned int i=0;i<event->fields.position;i++){
1834 field_t *field = (field_t*)(event->fields.array[i]);
1835 type_descriptor_t *type = field->type;
1836 /* Set from */
1837 print_tabs(1, fd);
1838 switch(type->type) {
1839 case SEQUENCE:
1840 case UNION:
1841 case ARRAY:
1842 case STRUCT:
1843 case STRING:
922b1092 1844 fprintf(fd, "*from = (const char*)lttng_param_%s;\n", field->name);
bd7b8ca6 1845 break;
1846 default:
922b1092 1847 fprintf(fd, "*from = (const char*)&lttng_param_%s;\n", field->name);
bd7b8ca6 1848 break;
1849 }
1850
1851 if(print_type_write(type,
1852 fd, 1, basename, field->name, "lttng_param_", 0)) return 1;
1853 fprintf(fd, "\n");
1854 }
1855 print_tabs(1, fd);
1856 fprintf(fd, "reserve_size = *to_base + *to + *len;\n");
1857
1858 print_tabs(1, fd);
1859 fprintf(fd, "{\n");
1860 print_tabs(2, fd);
1861 fprintf(fd, "char stack_buffer[reserve_size];\n");
1862 print_tabs(2, fd);
1863 fprintf(fd, "buffer = stack_buffer;\n");
1864 fprintf(fd, "\n");
1865
1866
1867 //print_tabs(2, fd);
1868 // for DEBUG only
1869 // fprintf(fd, "goto commit; /* DEBUG : never actually write. */\n\n");
1870 print_tabs(2, fd);
1871 fprintf(fd, "*to_base = *to = *len = 0;\n");
1872 fprintf(fd, "\n");
1873
1874 /* write data. */
1875
1876 for(unsigned int i=0;i<event->fields.position;i++){
1877 field_t *field = (field_t*)(event->fields.array[i]);
1878 type_descriptor_t *type = field->type;
1879
1880 /* Set from */
1881 print_tabs(2, fd);
1882 switch(type->type) {
1883 case SEQUENCE:
1884 case UNION:
1885 case ARRAY:
1886 case STRUCT:
1887 case STRING:
922b1092 1888 fprintf(fd, "*from = (const char*)lttng_param_%s;\n", field->name);
bd7b8ca6 1889 break;
1890 default:
922b1092 1891 fprintf(fd, "*from = (const char*)&lttng_param_%s;\n", field->name);
bd7b8ca6 1892 break;
1893 }
1894
1895
1896 if(print_type_write(type,
1897 fd, 2, basename, field->name, "lttng_param_", 0)) return 1;
1898 fprintf(fd, "\n");
1899
1900 /* Don't forget to flush pending memcpy */
1901 print_tabs(2, fd);
1902 fprintf(fd, "/* Flush pending memcpy */\n");
1903 print_tabs(2, fd);
00b44fe0 1904 fprintf(fd, "if (*len != 0) {\n");
bd7b8ca6 1905 print_tabs(3, fd);
1906 fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
1907 print_tabs(3, fd);
1908 fprintf(fd, "*to += *len;\n");
1909 //print_tabs(3, fd);
1910 //fprintf(fd, "from += len;\n");
1911 print_tabs(3, fd);
1912 fprintf(fd, "*len = 0;\n");
1913 print_tabs(2, fd);
1914 fprintf(fd, "}\n");
1915 fprintf(fd, "\n");
1916 }
1917
1e08067e 1918do_syscall:
bd7b8ca6 1919 print_tabs(2, fd);
c3fff9a4 1920 fprintf(fd, "ret = ltt_trace_generic(ltt_facility_%s_%X, event_%s_%s, buffer, reserve_size, LTT_BLOCKING, %u);\n", fac->name, fac->checksum, fac->name, event->name, event->high_priority);
bd7b8ca6 1921
1922 print_tabs(1, fd);
1923 fprintf(fd, "}\n\n");
1924
1925 print_tabs(1, fd);
1926 fprintf(fd, "return ret;\n\n");
1927
1928 fprintf(fd, "}\n");
1929 fprintf(fd,
1930 "#endif //LTT_TRACE\n");
8a9103df 1931 fprintf(fd, "#endif //!LTT_TRACE_FAST\n\n");
bd7b8ca6 1932
1933 return 0;
1934}
2d2d14a7 1935
8a9103df 1936/* print_event_logging_function_user_fast
1937 * Print the logging function of an event for userspace tracing. This is the
1938 * core of genevent */
1939int print_event_logging_function_user_fast(char *basename, facility_t *fac,
1940 event_t *event, FILE *fd)
1941{
1942 char *attrib;
1943
1944 fprintf(fd, "#ifdef LTT_TRACE_FAST\n");
1945
1946 if(event->no_instrument_function) {
1947 attrib = "__attribute__((no_instrument_function)) ";
1948 } else {
1949 attrib = "";
1950 }
1951 fprintf(fd, "static inline %sint trace_%s(\n",attrib, basename);
1952
1953 int has_argument = 0;
1954 int has_type_fixed = 0;
1955
1956 for(unsigned int j = 0; j < event->fields.position; j++) {
1957 /* For each field, print the function argument */
1958 field_t *f = (field_t*)event->fields.array[j];
1959 type_descriptor_t *t = f->type;
1960 if(has_argument) {
1961 fprintf(fd, ",");
1962 fprintf(fd, "\n");
1963 }
1964 if(print_arg(t, fd, 2, basename, f->name)) return 1;
1965 has_argument = 1;
1966 }
1967 if(!has_argument) {
1968 print_tabs(2, fd);
1969 fprintf(fd, "void");
1970 }
1971 fprintf(fd,")\n");
1972 fprintf(fd,
1973 "#ifndef LTT_TRACE\n");
1974 fprintf(fd, "{\n");
1975 fprintf(fd, "}\n");
1976 fprintf(fd,"#else\n");
1977 fprintf(fd, "{\n");
1978 /* Print the function variables */
1979 print_tabs(1, fd);
1980 fprintf(fd, "unsigned int index;\n");
1981 print_tabs(1, fd);
1982 fprintf(fd, "struct ltt_trace_info *trace = thread_trace_info;\n");
1983 print_tabs(1, fd);
1984 fprintf(fd, "struct ltt_buf *ltt_buf;\n");
1985 print_tabs(1, fd);
59a957df 1986 fprintf(fd, "char *buffer = NULL;\n");
8a9103df 1987 print_tabs(1, fd);
1988 fprintf(fd, "size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */\n");
1989 print_tabs(1, fd);
1990 fprintf(fd, "size_t *to_base = &real_to_base;\n");
1991 print_tabs(1, fd);
1992 fprintf(fd, "size_t real_to = 0;\n");
1993 print_tabs(1, fd);
1994 fprintf(fd, "size_t *to = &real_to;\n");
1995 print_tabs(1, fd);
1996 fprintf(fd, "size_t real_len = 0;\n");
1997 print_tabs(1, fd);
1998 fprintf(fd, "size_t *len = &real_len;\n");
1999 print_tabs(1, fd);
2000 fprintf(fd, "size_t reserve_size;\n");
2001 print_tabs(1, fd);
2002 fprintf(fd, "size_t slot_size;\n");
2003 print_tabs(1, fd);
2004
2005 if(event->fields.position > 0) {
2006 for(unsigned int i=0;i<event->fields.position;i++){
2007 /* Search for at least one child with fixed size. It means
2008 * we need local variables.*/
2009 field_t *field = (field_t*)(event->fields.array[i]);
2010 type_descriptor_t *type = field->type;
2011 has_type_fixed = has_type_local(type);
2012 if(has_type_fixed) break;
2013 }
2014
2015 if(has_type_fixed) {
2016 fprintf(fd, "size_t align;\n");
2017 print_tabs(1, fd);
2018 }
2019
59a957df 2020 fprintf(fd, "const char *real_from;\n");
8a9103df 2021 print_tabs(1, fd);
59a957df 2022 fprintf(fd, "const char **from = &real_from;\n");
8a9103df 2023 print_tabs(1, fd);
2024 }
2025 fprintf(fd, "uint64_t tsc;\n");
2026 print_tabs(1, fd);
2027 fprintf(fd, "size_t before_hdr_pad, after_hdr_pad, header_size;\n");
2028 fprintf(fd, "\n");
2029
2030 print_tabs(1, fd);
00b44fe0 2031 fprintf(fd, "if (!trace) {\n");
ba017bc3 2032 print_tabs(2, fd);
2033 fprintf(fd, "ltt_thread_init();\n");
2034 print_tabs(2, fd);
2035 fprintf(fd, "trace = thread_trace_info;\n");
2036 print_tabs(1, fd);
2037 fprintf(fd, "}\n\n");
8a9103df 2038 fprintf(fd, "\n");
2039
2040 /* Calculate event variable len + event data alignment offset.
2041 * Assume that the padding for alignment starts at a void*
2042 * address.
2043 * This excludes the header size and alignment. */
2044
2045 print_tabs(1, fd);
2046 fprintf(fd, "/* For each field, calculate the field size. */\n");
2047 print_tabs(1, fd);
2048 fprintf(fd, "/* size = *to_base + *to + *len */\n");
2049 print_tabs(1, fd);
2050 fprintf(fd, "/* Assume that the padding for alignment starts at a\n");
2051 print_tabs(1, fd);
2052 fprintf(fd, " * sizeof(void *) address. */\n");
2053 fprintf(fd, "\n");
2054
2055 for(unsigned int i=0;i<event->fields.position;i++){
2056 field_t *field = (field_t*)(event->fields.array[i]);
2057 type_descriptor_t *type = field->type;
2058 /* Set from */
2059 print_tabs(1, fd);
2060 switch(type->type) {
2061 case SEQUENCE:
2062 case UNION:
2063 case ARRAY:
2064 case STRUCT:
2065 case STRING:
922b1092 2066 fprintf(fd, "*from = (const char*)lttng_param_%s;\n", field->name);
8a9103df 2067 break;
2068 default:
922b1092 2069 fprintf(fd, "*from = (const char*)&lttng_param_%s;\n", field->name);
8a9103df 2070 break;
2071 }
2072
2073 if(print_type_write(type,
2074 fd, 1, basename, field->name, "lttng_param_", 0)) return 1;
2075 fprintf(fd, "\n");
2076 }
2077 print_tabs(1, fd);
2078 fprintf(fd, "reserve_size = *to_base + *to + *len;\n");
2079
2080 print_tabs(1, fd);
2081 fprintf(fd, "trace->nesting++;\n");
2082
2083 /* Get facility index */
2084
2085 print_tabs(1, fd);
2086 fprintf(fd,
2087 "index = ltt_get_index_from_facility(ltt_facility_%s_%X,\n"\
2088 "\t\t\t\t\t\tevent_%s_%s);\n",
2089 fac->name, fac->checksum, fac->name, event->name);
2090 fprintf(fd,"\n");
2091
2092
2093 print_tabs(1, fd);
2094 fprintf(fd, "{\n");
2095
2096 if(event->per_trace) {
2097 print_tabs(2, fd);
00b44fe0 2098 fprintf(fd, "if (dest_trace != trace) continue;\n\n");
8a9103df 2099 }
2100
2101 print_tabs(2, fd);
2102 fprintf(fd, "ltt_buf = ltt_get_channel_from_index(trace, index);\n");
2103 print_tabs(2, fd);
2104
2105
2106 /* Relay reserve */
2107 /* If error, increment event lost counter (done by ltt_reserve_slot) and
2108 * return */
2109 print_tabs(2, fd);
2110 fprintf(fd, "slot_size = 0;\n");
2111 print_tabs(2, fd);
922b1092 2112 fprintf(fd, "buffer = ltt_reserve_slot(trace, ltt_buf,\n");
8a9103df 2113 print_tabs(3, fd);
2114 fprintf(fd, "reserve_size, &slot_size, &tsc,\n");
2115 print_tabs(3, fd);
2116 fprintf(fd, "&before_hdr_pad, &after_hdr_pad, &header_size);\n");
2117 /* If error, return */
2118 print_tabs(2, fd);
00b44fe0 2119 fprintf(fd, "if (!buffer)\n");
2120 print_tabs(3, fd);
2121 fprintf(fd, "goto end; /* buffer full */\n\n");
8a9103df 2122 //print_tabs(2, fd);
2123 // for DEBUG only
2124 // fprintf(fd, "goto commit; /* DEBUG : never actually write. */\n\n");
2125 print_tabs(2, fd);
2126 fprintf(fd, "*to_base = *to = *len = 0;\n");
2127 fprintf(fd, "\n");
2128
2129 /* Write event header */
2130 print_tabs(2, fd);
2131 fprintf(fd, "ltt_write_event_header(trace, ltt_buf, buffer,\n");
2132 print_tabs(3, fd);
2133 fprintf(fd, "ltt_facility_%s_%X, event_%s_%s,\n", fac->name, fac->checksum,
2134 fac->name, event->name);
2135 print_tabs(3, fd);
2136 fprintf(fd, "reserve_size, before_hdr_pad, tsc);\n");
2137 print_tabs(2, fd);
2138 fprintf(fd, "*to_base += before_hdr_pad + after_hdr_pad + header_size;\n");
2139 fprintf(fd, "\n");
2140
2141 /* write data. */
2142
2143 for(unsigned int i=0;i<event->fields.position;i++){
2144 field_t *field = (field_t*)(event->fields.array[i]);
2145 type_descriptor_t *type = field->type;
2146
2147 /* Set from */
2148 print_tabs(2, fd);
2149 switch(type->type) {
2150 case SEQUENCE:
2151 case UNION:
2152 case ARRAY:
2153 case STRUCT:
2154 case STRING:
922b1092 2155 fprintf(fd, "*from = (const char*)lttng_param_%s;\n", field->name);
8a9103df 2156 break;
2157 default:
922b1092 2158 fprintf(fd, "*from = (const char*)&lttng_param_%s;\n", field->name);
8a9103df 2159 break;
2160 }
2161
2162
2163 if(print_type_write(type,
2164 fd, 2, basename, field->name, "lttng_param_", 0)) return 1;
2165 fprintf(fd, "\n");
2166
2167 /* Don't forget to flush pending memcpy */
2168 print_tabs(2, fd);
2169 fprintf(fd, "/* Flush pending memcpy */\n");
2170 print_tabs(2, fd);
00b44fe0 2171 fprintf(fd, "if (*len != 0) {\n");
8a9103df 2172 print_tabs(3, fd);
2173 fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
2174 print_tabs(3, fd);
2175 fprintf(fd, "*to += *len;\n");
2176 //print_tabs(3, fd);
2177 //fprintf(fd, "from += len;\n");
2178 print_tabs(3, fd);
2179 fprintf(fd, "*len = 0;\n");
2180 print_tabs(2, fd);
2181 fprintf(fd, "}\n");
2182 fprintf(fd, "\n");
2183 }
2184
2185
2186 /* commit */
2187 // for DEBUG only.
2188 //fprintf(fd, "commit:\n"); /* DEBUG! */
2189 print_tabs(2, fd);
922b1092 2190 fprintf(fd, "ltt_commit_slot(ltt_buf, buffer, slot_size);\n\n");
8a9103df 2191
2192 fprintf(fd, "}\n\n");
2193
2194 fprintf(fd, "end:\n");
2195 /* Release locks */
2196 print_tabs(1, fd);
2197 fprintf(fd, "trace->nesting--;\n");
2198
2199
2200 fprintf(fd, "}\n");
2201 fprintf(fd,
2202 "#endif //LTT_TRACE\n");
2203 fprintf(fd, "#endif //LTT_TRACE_FAST\n");
2204
2205 return 0;
2206}
2207
2208
2209
2210
2211
2212
2d2d14a7 2213/* ltt-facility-name.h : main logging header.
2214 * log_header */
2215
2216void print_log_header_head(facility_t *fac, FILE *fd)
2217{
2218 fprintf(fd, "#ifndef _LTT_FACILITY_%s_H_\n", fac->capname);
2219 fprintf(fd, "#define _LTT_FACILITY_%s_H_\n\n", fac->capname);
922b1092 2220 fprintf(fd, "#include <linux/types.h>\n");
ffaf5031 2221 if(!fac->arch)
c3fff9a4 2222 fprintf(fd, "#include <ltt/ltt-facility-id-%s.h>\n", fac->name);
ffaf5031 2223 else
c3fff9a4 2224 fprintf(fd, "#include <ltt/ltt-facility-id-%s_%s.h>\n",
ffaf5031 2225 fac->name,
2226 fac->arch);
c3fff9a4 2227 fprintf(fd, "#include <ltt/ltt-tracer.h>\n");
47299663 2228 fprintf(fd, "\n");
2d2d14a7 2229}
2230
bd7b8ca6 2231/* ltt-facility-name.h : main logging header.
2232 * log_header */
2233
2234void print_log_header_head_user(facility_t *fac, FILE *fd)
2235{
2236 fprintf(fd, "#ifndef _LTT_FACILITY_%s_H_\n", fac->capname);
2237 fprintf(fd, "#define _LTT_FACILITY_%s_H_\n\n", fac->capname);
922b1092 2238 fprintf(fd, "#include <sys/types.h>\n");
bd7b8ca6 2239 if(!fac->arch)
922b1092 2240 fprintf(fd, "#include <ltt/ltt-facility-id-%s.h>\n", fac->name);
bd7b8ca6 2241 else
922b1092 2242 fprintf(fd, "#include <asm/ltt/ltt-facility-id-%s_%s.h>\n",
bd7b8ca6 2243 fac->name,
2244 fac->arch);
922b1092 2245 fprintf(fd, "#include <ltt/ltt-usertrace.h>\n");
2246 fprintf(fd, "\n");
2247 fprintf(fd, "#ifdef __cplusplus\n");
2248 fprintf(fd, "extern \"C\" {\n");
2249 fprintf(fd, "#endif\n");
bd7b8ca6 2250 fprintf(fd, "\n");
2251}
2d2d14a7 2252
2253
2d2d14a7 2254int print_log_header_types(facility_t *fac, FILE *fd)
2255{
2256 sequence_t *types = &fac->named_types.values;
2257 fprintf(fd, "/* Named types */\n");
2258 fprintf(fd, "\n");
2259
2260 for(unsigned int i = 0; i < types->position; i++) {
2261 /* For each named type, print the definition */
458989d8 2262 if(print_type_declaration(types->array[i], fd,
2263 0, "", "")) return 1;
34c1d1b5 2264 /* Print also the align function */
2fef3d3e 2265 if(((type_descriptor_t*)types->array[i])->fac->align)
2266 if(print_type_alignment_fct(types->array[i], fd,
458989d8 2267 0, "", "")) return 1;
34c1d1b5 2268 /* Print also the write function */
458989d8 2269 if(print_type_write_fct(types->array[i], fd,
2270 0, "", "")) return 1;
2d2d14a7 2271 }
2272 return 0;
2273}
2274
2275int print_log_header_events(facility_t *fac, FILE *fd)
2276{
47299663 2277 sequence_t *events = &fac->events;
2278 char basename[PATH_MAX];
2279 unsigned int facname_len;
2280
2281 strncpy(basename, fac->name, PATH_MAX);
2282 facname_len = strlen(basename);
2283 strncat(basename, "_", PATH_MAX-facname_len);
2284 facname_len = strlen(basename);
2285
2286 for(unsigned int i = 0; i < events->position; i++) {
2287 event_t *event = (event_t*)events->array[i];
2288 strncpy(&basename[facname_len], event->name, PATH_MAX-facname_len);
2289
2290 /* For each event, print structure, and then logging function */
2291 fprintf(fd, "/* Event %s structures */\n",
2292 event->name);
2293 for(unsigned int j = 0; j < event->fields.position; j++) {
2294 /* For each unnamed type, print the definition */
2295 field_t *f = (field_t*)event->fields.array[j];
2296 type_descriptor_t *t = f->type;
34c1d1b5 2297 if(t->type_name == NULL) {
47299663 2298 if((print_type_declaration(t, fd, 0, basename, f->name))) return 1;
34c1d1b5 2299 /* Print also the align function */
2fef3d3e 2300 if(fac->align) {
2301 if((print_type_alignment_fct(t, fd, 0, basename, f->name))) return 1;
2302 }
34c1d1b5 2303 /* Print also the write function */
2304 if((print_type_write_fct(t, fd, 0, basename, f->name))) return 1;
2305 }
47299663 2306 }
34c1d1b5 2307
47299663 2308 fprintf(fd, "\n");
2d2d14a7 2309
47299663 2310 fprintf(fd, "/* Event %s logging function */\n",
2311 event->name);
bd7b8ca6 2312
2313 if(!fac->user) {
2314 if(print_event_logging_function(basename, fac, event, fd)) return 1;
2315 } else {
8a9103df 2316 if(print_event_logging_function_user_generic(basename, fac, event, fd))
2317 return 1;
2318 if(print_event_logging_function_user_fast(basename, fac, event, fd))
2319 return 1;
bd7b8ca6 2320 }
47299663 2321
2322 fprintf(fd, "\n");
2323 }
2324
2d2d14a7 2325 return 0;
2326}
2327
2328
2329void print_log_header_tail(facility_t *fac, FILE *fd)
2330{
2331 fprintf(fd, "#endif //_LTT_FACILITY_%s_H_\n",fac->capname);
2332}
bd7b8ca6 2333
2334void print_log_header_tail_user(facility_t *fac, FILE *fd)
2335{
922b1092 2336 fprintf(fd, "#ifdef __cplusplus\n");
2337 fprintf(fd, "} /* end of extern \"C\" */\n");
2338 fprintf(fd, "#endif\n");
2339 fprintf(fd, "\n");
bd7b8ca6 2340 fprintf(fd, "#endif //_LTT_FACILITY_%s_H_\n",fac->capname);
2341}
2d2d14a7 2342
2343int print_log_header(facility_t *fac)
2344{
2345 char filename[PATH_MAX];
2346 unsigned int filename_size = 0;
2347 FILE *fd;
2348 dprintf("%s\n", fac->name);
2349
2350 strcpy(filename, "ltt-facility-");
2351 filename_size = strlen(filename);
2352
2353 strncat(filename, fac->name, PATH_MAX - filename_size);
2354 filename_size = strlen(filename);
2355
ffaf5031 2356 if(fac->arch) {
2357 strncat(filename, "_", PATH_MAX - filename_size);
2358 filename_size = strlen(filename);
2359
2360 strncat(filename, fac->arch, PATH_MAX - filename_size);
2361 filename_size = strlen(filename);
2362 }
2363
2d2d14a7 2364 strncat(filename, ".h", PATH_MAX - filename_size);
2365 filename_size = strlen(filename);
2366
2367
2368 fd = fopen(filename, "w");
2369 if(fd == NULL) {
2370 printf("Error opening file %s for writing : %s\n",
2371 filename, strerror(errno));
2372 return errno;
2373 }
2374
2375 /* Print file head */
bd7b8ca6 2376 if(!fac->user)
2377 print_log_header_head(fac, fd);
2378 else
2379 print_log_header_head_user(fac, fd);
2d2d14a7 2380
2381 /* print named types in declaration order */
2382 if(print_log_header_types(fac, fd)) return 1;
2383
2384 /* Print events */
2385 if(print_log_header_events(fac, fd)) return 1;
2386
2387 /* Print file tail */
bd7b8ca6 2388 if(!fac->user)
2389 print_log_header_tail(fac, fd);
2390 else
2391 print_log_header_tail_user(fac, fd);
2392
2d2d14a7 2393
2394
2395 fclose(fd);
2396
2397 return 0;
2398}
2399
2400
2401/* ltt-facility-id-name.h : facility id.
2402 * log_id_header */
2403int print_id_header(facility_t *fac)
2404{
2405 char filename[PATH_MAX];
2406 unsigned int filename_size = 0;
2407 FILE *fd;
71e09db9 2408 char basename[PATH_MAX];
2409 char basename_len = 0;
2410
2d2d14a7 2411 dprintf("%s\n", fac->name);
2412
2413 strcpy(filename, "ltt-facility-id-");
2414 filename_size = strlen(filename);
2415
2416 strncat(filename, fac->name, PATH_MAX - filename_size);
2417 filename_size = strlen(filename);
2418
ffaf5031 2419 if(fac->arch) {
2420 strncat(filename, "_", PATH_MAX - filename_size);
2421 filename_size = strlen(filename);
2422
2423 strncat(filename, fac->arch, PATH_MAX - filename_size);
2424 filename_size = strlen(filename);
2425 }
2426
2d2d14a7 2427 strncat(filename, ".h", PATH_MAX - filename_size);
2428 filename_size = strlen(filename);
2429
2430
2431 fd = fopen(filename, "w");
2432 if(fd == NULL) {
2433 printf("Error opening file %s for writing : %s\n",
2434 filename, strerror(errno));
2435 return errno;
2436 }
2437
bd7b8ca6 2438 if(!fac->user) {
2439 fprintf(fd, "#ifndef _LTT_FACILITY_ID_%s_H_\n",fac->capname);
2440 fprintf(fd, "#define _LTT_FACILITY_ID_%s_H_\n\n",fac->capname);
2441 fprintf(fd, "#ifdef CONFIG_LTT\n");
71e09db9 2442
bd7b8ca6 2443 fprintf(fd,"#include <linux/ltt-facilities.h>\n\n");
71e09db9 2444
bd7b8ca6 2445 fprintf(fd,"/**** facility handle ****/\n\n");
2446 fprintf(fd,"extern ltt_facility_t ltt_facility_%s_%X;\n",
2447 fac->name, fac->checksum);
2448 fprintf(fd,"extern ltt_facility_t ltt_facility_%s;\n\n\n",fac->name);
71e09db9 2449
bd7b8ca6 2450 strncpy(basename, fac->name, PATH_MAX);
2451 basename_len = strlen(basename);
2452 strncat(basename, "_", PATH_MAX - basename_len);
2453 basename_len++;
2454
2455 fprintf(fd,"/**** event index ****/\n\n");
2456 fprintf(fd,"enum %s_event {\n",fac->name);
2457
2458 for(unsigned int i = 0; i < fac->events.position; i++) {
2459 event_t *event = (event_t*)fac->events.array[i];
2460 strncpy(basename+basename_len, event->name, PATH_MAX-basename_len);
2461 print_tabs(1, fd);
2462 fprintf(fd, "event_%s,\n", basename);
2463 }
71e09db9 2464 print_tabs(1, fd);
bd7b8ca6 2465 fprintf(fd, "facility_%s_num_events\n", fac->name);
2466 fprintf(fd, "};\n");
2467 fprintf(fd, "\n");
71e09db9 2468
2469
bd7b8ca6 2470 fprintf(fd, "#endif //CONFIG_LTT\n");
2471 fprintf(fd, "#endif //_LTT_FACILITY_ID_%s_H_\n",fac->capname);
2472 } else {
2473 fprintf(fd, "#ifndef _LTT_FACILITY_ID_%s_H_\n",fac->capname);
2474 fprintf(fd, "#define _LTT_FACILITY_ID_%s_H_\n\n",fac->capname);
2475 fprintf(fd, "#ifdef LTT_TRACE\n");
2476
f389e596 2477 fprintf(fd,"#include <ltt/ltt-usertrace.h>\n\n");
bd7b8ca6 2478
2479 fprintf(fd,"/**** facility handle ****/\n\n");
2480 fprintf(fd,"extern ltt_facility_t ltt_facility_%s_%X;\n",
2481 fac->name, fac->checksum);
2482 fprintf(fd,"extern ltt_facility_t ltt_facility_%s;\n\n\n",fac->name);
2483
2484 strncpy(basename, fac->name, PATH_MAX);
2485 basename_len = strlen(basename);
2486 strncat(basename, "_", PATH_MAX - basename_len);
2487 basename_len++;
2488
2489 fprintf(fd,"/**** event index ****/\n\n");
2490 fprintf(fd,"enum %s_event {\n",fac->name);
2491
2492 for(unsigned int i = 0; i < fac->events.position; i++) {
2493 event_t *event = (event_t*)fac->events.array[i];
2494 strncpy(basename+basename_len, event->name, PATH_MAX-basename_len);
2495 print_tabs(1, fd);
2496 fprintf(fd, "event_%s,\n", basename);
2497 }
2498 print_tabs(1, fd);
2499 fprintf(fd, "facility_%s_num_events\n", fac->name);
2500 fprintf(fd, "};\n");
2501 fprintf(fd, "\n");
2502
2503
2504 fprintf(fd, "#endif //LTT_TRACE\n");
2505 fprintf(fd, "#endif //_LTT_FACILITY_ID_%s_H_\n",fac->capname);
2506 }
71e09db9 2507
2508
2d2d14a7 2509 fclose(fd);
2510
2511 return 0;
2512}
2513
2514
2515/* ltt-facility-loader-name.h : facility specific loader info.
2516 * loader_header */
2517int print_loader_header(facility_t *fac)
2518{
2519 char filename[PATH_MAX];
2520 unsigned int filename_size = 0;
2521 FILE *fd;
2522 dprintf("%s\n", fac->name);
2523
2524 strcpy(filename, "ltt-facility-loader-");
2525 filename_size = strlen(filename);
2526
2527 strncat(filename, fac->name, PATH_MAX - filename_size);
2528 filename_size = strlen(filename);
2529
ffaf5031 2530 if(fac->arch) {
2531 strncat(filename, "_", PATH_MAX - filename_size);
2532 filename_size = strlen(filename);
2533
2534 strncat(filename, fac->arch, PATH_MAX - filename_size);
2535 filename_size = strlen(filename);
2536 }
2537
2d2d14a7 2538 strncat(filename, ".h", PATH_MAX - filename_size);
2539 filename_size = strlen(filename);
2540
2541
2542 fd = fopen(filename, "w");
2543 if(fd == NULL) {
2544 printf("Error opening file %s for writing : %s\n",
2545 filename, strerror(errno));
2546 return errno;
2547 }
2548
71e09db9 2549 fprintf(fd, "#ifndef _LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
2550 fprintf(fd, "#define _LTT_FACILITY_LOADER_%s_H_\n\n", fac->capname);
2551 fprintf(fd, "#ifdef CONFIG_LTT\n\n");
2552 fprintf(fd,"#include <linux/ltt-facilities.h>\n");
ffaf5031 2553 if(!fac->arch)
c3fff9a4 2554 fprintf(fd,"#include <ltt/ltt-facility-id-%s.h>\n\n",
ffaf5031 2555 fac->name);
2556 else
c3fff9a4 2557 fprintf(fd,"#include <ltt/ltt-facility-id-%s_%s.h>\n\n",
ffaf5031 2558 fac->name,
2559 fac->arch);
71e09db9 2560 fprintf(fd,"ltt_facility_t\tltt_facility_%s;\n", fac->name);
2561 fprintf(fd,"ltt_facility_t\tltt_facility_%s_%X;\n\n",
2562 fac->name, fac->checksum);
2563
0043cb00 2564 fprintf(fd,"#define LTT_FACILITY_SYMBOL\t\tltt_facility_%s\n",
71e09db9 2565 fac->name);
0043cb00 2566 fprintf(fd,"#define LTT_FACILITY_CHECKSUM_SYMBOL\tltt_facility_%s_%X\n",
71e09db9 2567 fac->name, fac->checksum);
0043cb00 2568 fprintf(fd,"#define LTT_FACILITY_CHECKSUM\t\t0x%X\n", fac->checksum);
2569 fprintf(fd,"#define LTT_FACILITY_NAME\t\t\"%s\"\n", fac->name);
2570 fprintf(fd,"#define LTT_FACILITY_NUM_EVENTS\tfacility_%s_num_events\n\n",
71e09db9 2571 fac->name);
2fef3d3e 2572 fprintf(fd,"#define LTT_FACILITY_ALIGNMENT\t\t%u\n\n",
2573 fac->align);
71e09db9 2574 fprintf(fd, "#endif //CONFIG_LTT\n\n");
2575 fprintf(fd, "#endif //_LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
2576
2d2d14a7 2577 fclose(fd);
2578
2579 return 0;
2580}
2581
bd7b8ca6 2582int print_loader_header_user(facility_t *fac)
2583{
2584 char filename[PATH_MAX];
2585 unsigned int filename_size = 0;
2586 FILE *fd;
2587 dprintf("%s\n", fac->name);
2588
2589 strcpy(filename, "ltt-facility-loader-");
2590 filename_size = strlen(filename);
2591
2592 strncat(filename, fac->name, PATH_MAX - filename_size);
2593 filename_size = strlen(filename);
2594
2595 if(fac->arch) {
2596 strncat(filename, "_", PATH_MAX - filename_size);
2597 filename_size = strlen(filename);
2598
2599 strncat(filename, fac->arch, PATH_MAX - filename_size);
2600 filename_size = strlen(filename);
2601 }
2602
2603 strncat(filename, ".h", PATH_MAX - filename_size);
2604 filename_size = strlen(filename);
2605
2606
2607 fd = fopen(filename, "w");
2608 if(fd == NULL) {
2609 printf("Error opening file %s for writing : %s\n",
2610 filename, strerror(errno));
2611 return errno;
2612 }
2613
2614 fprintf(fd, "#ifndef _LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
2615 fprintf(fd, "#define _LTT_FACILITY_LOADER_%s_H_\n\n", fac->capname);
f389e596 2616 fprintf(fd,"#include <ltt/ltt-usertrace.h>\n");
bd7b8ca6 2617 if(!fac->arch)
2618 fprintf(fd,"#include <ltt/ltt-facility-id-%s.h>\n\n",
2619 fac->name);
2620 else
c3fff9a4 2621 fprintf(fd,"#include <ltt/ltt-facility-id-%s_%s.h>\n\n",
bd7b8ca6 2622 fac->name,
2623 fac->arch);
2624 fprintf(fd,"ltt_facility_t\tltt_facility_%s;\n", fac->name);
2625 fprintf(fd,"ltt_facility_t\tltt_facility_%s_%X;\n\n",
2626 fac->name, fac->checksum);
2627
2628 fprintf(fd,"#define LTT_FACILITY_SYMBOL\t\t\t\t\t\t\tltt_facility_%s\n",
2629 fac->name);
2630 fprintf(fd,"#define LTT_FACILITY_CHECKSUM_SYMBOL\t\tltt_facility_%s_%X\n",
2631 fac->name, fac->checksum);
2632 fprintf(fd,"#define LTT_FACILITY_CHECKSUM\t\t\t\t\t\t0x%X\n", fac->checksum);
2633 fprintf(fd,"#define LTT_FACILITY_NAME\t\t\t\t\t\t\t\t\"%s\"\n", fac->name);
2634 fprintf(fd,"#define LTT_FACILITY_NUM_EVENTS\t\t\t\t\tfacility_%s_num_events\n\n",
2635 fac->name);
2fef3d3e 2636 fprintf(fd,"#define LTT_FACILITY_ALIGNMENT\t\t\t\t\t%u\n\n",
2637 fac->align);
bd7b8ca6 2638 fprintf(fd, "#endif //_LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
2639
2640 fclose(fd);
2641
2642 return 0;
2643}
2644
2645
2646
2647/* ltt-facility-loader-name.c : generic facility loader
2d2d14a7 2648 * loader_c */
2649int print_loader_c(facility_t *fac)
2650{
2651 char filename[PATH_MAX];
2652 unsigned int filename_size = 0;
2653 FILE *fd;
2654 dprintf("%s\n", fac->name);
2655
2656 strcpy(filename, "ltt-facility-loader-");
2657 filename_size = strlen(filename);
2658
2659 strncat(filename, fac->name, PATH_MAX - filename_size);
2660 filename_size = strlen(filename);
2661
ffaf5031 2662 if(fac->arch) {
2663 strncat(filename, "_", PATH_MAX - filename_size);
2664 filename_size = strlen(filename);
2665
2666 strncat(filename, fac->arch, PATH_MAX - filename_size);
2667 filename_size = strlen(filename);
2668 }
2669
2d2d14a7 2670 strncat(filename, ".c", PATH_MAX - filename_size);
2671 filename_size = strlen(filename);
2672
2673
2674 fd = fopen(filename, "w");
2675 if(fd == NULL) {
2676 printf("Error opening file %s for writing : %s\n",
2677 filename, strerror(errno));
2678 return errno;
2679 }
2680
71e09db9 2681 fprintf(fd, "/*\n");
ffaf5031 2682 if(!fac->arch)
2683 fprintf(fd, " * ltt-facility-loader-%s.c\n", fac->name);
2684 else
2685 fprintf(fd, " * ltt-facility-loader-%s_%s.c\n", fac->name, fac->arch);
71e09db9 2686 fprintf(fd, " *\n");
2687 fprintf(fd, " * (C) Copyright 2005 - \n");
2688 fprintf(fd, " * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)\n");
2689 fprintf(fd, " *\n");
2690 fprintf(fd, " * Contains the LTT facility loader.\n");
2691 fprintf(fd, " *\n");
2692 fprintf(fd, " */\n");
2693 fprintf(fd, "\n");
2694 fprintf(fd, "\n");
2695 fprintf(fd, "#include <linux/ltt-facilities.h>\n");
2696 fprintf(fd, "#include <linux/module.h>\n");
2697 fprintf(fd, "#include <linux/init.h>\n");
ffaf5031 2698 if(!fac->arch)
2699 fprintf(fd, "#include \"ltt-facility-loader-%s.h\"\n", fac->name);
2700 else
2701 fprintf(fd, "#include \"ltt-facility-loader-%s_%s.h\"\n",
2702 fac->name, fac->arch);
71e09db9 2703 fprintf(fd, "\n");
2704 fprintf(fd, "\n");
2705 fprintf(fd, "#ifdef CONFIG_LTT\n");
2706 fprintf(fd, "\n");
2707 fprintf(fd, "EXPORT_SYMBOL(LTT_FACILITY_SYMBOL);\n");
2708 fprintf(fd, "EXPORT_SYMBOL(LTT_FACILITY_CHECKSUM_SYMBOL);\n");
2709 fprintf(fd, "\n");
2710 fprintf(fd, "static const char ltt_facility_name[] = LTT_FACILITY_NAME;\n");
2711 fprintf(fd, "\n");
2712 fprintf(fd, "#define SYMBOL_STRING(sym) #sym\n");
2713 fprintf(fd, "\n");
2714 fprintf(fd, "static struct ltt_facility facility = {\n");
2715 fprintf(fd, "\t.name = ltt_facility_name,\n");
2716 fprintf(fd, "\t.num_events = LTT_FACILITY_NUM_EVENTS,\n");
2717 fprintf(fd, "\t.checksum = LTT_FACILITY_CHECKSUM,\n");
2718 fprintf(fd, "\t.symbol = SYMBOL_STRING(LTT_FACILITY_SYMBOL),\n");
2fef3d3e 2719 fprintf(fd, "\t.alignment = LTT_FACILITY_ALIGNMENT,\n");
71e09db9 2720 fprintf(fd, "};\n");
2721 fprintf(fd, "\n");
71e09db9 2722 fprintf(fd, "static int __init facility_init(void)\n");
2723 fprintf(fd, "{\n");
2724 fprintf(fd, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init in kernel\\n\");\n", fac->name);
2725 fprintf(fd, "\n");
bd7b8ca6 2726 fprintf(fd, "\tLTT_FACILITY_SYMBOL = ltt_facility_kernel_register(&facility);\n");
71e09db9 2727 fprintf(fd, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
2728 fprintf(fd, "\t\n");
2729 fprintf(fd, "\treturn LTT_FACILITY_SYMBOL;\n");
2730 fprintf(fd, "}\n");
71e09db9 2731 fprintf(fd, "\n");
bd7b8ca6 2732 fprintf(fd, "#ifndef MODULE\n");
ba899d3d 2733 fprintf(fd, "__initcall(facility_init);\n");
2734 fprintf(fd, "#else\n");
2735 fprintf(fd, "module_init(facility_init);\n");
71e09db9 2736 fprintf(fd, "static void __exit facility_exit(void)\n");
2737 fprintf(fd, "{\n");
2738 fprintf(fd, "\tint err;\n");
2739 fprintf(fd, "\n");
bd7b8ca6 2740 fprintf(fd, "\terr = ltt_facility_unregister(LTT_FACILITY_SYMBOL);\n");
00b44fe0 2741 fprintf(fd, "\tif (err != 0)\n");
71e09db9 2742 fprintf(fd, "\t\tprintk(KERN_ERR \"LTT : Error in unregistering facility.\\n\");\n");
2743 fprintf(fd, "\n");
2744 fprintf(fd, "}\n");
71e09db9 2745 fprintf(fd, "module_exit(facility_exit)\n");
2746 fprintf(fd, "\n");
71e09db9 2747 fprintf(fd, "MODULE_LICENSE(\"GPL\");\n");
2748 fprintf(fd, "MODULE_AUTHOR(\"Mathieu Desnoyers\");\n");
2749 fprintf(fd, "MODULE_DESCRIPTION(\"Linux Trace Toolkit Facility\");\n");
2750 fprintf(fd, "\n");
2751 fprintf(fd, "#endif //MODULE\n");
2752 fprintf(fd, "\n");
2753 fprintf(fd, "#endif //CONFIG_LTT\n");
2d2d14a7 2754
2755 fclose(fd);
2756
2757 return 0;
2758}
2759
bd7b8ca6 2760int print_loader_c_user(facility_t *fac)
2761{
2762 char filename[PATH_MAX];
2763 unsigned int filename_size = 0;
2764 FILE *fd;
2765 dprintf("%s\n", fac->name);
2766
2767 strcpy(filename, "ltt-facility-loader-");
2768 filename_size = strlen(filename);
2769
2770 strncat(filename, fac->name, PATH_MAX - filename_size);
2771 filename_size = strlen(filename);
2772
2773 if(fac->arch) {
2774 strncat(filename, "_", PATH_MAX - filename_size);
2775 filename_size = strlen(filename);
2776
2777 strncat(filename, fac->arch, PATH_MAX - filename_size);
2778 filename_size = strlen(filename);
2779 }
2780
2781 strncat(filename, ".c", PATH_MAX - filename_size);
2782 filename_size = strlen(filename);
2783
2784
2785 fd = fopen(filename, "w");
2786 if(fd == NULL) {
2787 printf("Error opening file %s for writing : %s\n",
2788 filename, strerror(errno));
2789 return errno;
2790 }
2791
2792 fprintf(fd, "/*\n");
2793 if(!fac->arch)
2794 fprintf(fd, " * ltt-facility-loader-%s.c\n", fac->name);
2795 else
2796 fprintf(fd, " * ltt-facility-loader-%s_%s.c\n", fac->name, fac->arch);
2797 fprintf(fd, " *\n");
2798 fprintf(fd, " * (C) Copyright 2005 - \n");
2799 fprintf(fd, " * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)\n");
2800 fprintf(fd, " *\n");
2801 fprintf(fd, " * Contains the LTT user space facility loader.\n");
2802 fprintf(fd, " *\n");
2803 fprintf(fd, " */\n");
2804 fprintf(fd, "\n");
2805 fprintf(fd, "\n");
2806 fprintf(fd, "#define LTT_TRACE\n");
2807 fprintf(fd, "#include <error.h>\n");
2808 fprintf(fd, "#include <stdio.h>\n");
f389e596 2809 fprintf(fd, "#include <ltt/ltt-usertrace.h>\n");
bd7b8ca6 2810 if(!fac->arch)
2811 fprintf(fd, "#include \"ltt-facility-loader-%s.h\"\n", fac->name);
2812 else
2813 fprintf(fd, "#include \"ltt-facility-loader-%s_%s.h\"\n",
2814 fac->name, fac->arch);
2815 fprintf(fd, "\n");
2816 fprintf(fd, "static struct user_facility_info facility = {\n");
2817 fprintf(fd, "\t.name = LTT_FACILITY_NAME,\n");
2818 fprintf(fd, "\t.num_events = LTT_FACILITY_NUM_EVENTS,\n");
2819 fprintf(fd, "#ifndef LTT_PACK\n");
2fef3d3e 2820 fprintf(fd, "\t.alignment = LTT_FACILITY_ALIGNMENT?sizeof(void*):0,\n");
bd7b8ca6 2821 fprintf(fd, "#else\n");
2822 fprintf(fd, "\t.alignment = 0,\n");
2823 fprintf(fd, "#endif //LTT_PACK\n");
2824 fprintf(fd, "\t.checksum = LTT_FACILITY_CHECKSUM,\n");
2825 fprintf(fd, "\t.int_size = sizeof(int),\n");
2826 fprintf(fd, "\t.long_size = sizeof(long),\n");
2827 fprintf(fd, "\t.pointer_size = sizeof(void*),\n");
2828 fprintf(fd, "\t.size_t_size = sizeof(size_t)\n");
2829 fprintf(fd, "};\n");
2830 fprintf(fd, "\n");
2831 fprintf(fd, "static void __attribute__((constructor)) __ltt_user_init(void)\n");
2832 fprintf(fd, "{\n");
2833 fprintf(fd, "\tint err;\n");
2d6c6b76 2834 fprintf(fd, "#ifdef LTT_SHOW_DEBUG\n");
bd7b8ca6 2835 fprintf(fd, "\tprintf(\"LTT : ltt-facility-%s init in userspace\\n\");\n", fac->name);
2d6c6b76 2836 fprintf(fd, "#endif //LTT_SHOW_DEBUG\n");
bd7b8ca6 2837 fprintf(fd, "\n");
2838 fprintf(fd, "\terr = ltt_register_generic(&LTT_FACILITY_SYMBOL, &facility);\n");
2839 fprintf(fd, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
2840 fprintf(fd, "\t\n");
00b44fe0 2841 fprintf(fd, "\tif (err) {\n");
2d6c6b76 2842 fprintf(fd, "#ifdef LTT_SHOW_DEBUG\n");
bd7b8ca6 2843 fprintf(fd, "\t\tperror(\"Error in ltt_register_generic\");\n");
2d6c6b76 2844 fprintf(fd, "#endif //LTT_SHOW_DEBUG\n");
bd7b8ca6 2845 fprintf(fd, "\t}\n");
2846 fprintf(fd, "}\n");
2847 fprintf(fd, "\n");
2848
2849 fclose(fd);
2850
2851 return 0;
2852}
2853
2d2d14a7 2854
2855
92d82357 2856/* open facility */
2857/* code taken from ltt_facility_open in ltt/facility.c in lttv */
2858
2859/*****************************************************************************
2860 *Function name
2861 * ltt_facility_open : open facilities
2862 *Input params
2863 * pathname : the path name of the facility
2864 *
2865 * Open the facility corresponding to the right checksum.
2866 *
2867 *returns the facility on success, NULL on error.
2868 ****************************************************************************/
2869facility_t *ltt_facility_open(char * pathname)
2870{
2871 int ret = 0;
2872 char *token;
2873 parse_file_t in;
2874 facility_t * fac = NULL;
92d82357 2875 char buffer[BUFFER_SIZE];
2876 int generated = FALSE;
2877
2878 in.buffer = &(buffer[0]);
2879 in.lineno = 0;
2880 in.error = error_callback;
2881 in.name = pathname;
2882 in.unget = 0;
2883
2884 in.fp = fopen(in.name, "r");
2885 if(in.fp == NULL) {
2886 ret = 1;
2887 goto open_error;
2888 }
2889
2890 while(1){
2891 token = getToken(&in);
2892 if(in.type == ENDFILE) break;
2893
2894 if(generated) {
2895 printf("More than one facility in the file. Only using the first one.\n");
2896 break;
2897 }
2898
2899 if(strcmp(token, "<")) in.error(&in,"not a facility file");
2900 token = getName(&in);
f389e596 2901 if(strcmp(token, "?")) in.error(&in,"not a facility file");
2902 token = getName(&in);
2903 if(strcmp(token, "xml")) in.error(&in,"not a facility file");
2904 token = getName(&in);
2905 if(strcmp(token, "version")) in.error(&in,"not a facility file");
2906 token = getName(&in);
2907 if(strcmp(token, "=")) in.error(&in,"not a facility file");
2908 token = getQuotedString(&in);
2909 if(strcmp(token, "1.0")) in.error(&in,"not a facility file");
2910 token = getName(&in);
2911 if(strcmp(token, "?")) in.error(&in,"not a facility file");
2912 token = getToken(&in);
2913 if(strcmp(token, ">")) in.error(&in,"not a facility file");
92d82357 2914
f389e596 2915 token = getName(&in);
2916 if(strcmp(token, "<")) in.error(&in,"not a facility file");
2917 token = getName(&in);
92d82357 2918 if(strcmp("facility",token) == 0) {
2919 fac = malloc(sizeof(facility_t));
2920 fac->name = NULL;
2921 fac->description = NULL;
2922 sequence_init(&(fac->events));
2923 table_init(&(fac->named_types));
2924 sequence_init(&(fac->unnamed_types));
2925
2926 parseFacility(&in, fac);
2927
2928 //check if any namedType is not defined
2929 checkNamedTypesImplemented(&fac->named_types);
2930
2e415130 2931 generateChecksum(fac->name, &fac->checksum, &fac->events);
a67cd958 2932
92d82357 2933 generated = TRUE;
2934 }
2935 else {
2936 printf("facility token was expected in file %s\n", in.name);
2937 ret = 1;
2938 goto parse_error;
2939 }
2940 }
2941
2942 parse_error:
2943 fclose(in.fp);
2944open_error:
2945
2946 if(!generated) {
2947 printf("Cannot find facility %s\n", pathname);
2948 fac = NULL;
2949 }
2950
2951 return fac;
2952}
2953
2954/* Close the facility */
2955void ltt_facility_close(facility_t *fac)
2956{
2957 free(fac->name);
2958 free(fac->capname);
2959 free(fac->description);
2960 freeEvents(&fac->events);
2961 sequence_dispose(&fac->events);
2962 freeNamedType(&fac->named_types);
2963 table_dispose(&fac->named_types);
2964 freeTypes(&fac->unnamed_types);
2965 sequence_dispose(&fac->unnamed_types);
2966 free(fac);
2967}
2968
2969
2970/* Show help */
2971void show_help(int argc, char ** argv)
2972{
2973 printf("Genevent help : \n");
2974 printf("\n");
2975 printf("Use %s name.xml\n", argv[0]);
2976 printf("to create :\n");
2977 printf("ltt-facility-name.h\n");
2978 printf("ltt-facility-id-name.h\n");
2979 printf("ltt-facility-loader-name.h\n");
2980 printf("ltt-facility-loader-name.c\n");
2981 printf("In the current directory.\n");
2982 printf("\n");
2983}
2984
2985/* Parse program arguments */
2986/* Return values :
2987 * 0 : continue program
2988 * -1 : stop program, return 0
2989 * > 0 : stop program, return value as exit.
2990 */
2991int check_args(int argc, char **argv)
2992{
2993 if(argc < 2) {
2994 printf("Not enough arguments\n");
2995 show_help(argc, argv);
2996 return EINVAL;
2997 }
2998
2999 if(strcmp(argv[1], "-h") == 0) {
3000 show_help(argc, argv);
3001 return -1;
3002 }
3003
3004 return 0;
3005}
3006
3007int main(int argc, char **argv)
3008{
3009 int err = 0;
3010 facility_t *fac;
3011
3012 err = check_args(argc, argv);
3013 if(err > 0) return err;
3014 else if(err < 0) return 0;
3015
3016 /* open the facility */
3017 fac = ltt_facility_open(argv[1]);
3018 if(fac == NULL) {
3019 printf("Error opening file %s for reading : %s\n",
3020 argv[1], strerror(errno));
3021 return errno;
3022 }
3023
3024 /* generate the output C files */
3025
3026
2d2d14a7 3027 /* ltt-facility-name.h : main logging header.
3028 * log_header */
3029 err = print_log_header(fac);
3030 if(err) return err;
92d82357 3031
2d2d14a7 3032 /* ltt-facility-id-name.h : facility id.
3033 * log_id_header */
3034 err = print_id_header(fac);
3035 if(err) return err;
92d82357 3036
2d2d14a7 3037 /* ltt-facility-loader-name.h : facility specific loader info.
3038 * loader_header */
bd7b8ca6 3039 if(!fac->user)
3040 err = print_loader_header(fac);
3041 else
3042 err = print_loader_header_user(fac);
2d2d14a7 3043 if(err) return err;
3044
3045 /* ltt-facility-loader-name.c : generic faciilty loader
3046 * loader_c */
bd7b8ca6 3047 if(!fac->user)
3048 err = print_loader_c(fac);
3049 else
3050 err = print_loader_c_user(fac);
2d2d14a7 3051 if(err) return err;
92d82357 3052
3053 /* close the facility */
3054 ltt_facility_close(fac);
3055
3056 return 0;
3057}
3058
3059
LTTng 2.x Viewer (LTTV)
This page took 0.207695 seconds and 4 git commands to generate.