+++ /dev/null
-SHELL = /bin/sh
-
-CC = gcc
-
-#CFLAGS = -std=c99 -Wall -g -DDEBUG
-CFLAGS = -std=c99 -Wall -g
-
-all: genevent
-
-install: genevent
- cp -f genevent /usr/local/bin
-
-genevent: genevent.o parser.o
- $(CC) $(CFLAGS) -o $@ $^
-
-genevent.o: genevent.c genevent.h parser.h
- $(CC) $(CFLAGS) -c -o $@ $<
-
-parser.o: parser.c parser.h
- $(CC) $(CFLAGS) -c -o $@ $<
-
-.PHONY: clean
-
-clean:
- rm -rf *.o *~ *# genevent
-
-
+++ /dev/null
-
-Mathieu Desnoyers -- November 2005
-
-This is a complete rework of genevent.
-
-The 'genevent' program parses event descriptions and generates
-the inline functions to record events in the kernel.
-
-There are several files in the directory:
- genevent.c, genevent.h, crc32.tab, parser.c and parser.h
-
-In fact, crc32.tab, parser.c and parser.h are the same files as
-those in LTT library.
-
-Important notes :
- * Do not put "-" symbols in facilities name.
- * Use the exact same name for facility xml file and for facility name.
- * As from genevent 0.17, a standard XML 1.0 description is "required". It must
- begin with the <?xml version="1.0"?> header.
-
-Note about strings :
-There are three methods to write strings in genevent, each suitable and
-efficient for a particular case. They are explained here from the fastest
-to the slowest.
-1 - The C code presents a fixed size string.
- For example, you find :
- char mystring[10];
- as string definition.
-
- you must then define it as an array of char :
- <array size="10"><char></array>
-
- Note, however, that you might not want to declare a fixed size for trace size
- and unnecessary copy matters.
-
- For instance, on a 32 bits architecture, copying a n bytes array takes
- approximately* n/4 memory read and write, for n/2 memory operations.
-
- Using the slower method described in (3), with a strlen and memcpy, where
- "u" is the number of used caracters, takes u+1 reads for the strlen, and
- approximately* (u+1)/4 read and write for the memcpy, for a total of :
- (3/2)*(u+1) memory access.
-
- So, if (n/2) > (3/2)*(u+1), or : n > 3*u+3
- where n is the size of the array
- u is the average number of used caracters (excluding the \0)
- it becomes faster to use the method number 3 with strlen.
-
-2 - The C code presents a variable size string together with its
- size.
-
- A typical use for this case is filenames in the Linux kernel. The
- dentry strucure has a d_name member, which is a struct qstr containing
- a unsigned int len and const unsigned char *name.
-
- you must use a sequence to declare this efficiently :
- <sequence><uint><char></sequence>
-
-3 - The C code presents a \0 terminated string.
-
- This is the slowest, but most convenient way to declare a string. You are
- discouraged to use it when options 1 or 2 are available. It will dynamically
- calculate the string length (byte by byte read) and only afterward do a
- memcpy.
-
- Note that, as explained in 1, if n > 3*u+3, it becomes faster to use this
- method instead of copying the whole fixed size array.
-
- Declare like this :
- <string>
-
-Here is a brief description of how to use genevent.
-
-make
-make install
-
-
-* Add new events to the kernel with genevent
-
-su -
-cd /usr/local/share/LinuxTraceToolkitViewer/facilities
-cp process.xml yourfacility.xml
- * edit yourfacility.xml to fit your needs.
-cd /tmp
-/usr/local/bin/genevent /usr/local/share/LinuxTraceToolkitViewer/yourfacility.xml
-cp ltt-facility-yourfacility.h ltt-facility-id-yourfacility.h \
- /usr/src/linux-2.6.12-rc4-mm2-lttng-0.2/include/linux/ltt
-cp ltt-facility-loader-yourfacility.c ltt-facility-loader-yourfacility.h \
- /usr/src/linux-2.6.12-rc4-mm2-lttng-0.2/ltt
- * edit the kernel file you want to instrument
- - Add #include <linux/ltt/ltt-facility-yourfacility.h> at the beginning
- of the file.
- - Add a call to the tracing functions. See their names and parameters in
- /usr/src/linux-2.6.12-rc4-mm2-lttng-0.2/include/linux/ltt/ltt-facility-yourfacility.h
-
-
-
-* The approximation comes from the fact that copies of number of caracters non
- multiple of the architecture size takes more operations (maximum of :
- (architecture size (in bytes) - 1) operations).
-
+++ /dev/null
- 0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U,
- 0x706af48fU, 0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U,
- 0xe0d5e91eU, 0x97d2d988U, 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U,
- 0x90bf1d91U, 0x1db71064U, 0x6ab020f2U, 0xf3b97148U, 0x84be41deU,
- 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U, 0x136c9856U,
- 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U,
- 0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U,
- 0xa2677172U, 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU,
- 0x35b5a8faU, 0x42b2986cU, 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U,
- 0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U, 0x26d930acU, 0x51de003aU,
- 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U, 0xcfba9599U,
- 0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U,
- 0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U,
- 0x01db7106U, 0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU,
- 0x9fbfe4a5U, 0xe8b8d433U, 0x7807c9a2U, 0x0f00f934U, 0x9609a88eU,
- 0xe10e9818U, 0x7f6a0dbbU, 0x086d3d2dU, 0x91646c97U, 0xe6635c01U,
- 0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U, 0xf262004eU, 0x6c0695edU,
- 0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U, 0x12b7e950U,
- 0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U,
- 0xfbd44c65U, 0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U,
- 0x4adfa541U, 0x3dd895d7U, 0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU,
- 0x346ed9fcU, 0xad678846U, 0xda60b8d0U, 0x44042d73U, 0x33031de5U,
- 0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU, 0x270241aaU, 0xbe0b1010U,
- 0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U, 0xce61e49fU,
- 0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U,
- 0x2eb40d81U, 0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U,
- 0x03b6e20cU, 0x74b1d29aU, 0xead54739U, 0x9dd277afU, 0x04db2615U,
- 0x73dc1683U, 0xe3630b12U, 0x94643b84U, 0x0d6d6a3eU, 0x7a6a5aa8U,
- 0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U, 0x7d079eb1U, 0xf00f9344U,
- 0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU, 0x806567cbU,
- 0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU,
- 0x67dd4accU, 0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U,
- 0xd6d6a3e8U, 0xa1d1937eU, 0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U,
- 0xa6bc5767U, 0x3fb506ddU, 0x48b2364bU, 0xd80d2bdaU, 0xaf0a1b4cU,
- 0x36034af6U, 0x41047a60U, 0xdf60efc3U, 0xa867df55U, 0x316e8eefU,
- 0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U, 0x5268e236U,
- 0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU,
- 0xb2bd0b28U, 0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U,
- 0x2cd99e8bU, 0x5bdeae1dU, 0x9b64c2b0U, 0xec63f226U, 0x756aa39cU,
- 0x026d930aU, 0x9c0906a9U, 0xeb0e363fU, 0x72076785U, 0x05005713U,
- 0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU, 0x0cb61b38U, 0x92d28e9bU,
- 0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U, 0xf1d4e242U,
- 0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U,
- 0x18b74777U, 0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU,
- 0x8f659effU, 0xf862ae69U, 0x616bffd3U, 0x166ccf45U, 0xa00ae278U,
- 0xd70dd2eeU, 0x4e048354U, 0x3903b3c2U, 0xa7672661U, 0xd06016f7U,
- 0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU, 0xd9d65adcU, 0x40df0b66U,
- 0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU, 0x30b5ffe9U,
- 0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U,
- 0xcdd70693U, 0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U,
- 0x5d681b02U, 0x2a6f2b94U, 0xb40bbe37U, 0xc30c8ea1U, 0x5a05df1bU,
- 0x2d02ef8dU
+++ /dev/null
-/******************************************************************************
- * Genevent
- *
- * Event generator. XML to logging C code converter.
- *
- * Program parameters :
- * ./genevent name.xml
- *
- * Will generate ltt-facility-name.h, ltt-facility-id-name.h
- * ltt-facility-loader-name.c, ltt-facility-loader-name.h
- * in the current directory.
- *
- * Supports :
- * - C Alignment
- * - C types : struct, union, enum, basic types.
- * - Architectures : LP32, ILP32, ILP64, LLP64, LP64.
- *
- * Additionnal structures supported :
- * - embedded variable size strings
- * - embedded variable size arrays
- * - embedded variable size sequences
- *
- * Notes :
- * (1)
- * enums are limited to integer type, as this is what is used in C. Note,
- * however, that ISO/IEC 9899:TC2 specify that the type of enum can be char,
- * unsigned int or int. This is implementation defined (compiler). That's why we
- * add a check for sizeof enum.
- *
- * (2)
- * Because of archtecture defined type sizes, we need to ask for ltt_align
- * (which gives the alignment) by passing basic types, not their actual sizes.
- * It's up to ltt_align to determine sizes of types.
- *
- * Note that, from
- * http://www.usenix.org/publications/login/standards/10.data.html
- * (Andrew Josey <a.josey@opengroup.org>) :
- *
- * Data Type LP32 ILP32 ILP64 LLP64 LP64
- * char 8 8 8 8 8
- * short 16 16 16 16 16
- * int32 32
- * int 16 32 64 32 32
- * long 32 32 64 32 64
- * long long (int64) 64
- * pointer 32 32 64 64 64
- *
- * With these constraints :
- * sizeof(char) <= sizeof(short) <= sizeof(int)
- * <= sizeof(long) = sizeof(size_t)
- *
- * and therefore sizeof(long) <= sizeof(pointer) <= sizeof(size_t)
- *
- * Which means we only have to remember which is the biggest type in a structure
- * to know the structure's alignment.
- */
-
-#define _GNU_SOURCE
-#include <limits.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <assert.h>
-
-#include "genevent.h"
-#include "parser.h"
-
-
-#define TRUE 1
-#define FALSE (!TRUE)
-
-/* Debugging printf */
-#ifdef DEBUG
-#define dprintf(...) \
- do {\
- printf(__FILE__ ",%u,%s: ",\
- __LINE__, __func__);\
- printf(__VA_ARGS__);\
- } while(0)
-#else
-#define dprintf(...)
-#endif
-
-/* Code printing */
-
-void print_tabs(unsigned int tabs, FILE *fd)
-{
- for(unsigned int i = 0; i<tabs;i++)
- fprintf(fd, "\t");
-}
-
-/* print type.
- *
- * Copied from construct_types_and_fields in LTTV facility.c */
-
-int print_type(type_descriptor_t * td, FILE *fd, unsigned int tabs,
- char *nest_name, char *field_name)
-{
- char basename[PATH_MAX];
- unsigned int basename_len = 0;
-
- strcpy(basename, nest_name);
- basename_len = strlen(basename);
-
- /* For a named type, we use the type_name directly */
- if(td->type_name != NULL) {
- strncpy(basename, td->type_name, PATH_MAX);
- basename_len = strlen(basename);
- } else {
- /* For a unnamed type, there must be a field name */
- if((basename_len != 0)
- && (basename[basename_len-1] != '_')
- && (field_name[0] != '\0')) {
- strncat(basename, "_", PATH_MAX - basename_len);
- basename_len = strlen(basename);
- }
- strncat(basename, field_name, PATH_MAX - basename_len);
- }
-
- switch(td->type) {
- case INT_FIXED:
- fprintf(fd, "%s", intOutputTypes[getSizeindex(td->size)]);
- break;
- case UINT_FIXED:
- fprintf(fd, "%s", uintOutputTypes[getSizeindex(td->size)]);
- break;
- case CHAR:
- fprintf(fd, "signed char");
- break;
- case UCHAR:
- fprintf(fd, "unsigned char");
- break;
- case SHORT:
- fprintf(fd, "short");
- break;
- case USHORT:
- fprintf(fd, "unsigned short");
- break;
- case INT:
- fprintf(fd, "int");
- break;
- case UINT:
- fprintf(fd, "unsigned int");
- break;
- case FLOAT:
- fprintf(fd, "%s", floatOutputTypes[getSizeindex(td->size)]);
- break;
- case POINTER:
- fprintf(fd, "const void *");
- break;
- case LONG:
- fprintf(fd, "long");
- break;
- case ULONG:
- fprintf(fd, "unsigned long");
- break;
- case SIZE_T:
- fprintf(fd, "size_t");
- break;
- case SSIZE_T:
- fprintf(fd, "ssize_t");
- break;
- case OFF_T:
- fprintf(fd, "off_t");
- break;
- case STRING:
- fprintf(fd, "const char *");
- break;
- case ENUM:
- fprintf(fd, "enum lttng_%s", basename);
- break;
- case ARRAY:
- fprintf(fd, "lttng_array_%s", basename);
- break;
- case SEQUENCE:
- fprintf(fd, "lttng_sequence_%s", basename);
- break;
- case STRUCT:
- fprintf(fd, "struct lttng_%s", basename);
- break;
- case UNION:
- fprintf(fd, "union lttng_%s", basename);
- break;
- default:
- printf("print_type : unknown type\n");
- return 1;
- }
-
- return 0;
-}
-
-/* Print logging function argument */
-int print_arg(type_descriptor_t * td, FILE *fd, unsigned int tabs,
- char *nest_name, char *field_name)
-{
- char basename[PATH_MAX];
- unsigned int basename_len = 0;
-
- strcpy(basename, nest_name);
- basename_len = strlen(basename);
-
- /* For a named type, we use the type_name directly */
- if(td->type_name != NULL) {
- strncpy(basename, td->type_name, PATH_MAX);
- basename_len = strlen(basename);
- } else {
- /* For a unnamed type, there must be a field name */
- if((basename_len != 0)
- && (basename[basename_len-1] != '_')
- && (field_name[0] != '\0')) {
- strncat(basename, "_", PATH_MAX - basename_len);
- basename_len = strlen(basename);
- }
- strncat(basename, field_name, PATH_MAX - basename_len);
- }
-
- print_tabs(tabs, fd);
-
- switch(td->type) {
- case INT_FIXED:
- fprintf(fd, "%s", intOutputTypes[getSizeindex(td->size)]);
- fprintf(fd, "lttng_param_%s", field_name);
- break;
- case UINT_FIXED:
- fprintf(fd, "%s", uintOutputTypes[getSizeindex(td->size)]);
- fprintf(fd, "lttng_param_%s", field_name);
- break;
- case CHAR:
- fprintf(fd, "signed char");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case UCHAR:
- fprintf(fd, "unsigned char");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case SHORT:
- fprintf(fd, "short");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case USHORT:
- fprintf(fd, "unsigned short");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case INT:
- fprintf(fd, "int");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case UINT:
- fprintf(fd, "unsigned int");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case FLOAT:
- fprintf(fd, "%s", floatOutputTypes[getSizeindex(td->size)]);
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case POINTER:
- fprintf(fd, "const void *");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case LONG:
- fprintf(fd, "long");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case ULONG:
- fprintf(fd, "unsigned long");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case SIZE_T:
- fprintf(fd, "size_t");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case SSIZE_T:
- fprintf(fd, "ssize_t");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case OFF_T:
- fprintf(fd, "off_t");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case STRING:
- fprintf(fd, "const char *");
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case ENUM:
- fprintf(fd, "enum lttng_%s", basename);
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case ARRAY:
- fprintf(fd, "lttng_array_%s", basename);
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case SEQUENCE:
- fprintf(fd, "lttng_sequence_%s *", basename);
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case STRUCT:
- fprintf(fd, "struct lttng_%s *", basename);
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- case UNION:
- fprintf(fd, "union lttng_%s *", basename);
- fprintf(fd, " lttng_param_%s", field_name);
- break;
- default:
- printf("print_type : unknown type\n");
- return 1;
- }
-
- return 0;
-}
-
-
-/* Does the type has a fixed size ? (as know from the compiler)
- *
- * 1 : fixed size
- * 0 : variable length
- */
-int has_type_fixed_size(type_descriptor_t *td)
-{
- switch(td->type) {
- case INT_FIXED:
- case UINT_FIXED:
- case CHAR:
- case UCHAR:
- case SHORT:
- case USHORT:
- case INT:
- case UINT:
- case FLOAT:
- case POINTER:
- case LONG:
- case ULONG:
- case SIZE_T:
- case SSIZE_T:
- case OFF_T:
- case ENUM:
- case UNION: /* The union must have fixed size children. Must be checked by
- the parser */
- return 1;
- break;
- case STRING:
- case SEQUENCE:
- return 0;
- break;
- case STRUCT:
- {
- int has_type_fixed = 0;
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
-
- has_type_fixed = has_type_fixed_size(type);
- if(!has_type_fixed) return 0;
- }
- return 1;
- }
- break;
- case ARRAY:
- assert(td->size >= 0);
- return has_type_fixed_size(((field_t*)td->fields.array[0])->type);
- break;
- case NONE:
- printf("There is a type defined to NONE : bad.\n");
- assert(0);
- break;
- }
- return 0; //make gcc happy.
-}
-
-
-
-
-
-/* print type declaration.
- *
- * Copied from construct_types_and_fields in LTTV facility.c */
-
-int print_type_declaration(type_descriptor_t * td, FILE *fd, unsigned int tabs,
- char *nest_name, char *field_name)
-{
- char basename[PATH_MAX];
- unsigned int basename_len = 0;
-
- if(td->custom_write) return 0; /* Does print custom type */
-
- strncpy(basename, nest_name, PATH_MAX);
- basename_len = strlen(basename);
-
- /* For a named type, we use the type_name directly */
- if(td->type_name != NULL) {
- strncpy(basename, td->type_name, PATH_MAX);
- basename_len = strlen(basename);
- } else {
- /* For a unnamed type, there must be a field name, except for
- * the array. */
- if((basename_len != 0)
- && (basename[basename_len-1] != '_'
- && (field_name[0] != '\0'))) {
- strncat(basename, "_", PATH_MAX - basename_len);
- basename_len = strlen(basename);
- }
- strncat(basename, field_name, PATH_MAX - basename_len);
- }
-
- switch(td->type) {
- case ENUM:
- fprintf(fd, "enum lttng_%s", basename);
- fprintf(fd, " {\n");
- for(unsigned int i=0;i<td->labels.position;i++){
- print_tabs(1, fd);
- fprintf(fd, "LTTNG_%s = %d", ((char*)td->labels.array[i]),
- (*(int*)td->labels_values.array[i]));
- fprintf(fd, ",\n");
- }
- fprintf(fd, "};\n");
- fprintf(fd, "\n");
- break;
-
- case ARRAY:
- dprintf("%s\n", basename);
- assert(td->size >= 0);
- if(((field_t*)td->fields.array[0])->type->type_name == NULL) {
- /* Not a named nested type : we must print its declaration first */
- if(print_type_declaration(((field_t*)td->fields.array[0])->type,
- fd, 0, basename, "")) return 1;
- }
- fprintf(fd, "#define LTTNG_ARRAY_SIZE_%s %zu\n", basename,
- td->size);
- fprintf(fd, "typedef ");
- if(print_type(((field_t*)td->fields.array[0])->type,
- fd, tabs, basename, "")) return 1;
- fprintf(fd, " lttng_array_%s[LTTNG_ARRAY_SIZE_%s];\n", basename,
- basename);
- fprintf(fd, "\n");
- break;
- case SEQUENCE:
- /* We assume that the sequence length type does not need to be declared.
- */
- if(((field_t*)td->fields.array[1])->type->type_name == NULL) {
- /* Not a named nested type : we must print its declaration first */
- if(print_type_declaration(((field_t*)td->fields.array[1])->type,
- fd, 0, basename, "")) return 1;
- }
- fprintf(fd, "typedef struct lttng_sequence_%s lttng_sequence_%s;\n",
- basename,
- basename);
- fprintf(fd, "struct lttng_sequence_%s", basename);
- fprintf(fd, " {\n");
- print_tabs(1, fd);
- if(print_type(((field_t*)td->fields.array[0])->type,
- fd, tabs, basename, "")) return 1;
- fprintf(fd, " len;\n");
- print_tabs(1, fd);
- fprintf(fd, "const ");
- if(print_type(((field_t*)td->fields.array[1])->type,
- fd, tabs, basename, "")) return 1;
- fprintf(fd, " *array;\n");
- fprintf(fd, "};\n"); /* We do not LTT_ALIGN, because we never copy
- it to the buffer directly. */
- fprintf(fd, "\n");
- break;
-
- case STRUCT:
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- if(type->type_name == NULL) {
- /* Not a named nested type : we must print its declaration first */
- if(print_type_declaration(type,
- fd, 0, basename, field->name)) return 1;
- }
- }
- fprintf(fd, "struct lttng_%s", basename);
- fprintf(fd, " {\n");
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- print_tabs(1, fd);
- if(print_type(type, fd, tabs, basename, field->name)) return 1;
- fprintf(fd, " ");
- fprintf(fd, "%s", field->name);
- fprintf(fd, ";\n");
- }
- fprintf(fd, "} LTT_ALIGN;\n");
- fprintf(fd, "\n");
- break;
- case UNION:
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- if(type->type_name == NULL) {
- /* Not a named nested type : we must print its declaration first */
- if(print_type_declaration(type,
- fd, 0, basename, field->name)) return 1;
- }
- }
- fprintf(fd, "union lttng_%s", basename);
- fprintf(fd, " {\n");
- for(unsigned i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- print_tabs(1, fd);
- if(print_type(type, fd, tabs, basename, field->name)) return 1;
- fprintf(fd, " ");
- fprintf(fd, "%s", field->name);
- fprintf(fd, ";\n");
- }
- fprintf(fd, "} LTT_ALIGN;\n");
- fprintf(fd, "\n");
- break;
- default:
- dprintf("print_type_declaration : unknown type or nothing to declare.\n");
- break;
- }
-
- return 0;
-}
-
-
-/* print type alignment.
- *
- * Copied from construct_types_and_fields in LTTV facility.c
- *
- * basename is the name which identifies the type (along with a prefix
- * (possibly)). */
-
-int print_type_alignment(type_descriptor_t * td, FILE *fd, unsigned int tabs,
- char *nest_name, char *field_name, char *obj_prefix)
-{
- char basename[PATH_MAX];
- unsigned int basename_len = 0;
-
- strncpy(basename, nest_name, PATH_MAX);
- basename_len = strlen(basename);
-
- /* For a named type, we use the type_name directly */
- if(td->type_name != NULL) {
- strncpy(basename, td->type_name, PATH_MAX);
- basename_len = strlen(basename);
- } else {
- /* For a unnamed type, there must be a field name, except for
- * the array. */
- if((basename_len != 0)
- && (basename[basename_len-1] != '_'
- && field_name != NULL
- && (field_name[0] != '\0'))) {
- strncat(basename, "_", PATH_MAX - basename_len);
- basename_len = strlen(basename);
- }
- if(field_name != NULL)
- strncat(basename, field_name, PATH_MAX - basename_len);
- }
-
- if(field_name[0] == '\0') {
- /* We are in a write function : it's the obj that we must align. */
- switch(td->type) {
- case SEQUENCE:
- fprintf(fd, "lttng_get_alignment_sequence_%s(%s)", basename,
- obj_prefix);
- break;
- case STRUCT:
- fprintf(fd, "lttng_get_alignment_struct_%s(%s)", basename,
- obj_prefix);
- break;
- case UNION:
- fprintf(fd, "lttng_get_alignment_union_%s(%s)", basename,
- obj_prefix);
- break;
- case ARRAY:
- fprintf(fd, "lttng_get_alignment_array_%s(%s)", basename,
- obj_prefix);
- case STRING:
- fprintf(fd, "sizeof(char)");
- break;
- case INT_FIXED:
- case UINT_FIXED:
- case CHAR:
- case UCHAR:
- case SHORT:
- case USHORT:
- case INT:
- case UINT:
- case FLOAT:
- case POINTER:
- case LONG:
- case ULONG:
- case SIZE_T:
- case SSIZE_T:
- case OFF_T:
- case ENUM:
- fprintf(fd, "sizeof(");
- if(print_type(td, fd, 0, basename, "")) return 1;
- fprintf(fd, ")");
- break;
-
- default:
- printf("error : type unexpected\n");
- return 1;
- break;
- }
- } else {
-
- switch(td->type) {
- case INT_FIXED:
- case UINT_FIXED:
- case CHAR:
- case UCHAR:
- case SHORT:
- case USHORT:
- case INT:
- case UINT:
- case FLOAT:
- case POINTER:
- case LONG:
- case ULONG:
- case SIZE_T:
- case SSIZE_T:
- case OFF_T:
- case ENUM:
- fprintf(fd, "sizeof(");
- if(print_type(td, fd, 0, basename, "")) return 1;
- fprintf(fd, ")");
- break;
- case STRING:
- fprintf(fd, "sizeof(char)");
- break;
- case SEQUENCE:
- fprintf(fd, "lttng_get_alignment_sequence_%s(&%s%s)", basename,
- obj_prefix, field_name);
- break;
- case STRUCT:
- fprintf(fd, "lttng_get_alignment_struct_%s(&%s%s)", basename,
- obj_prefix, field_name);
- break;
- case UNION:
- fprintf(fd, "lttng_get_alignment_union_%s(&%s%s)", basename,
- obj_prefix, field_name);
- break;
- case ARRAY:
- fprintf(fd, "lttng_get_alignment_array_%s(%s%s)", basename,
- obj_prefix, field_name);
- break;
- case NONE:
- printf("error : type NONE unexpected\n");
- return 1;
- break;
- }
- }
-
- return 0;
-}
-
-/* print type write.
- *
- * Copied from construct_types_and_fields in LTTV facility.c
- *
- * basename is the name which identifies the type (along with a prefix
- * (possibly)). */
-
-int print_type_write(type_descriptor_t * td, FILE *fd, unsigned int tabs,
- char *nest_name, char *field_name, char *obj_prefix, int get_ptr)
-{
- char basename[PATH_MAX];
- unsigned int basename_len = 0;
- char get_ptr_char[2] = "";
- char custom[PATH_MAX] = "";
-
- strncpy(basename, nest_name, PATH_MAX);
- basename_len = strlen(basename);
-
- /* For a named type, we use the type_name directly */
- if(td->type_name != NULL) {
- strncpy(basename, td->type_name, PATH_MAX);
- basename_len = strlen(basename);
- } else {
- /* For a unnamed type, there must be a field name, except for
- * the array. */
- if((basename_len != 0)
- && (basename[basename_len-1] != '_'
- && (field_name[0] != '\0'))) {
- strncat(basename, "_", PATH_MAX - basename_len);
- basename_len = strlen(basename);
- }
- strncat(basename, field_name, PATH_MAX - basename_len);
- }
-
- if(get_ptr) {
- strcpy(get_ptr_char, "&");
- }
-
- if(td->custom_write) {
- strcpy(custom, "_custom");
- }
-
- switch(td->type) {
- case INT_FIXED:
- case UINT_FIXED:
- case CHAR:
- case UCHAR:
- case SHORT:
- case USHORT:
- case INT:
- case UINT:
- case FLOAT:
- case POINTER:
- case LONG:
- case ULONG:
- case SIZE_T:
- case SSIZE_T:
- case OFF_T:
- case ENUM:
- print_tabs(tabs, fd);
- fprintf(fd, "align = ");
- if(print_type_alignment(td, fd, 0, basename, "", "obj")) return 1;
- fprintf(fd, ";\n");
- fprintf(fd, "\n");
- print_tabs(tabs, fd);
- fprintf(fd, "if(*len == 0) {\n");
- print_tabs(tabs+1, fd);
- fprintf(fd, "*to += ltt_align(*to, align); /* align output */\n");
- print_tabs(tabs, fd);
- fprintf(fd, "} else {\n");
- print_tabs(tabs+1, fd);
- fprintf(fd, "*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */\n");
- print_tabs(tabs, fd);
- fprintf(fd, "}\n");
- fprintf(fd, "\n");
-
- print_tabs(tabs, fd);
- fprintf(fd, "*len += ");
- fprintf(fd, "sizeof(");
- if(print_type(td, fd, 0, basename, "")) return 1;
- fprintf(fd, ");\n");
-
- break;
- case STRING:
- print_tabs(tabs, fd);
- fprintf(fd,
- "lttng_write%s_string_%s(buffer, to_base, to, from, len, %s%s);\n",
- custom, basename, obj_prefix, field_name);
- break;
- case SEQUENCE:
- print_tabs(tabs, fd);
- fprintf(fd,
- "lttng_write%s_sequence_%s(buffer, to_base, to, from, len, %s%s%s);",
- custom, basename, get_ptr_char, obj_prefix, field_name);
- break;
- case STRUCT:
- print_tabs(tabs, fd);
- fprintf(fd,
- "lttng_write%s_struct_%s(buffer, to_base, to, from, len, %s%s%s);",
- custom, basename, get_ptr_char, obj_prefix, field_name);
- break;
- case UNION:
- print_tabs(tabs, fd);
- fprintf(fd,
- "lttng_write%s_union_%s(buffer, to_base, to, from, len, %s%s%s);",
- custom, basename, get_ptr_char, obj_prefix, field_name);
- break;
- case ARRAY:
- print_tabs(tabs, fd);
- fprintf(fd,
- "lttng_write%s_array_%s(buffer, to_base, to, from, len, %s%s);",
- custom, basename, obj_prefix, field_name);
- break;
- case NONE:
- printf("Error : type NONE unexpected\n");
- return 1;
- break;
- }
-
- return 0;
-}
-
-/* print need local vars ?.
- *
- * Copied from print_type_write
- *
- * Does the type_write call needs local size and from variables ?
- * return value : 1 yes, 0 no.
- */
-
-int has_type_local(type_descriptor_t * td)
-{
- switch(td->type) {
- case INT_FIXED:
- case UINT_FIXED:
- case CHAR:
- case UCHAR:
- case SHORT:
- case USHORT:
- case INT:
- case UINT:
- case FLOAT:
- case POINTER:
- case LONG:
- case ULONG:
- case SIZE_T:
- case SSIZE_T:
- case OFF_T:
- case ENUM:
- return 1;
- break;
- case STRING:
- case SEQUENCE:
- case STRUCT:
- case UNION:
- case ARRAY:
- return 0;
- break;
- case NONE:
- printf("Error : type NONE unexpected\n");
- return 1;
- break;
- }
-
- return 0;
-}
-
-
-
-/* print type alignment function.
- *
- * Copied from construct_types_and_fields in LTTV facility.c
- *
- * basename is the name which identifies the type (along with a prefix
- * (possibly)). */
-
-int print_type_alignment_fct(type_descriptor_t * td, FILE *fd,
- unsigned int tabs,
- char *nest_name, char *field_name)
-{
- char basename[PATH_MAX];
- unsigned int basename_len = 0;
-
- if(td->custom_write) return 0; /* Does print custom type */
-
- strncpy(basename, nest_name, PATH_MAX);
- basename_len = strlen(basename);
-
- /* For a named type, we use the type_name directly */
- if(td->type_name != NULL) {
- strncpy(basename, td->type_name, PATH_MAX);
- basename_len = strlen(basename);
- } else {
- /* For a unnamed type, there must be a field name, except for
- * the array. */
- if((basename_len != 0)
- && (basename[basename_len-1] != '_'
- && (field_name[0] != '\0'))) {
- strncat(basename, "_", PATH_MAX - basename_len);
- basename_len = strlen(basename);
- }
- strncat(basename, field_name, PATH_MAX - basename_len);
- }
-
- switch(td->type) {
- case SEQUENCE:
- if(((field_t*)td->fields.array[1])->type->type_name == NULL) {
- /* Not a named nested type : we must print its align fct */
- if(print_type_alignment_fct(((field_t*)td->fields.array[1])->type, fd,
- 0, basename, "")) return 1;
- }
- /* Function header */
- fprintf(fd, "static inline size_t lttng_get_alignment_sequence_%s(\n",
- basename);
- print_tabs(2, fd);
- if(print_type(td, fd, 0, basename, "")) return 1;
- fprintf(fd, " *obj)\n");
- fprintf(fd, "{\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t align=0, localign;");
- fprintf(fd, "\n");
- print_tabs(1, fd);
- fprintf(fd, "localign = ");
- if(print_type_alignment(((field_t*)td->fields.array[0])->type,
- fd, 0, basename, "len", "obj->")) return 1;
- fprintf(fd, ";\n");
- print_tabs(1, fd);
- fprintf(fd, "align = max(align, localign);\n");
- fprintf(fd, "\n");
- print_tabs(1, fd);
- fprintf(fd, "localign = ");
- if(print_type_alignment(((field_t*)td->fields.array[1])->type,
- fd, 0, basename, "array[0]", "obj->")) return 1;
- fprintf(fd, ";\n");
- print_tabs(1, fd);
- fprintf(fd, "align = max(align, localign);\n");
- fprintf(fd, "\n");
- print_tabs(1, fd);
- fprintf(fd, "return align;\n");
- break;
- case STRUCT:
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- if(type->type_name == NULL) {
- /* Not a named nested type : we must print its align fct */
- if(print_type_alignment_fct(type, fd,
- 0, basename, field->name)) return 1;
- }
- }
- /* Function header */
- fprintf(fd, "static inline size_t lttng_get_alignment_struct_%s(\n",
- basename);
- print_tabs(2, fd);
- if(print_type(td, fd, 0, basename, "")) return 1;
- fprintf(fd, " *obj)\n");
- fprintf(fd, "{\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t align=0, localign;");
- fprintf(fd, "\n");
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- print_tabs(1, fd);
- fprintf(fd, "localign = ");
- if(print_type_alignment(type, fd, 0, basename, field->name, "obj->"))
- return 1;
- fprintf(fd, ";\n");
- print_tabs(1, fd);
- fprintf(fd, "align = max(align, localign);\n");
- fprintf(fd, "\n");
- }
- print_tabs(1, fd);
- fprintf(fd, "return align;\n");
-
- break;
- case UNION:
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- if(type->type_name == NULL) {
- /* Not a named nested type : we must print its align fct */
- if(print_type_alignment_fct(type, fd,
- 0, basename, field->name)) return 1;
- }
- }
- /* Function header */
- fprintf(fd, "static inline size_t lttng_get_alignment_union_%s(\n",
- basename);
- print_tabs(2, fd);
- if(print_type(td, fd, 0, basename, "")) return 1;
- fprintf(fd, " *obj)\n");
- fprintf(fd, "{\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t align=0, localign;");
- fprintf(fd, "\n");
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- print_tabs(1, fd);
- fprintf(fd, "localign = ");
- if(print_type_alignment(type, fd, 0, basename, field->name, "obj->"))
- return 1;
- fprintf(fd, ";\n");
- print_tabs(1, fd);
- fprintf(fd, "align = max(align, localign);\n");
- fprintf(fd, "\n");
- }
- print_tabs(1, fd);
- fprintf(fd, "return align;\n");
-
- break;
- case ARRAY:
- if(((field_t*)td->fields.array[0])->type->type_name == NULL) {
- /* Not a named nested type : we must print its align fct */
- if(print_type_alignment_fct(((field_t*)td->fields.array[0])->type, fd,
- 0, basename, "")) return 1;
- }
- /* Function header */
- fprintf(fd, "static inline size_t lttng_get_alignment_array_%s(\n",
- basename);
- print_tabs(2, fd);
- if(print_type(td, fd, 0, basename, "")) return 1;
- fprintf(fd, " obj)\n");
- fprintf(fd, "{\n");
- print_tabs(1, fd);
- fprintf(fd, "return \n");
- if(print_type_alignment(((field_t*)td->fields.array[0])->type,
- fd, 0, basename, "", "obj[0]"))
- return 1;
- fprintf(fd, ";\n");
- break;
- default:
- dprintf("print_type_alignment_fct : type has no alignment function.\n");
- return 0;
- break;
- }
-
-
- /* Function footer */
- fprintf(fd, "}\n");
- fprintf(fd, "\n");
-
- return 0;
-}
-
-/* print type write function.
- *
- * Copied from construct_types_and_fields in LTTV facility.c
- *
- * basename is the name which identifies the type (along with a prefix
- * (possibly)). */
-
-int print_type_write_fct(type_descriptor_t * td, FILE *fd, unsigned int tabs,
- char *nest_name, char *field_name)
-{
- char basename[PATH_MAX];
- unsigned int basename_len = 0;
-
- if(td->custom_write) return 0; /* Does print custom type */
-
- strncpy(basename, nest_name, PATH_MAX);
- basename_len = strlen(basename);
-
- /* For a named type, we use the type_name directly */
- if(td->type_name != NULL) {
- strncpy(basename, td->type_name, PATH_MAX);
- basename_len = strlen(basename);
- } else {
- /* For a unnamed type, there must be a field name, except for
- * the array. */
- if((basename_len != 0)
- && (basename[basename_len-1] != '_'
- && (field_name[0] != '\0'))) {
- strncat(basename, "_", PATH_MAX - basename_len);
- basename_len = strlen(basename);
- }
- strncat(basename, field_name, PATH_MAX - basename_len);
- }
-
- switch(td->type) {
- case SEQUENCE:
- if(((field_t*)td->fields.array[1])->type->type_name == NULL) {
- /* Not a named nested type : we must print its write fct */
- if(print_type_write_fct(((field_t*)td->fields.array[1])->type, fd,
- 0, basename, "")) return 1;
- }
- break;
- case STRUCT:
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- if(type->type_name == NULL) {
- /* Not a named nested type : we must print its write fct */
- if(print_type_write_fct(type, fd,
- 0, basename, field->name)) return 1;
- }
- }
- break;
- case UNION:
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- if(type->type_name == NULL) {
- /* Not a named nested type : we must print its write fct */
- if(print_type_write_fct(type, fd,
- 0, basename, field->name)) return 1;
- }
- }
- break;
- case ARRAY:
- if(((field_t*)td->fields.array[0])->type->type_name == NULL) {
- /* Not a named nested type : we must print its write fct */
- if(print_type_write_fct(((field_t*)td->fields.array[0])->type, fd,
- 0, basename, "")) return 1;
- }
- break;
- case STRING:
- break;
- default:
- dprintf("print_type_write_fct : type has no write function.\n");
- return 0;
- break;
- }
-
- /* Print header */
- switch(td->type) {
- case SEQUENCE:
- fprintf(fd, "static inline void lttng_write_sequence_%s(\n",
- basename);
- break;
- case STRUCT:
- fprintf(fd, "static inline void lttng_write_struct_%s(\n", basename);
- break;
- case UNION:
- fprintf(fd, "static inline void lttng_write_union_%s(\n", basename);
- break;
- case ARRAY:
- fprintf(fd, "static inline void lttng_write_array_%s(\n", basename);
- break;
- case STRING:
- fprintf(fd, "static inline void lttng_write_string_%s(\n", basename);
- break;
- default:
- printf("print_type_write_fct : type has no write function.\n");
- break;
- }
-
- print_tabs(2, fd);
- fprintf(fd, "void *buffer,\n");
- print_tabs(2, fd);
- fprintf(fd, "size_t *to_base,\n");
- print_tabs(2, fd);
- fprintf(fd, "size_t *to,\n");
- print_tabs(2, fd);
- fprintf(fd, "const void **from,\n");
- print_tabs(2, fd);
- fprintf(fd, "size_t *len,\n");
- print_tabs(2, fd);
- if(print_type(td, fd, 0, basename, "")) return 1;
-
- switch(td->type) {
- case SEQUENCE:
- fprintf(fd, " *obj)\n");
- break;
- case STRUCT:
- fprintf(fd, " *obj)\n");
- break;
- case UNION:
- fprintf(fd, " *obj)\n");
- break;
- case ARRAY:
- fprintf(fd, " obj)\n");
- break;
- case STRING:
- fprintf(fd, " obj)\n");
- break;
- default:
- printf("print_type_write_fct : type has no write function.\n");
- break;
- }
-
- fprintf(fd, "{\n");
-
- switch(td->type) {
- case STRING:
- print_tabs(1, fd);
- fprintf(fd, "size_t size;\n");
- break;
- default:
- break;
- }
-
- print_tabs(1, fd);
- fprintf(fd, "size_t align;\n");
- fprintf(fd, "\n");
-
- switch(td->type) {
- case SEQUENCE:
- case STRING:
- print_tabs(1, fd);
- fprintf(fd, "/* Flush pending memcpy */\n");
- print_tabs(1, fd);
- fprintf(fd, "if(*len != 0) {\n");
- print_tabs(2, fd);
- fprintf(fd, "if(buffer != NULL)\n");
- print_tabs(3, fd);
- fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
- print_tabs(1, fd);
- fprintf(fd, "}\n");
- print_tabs(1, fd);
- fprintf(fd, "*to += *len;\n");
- print_tabs(1, fd);
- fprintf(fd, "*len = 0;\n");
- fprintf(fd, "\n");
- break;
- case STRUCT:
- case UNION:
- case ARRAY:
- break;
- default:
- printf("print_type_write_fct : type has no write function.\n");
- break;
- }
-
- print_tabs(1, fd);
- fprintf(fd, "align = ");
- if(print_type_alignment(td, fd, 0, basename, "", "obj")) return 1;
- fprintf(fd, ";\n");
- fprintf(fd, "\n");
- print_tabs(1, fd);
- fprintf(fd, "if(*len == 0) {\n");
- print_tabs(2, fd);
- fprintf(fd, "*to += ltt_align(*to, align); /* align output */\n");
- print_tabs(1, fd);
- fprintf(fd, "} else {\n");
- print_tabs(2, fd);
- fprintf(fd, "*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */\n");
- print_tabs(1, fd);
- fprintf(fd, "}\n");
- fprintf(fd, "\n");
-
- /* First, check if the type has a fixed size. If it is the case, then the size
- * to write is know by the compiler : simply use a sizeof() */
- if(has_type_fixed_size(td)) {
- print_tabs(1, fd);
- fprintf(fd, "/* Contains only fixed size fields : use compiler sizeof() */\n");
- fprintf(fd, "\n");
- print_tabs(1, fd);
- fprintf(fd, "*len += sizeof(");
- if(print_type(td, fd, 0, basename, field_name)) return 1;
- fprintf(fd, ");\n");
- } else {
- /* The type contains nested variable size subtypes :
- * we must write field by field. */
- print_tabs(1, fd);
- fprintf(fd, "/* Contains variable sized fields : must explode the structure */\n");
- fprintf(fd, "\n");
-
- switch(td->type) {
- case SEQUENCE:
- print_tabs(1, fd);
- fprintf(fd, "/* Copy members */\n");
-// print_tabs(1, fd);
-// fprintf(fd, "size = sizeof(\n");
- if(print_type_write(((field_t*)td->fields.array[0])->type,
- fd, 1, basename, "len", "obj->", 1)) return 1;
- fprintf(fd, "\n");
-// fprintf(fd, ");\n");
-// print_tabs(1, fd);
-// fprintf(fd, "*to += ltt_align(*to, size);\n");
- print_tabs(1, fd);
- fprintf(fd, "if(buffer != NULL)\n");
- print_tabs(2, fd);
- fprintf(fd, "memcpy(buffer+*to_base+*to, &obj->len, *len);\n");
- print_tabs(1, fd);
- fprintf(fd, "*to += *len;\n");
- print_tabs(1, fd);
- fprintf(fd, "*len = 0;\n");
- fprintf(fd, "\n");
-
- /* Write the child : varlen child or not ? */
- if(has_type_fixed_size(((field_t*)td->fields.array[1])->type)) {
- /* Fixed size len child : use a multiplication of its size */
-// print_tabs(1, fd);
-// fprintf(fd, "size = sizeof(\n");
-
- //print_tabs(1, fd);
- /* We know that *len does not contain alignment because of the
- * previous align output. len is always 0 here. */
- if(print_type_write(((field_t*)td->fields.array[1])->type,
- fd, 1, basename, "array[0]", "obj->", 1))
- return 1;
-// fprintf(fd, ");\n");
- fprintf(fd, "\n");
- print_tabs(1, fd);
- fprintf(fd, "*len = obj->len * (*len);\n");
- print_tabs(1, fd);
- fprintf(fd, "if(buffer != NULL)\n");
- print_tabs(2, fd);
- fprintf(fd, "memcpy(buffer+*to_base+*to, obj->array, *len);\n");
- print_tabs(1, fd);
- fprintf(fd, "*to += *len;\n");
- print_tabs(1, fd);
- fprintf(fd, "*len = 0;\n");
- fprintf(fd, "\n");
- } else {
- print_tabs(1, fd);
- fprintf(fd, "/* Variable length child : iter. */\n");
- print_tabs(1, fd);
- fprintf(fd, "for(unsigned int i=0; i<obj->len; i++) {\n");
- if(print_type_write(((field_t*)td->fields.array[1])->type,
- fd, 2, basename, "array[i]", "obj->", 1)) return 1;
- print_tabs(1, fd);
- fprintf(fd, "}\n");
- }
- fprintf(fd, "\n");
- print_tabs(1, fd);
- fprintf(fd, "/* Realign the *to_base on arch size, set *to to 0 */\n");
- print_tabs(1, fd);
- fprintf(fd, "*to += ltt_align(*to, sizeof(void *));\n");
- print_tabs(1, fd);
- fprintf(fd, "*to_base = *to_base+*to;\n");
- print_tabs(1, fd);
- fprintf(fd, "*to = 0;\n");
- fprintf(fd, "\n");
- print_tabs(1, fd);
- fprintf(fd, "/* Put source *from just after the C sequence */\n");
- print_tabs(1, fd);
- fprintf(fd, "*from = obj+1;\n");
- break;
- case STRING:
- print_tabs(1, fd);
- fprintf(fd, "size = strlen(obj) + 1; /* Include final NULL char. */\n");
- print_tabs(1, fd);
- fprintf(fd, "if(buffer != NULL)\n");
- print_tabs(2, fd);
- fprintf(fd, "memcpy(buffer+*to_base+*to, obj, size);\n");
- print_tabs(1, fd);
- fprintf(fd, "*to += size;\n");
- fprintf(fd, "\n");
- print_tabs(1, fd);
- fprintf(fd, "/* Realign the *to_base on arch size, set *to to 0 */\n");
- print_tabs(1, fd);
- fprintf(fd, "*to += ltt_align(*to, sizeof(void *));\n");
- print_tabs(1, fd);
- fprintf(fd, "*to_base = *to_base+*to;\n");
- print_tabs(1, fd);
- fprintf(fd, "*to = 0;\n");
- fprintf(fd, "\n");
- print_tabs(1, fd);
- fprintf(fd, "/* Put source *from just after the C string */\n");
- print_tabs(1, fd);
- fprintf(fd, "*from += size;\n");
- break;
- case STRUCT:
- for(unsigned int i=0;i<td->fields.position;i++){
- field_t *field = (field_t*)(td->fields.array[i]);
- type_descriptor_t *type = field->type;
- if(print_type_write(type,
- fd, 1, basename, field->name, "obj->", 1)) return 1;
- fprintf(fd, "\n");
- }
- break;
- case UNION:
- printf("ERROR : A union CANNOT contain a variable size child.\n");
- return 1;
- break;
- case ARRAY:
- /* Write the child : varlen child or not ? */
- if(has_type_fixed_size(((field_t*)td->fields.array[0])->type)) {
- /* Error : if an array has a variable size, then its child must also
- * have a variable size. */
- assert(0);
- } else {
- print_tabs(1, fd);
- fprintf(fd, "/* Variable length child : iter. */\n");
- print_tabs(1, fd);
- fprintf(fd, "for(unsigned int i=0; i<LTTNG_ARRAY_SIZE_%s; i++) {\n", basename);
- if(print_type_write(((field_t*)td->fields.array[0])->type,
- fd, 2, basename, "", "obj->array[i]", 1)) return 1;
- print_tabs(1, fd);
- fprintf(fd, "}\n");
- }
- break;
- default:
- printf("print_type_write_fct : type has no write function.\n");
- break;
- }
-
-
- }
-
-
- /* Function footer */
- fprintf(fd, "}\n");
- fprintf(fd, "\n");
- return 0;
-}
-
-
-
-/* Print the logging function of an event. This is the core of genevent */
-int print_event_logging_function(char *basename, facility_t *fac,
- event_t *event, FILE *fd)
-{
- fprintf(fd, "static inline void trace_%s(\n", basename);
- int has_argument = 0;
- int has_type_fixed = 0;
-
- /* Does it support per trace tracing ? */
- if(event->per_trace) {
- print_tabs(2, fd);
- fprintf(fd, "struct ltt_trace_struct *dest_trace");
- has_argument = 1;
- }
-
- /* Does it support per tracefile tracing ? */
- if(event->per_tracefile) {
- if(has_argument) {
- fprintf(fd, ",");
- fprintf(fd, "\n");
- }
- fprintf(fd, "unsigned int tracefile_index");
- has_argument = 1;
- }
-
- for(unsigned int j = 0; j < event->fields.position; j++) {
- /* For each field, print the function argument */
- field_t *f = (field_t*)event->fields.array[j];
- type_descriptor_t *t = f->type;
- if(has_argument) {
- fprintf(fd, ",");
- fprintf(fd, "\n");
- }
- if(print_arg(t, fd, 2, basename, f->name)) return 1;
- has_argument = 1;
- }
- if(!has_argument) {
- print_tabs(2, fd);
- fprintf(fd, "void");
- }
- fprintf(fd,")\n");
- fprintf(fd,
- "#if (!defined(CONFIG_LTT) || !defined(CONFIG_LTT_FACILITY_%s))\n",
- fac->capname);
- fprintf(fd, "{\n");
- fprintf(fd, "}\n");
- fprintf(fd,"#else\n");
- fprintf(fd, "{\n");
- /* Print the function variables */
- print_tabs(1, fd);
- fprintf(fd, "unsigned int index;\n");
- print_tabs(1, fd);
- fprintf(fd, "struct ltt_channel_struct *channel;\n");
- print_tabs(1, fd);
- fprintf(fd, "struct ltt_trace_struct *trace;\n");
- print_tabs(1, fd);
- fprintf(fd, "struct rchan_buf *relayfs_buf;\n");
- print_tabs(1, fd);
- fprintf(fd, "void *buffer = NULL;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t *to_base = &real_to_base;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t real_to = 0;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t *to = &real_to;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t real_len = 0;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t *len = &real_len;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t reserve_size;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t slot_size;\n");
- print_tabs(1, fd);
-
- if(event->fields.position > 0) {
- for(unsigned int i=0;i<event->fields.position;i++){
- /* Search for at least one child with fixed size. It means
- * we need local variables.*/
- field_t *field = (field_t*)(event->fields.array[i]);
- type_descriptor_t *type = field->type;
- has_type_fixed = has_type_local(type);
- if(has_type_fixed) break;
- }
-
- if(has_type_fixed) {
- fprintf(fd, "size_t align;\n");
- print_tabs(1, fd);
- }
-
- fprintf(fd, "const void *real_from;\n");
- print_tabs(1, fd);
- fprintf(fd, "const void **from = &real_from;\n");
- print_tabs(1, fd);
- }
- fprintf(fd, "u64 tsc;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t before_hdr_pad, after_hdr_pad, header_size;\n");
- fprintf(fd, "\n");
-
- print_tabs(1, fd);
- fprintf(fd, "if(ltt_traces.num_active_traces == 0) return;\n");
- fprintf(fd, "\n");
-
- /* Calculate event variable len + event data alignment offset.
- * Assume that the padding for alignment starts at a void*
- * address.
- * This excludes the header size and alignment. */
-
- print_tabs(1, fd);
- fprintf(fd, "/* For each field, calculate the field size. */\n");
- print_tabs(1, fd);
- fprintf(fd, "/* size = *to_base + *to + *len */\n");
- print_tabs(1, fd);
- fprintf(fd, "/* Assume that the padding for alignment starts at a\n");
- print_tabs(1, fd);
- fprintf(fd, " * sizeof(void *) address. */\n");
- fprintf(fd, "\n");
-
- for(unsigned int i=0;i<event->fields.position;i++){
- field_t *field = (field_t*)(event->fields.array[i]);
- type_descriptor_t *type = field->type;
- /* Set from */
- print_tabs(1, fd);
- switch(type->type) {
- case SEQUENCE:
- case UNION:
- case ARRAY:
- case STRUCT:
- case STRING:
- fprintf(fd, "*from = lttng_param_%s;\n", field->name);
- break;
- default:
- fprintf(fd, "*from = <tng_param_%s;\n", field->name);
- break;
- }
-
- if(print_type_write(type,
- fd, 1, basename, field->name, "lttng_param_", 0)) return 1;
- fprintf(fd, "\n");
- }
- print_tabs(1, fd);
- fprintf(fd, "reserve_size = *to_base + *to + *len;\n");
-
- /* Take locks : make sure the trace does not vanish while we write on
- * it. A simple preemption disabling is enough (using rcu traces). */
- print_tabs(1, fd);
- fprintf(fd, "preempt_disable();\n");
- print_tabs(1, fd);
- fprintf(fd, "ltt_nesting[smp_processor_id()]++;\n");
-
- /* Get facility index */
-
- if(event->per_tracefile) {
- print_tabs(1, fd);
- fprintf(fd, "index = tracefile_index;\n");
- } else {
- print_tabs(1, fd);
- fprintf(fd,
- "index = ltt_get_index_from_facility(ltt_facility_%s_%X,\n"\
- "\t\t\t\t\t\tevent_%s_%s);\n",
- fac->name, fac->checksum, fac->name, event->name);
- }
- fprintf(fd,"\n");
-
-
- /* For each trace */
- print_tabs(1, fd);
- fprintf(fd, "list_for_each_entry_rcu(trace, <t_traces.head, list) {\n");
- print_tabs(2, fd);
- fprintf(fd, "if(!trace->active) continue;\n\n");
-
- if(event->per_trace) {
- print_tabs(2, fd);
- fprintf(fd, "if(dest_trace != trace) continue;\n\n");
- }
-
- print_tabs(2, fd);
- fprintf(fd, "channel = ltt_get_channel_from_index(trace, index);\n");
- print_tabs(2, fd);
- fprintf(fd, "relayfs_buf = channel->rchan->buf[smp_processor_id()];\n");
- fprintf(fd, "\n");
-
-
- /* Relay reserve */
- /* If error, increment event lost counter (done by ltt_reserve_slot) and
- * return */
- print_tabs(2, fd);
- fprintf(fd, "slot_size = 0;\n");
- print_tabs(2, fd);
- fprintf(fd, "buffer = ltt_reserve_slot(trace, relayfs_buf,\n");
- print_tabs(3, fd);
- fprintf(fd, "reserve_size, &slot_size, &tsc,\n");
- print_tabs(3, fd);
- fprintf(fd, "&before_hdr_pad, &after_hdr_pad, &header_size);\n");
- /* If error, return */
- print_tabs(2, fd);
- fprintf(fd, "if(!buffer) continue; /* buffer full */\n\n");
- //print_tabs(2, fd);
- // for DEBUG only
- // fprintf(fd, "goto commit; /* DEBUG : never actually write. */\n\n");
- print_tabs(2, fd);
- fprintf(fd, "*to_base = *to = *len = 0;\n");
- fprintf(fd, "\n");
-
- /* Write event header */
- print_tabs(2, fd);
- fprintf(fd, "ltt_write_event_header(trace, channel, buffer,\n");
- print_tabs(3, fd);
- fprintf(fd, "ltt_facility_%s_%X, event_%s_%s,\n", fac->name, fac->checksum,
- fac->name, event->name);
- print_tabs(3, fd);
- fprintf(fd, "reserve_size, before_hdr_pad, tsc);\n");
- print_tabs(2, fd);
- fprintf(fd, "*to_base += before_hdr_pad + after_hdr_pad + header_size;\n");
- fprintf(fd, "\n");
-
- /* write data. */
-
- for(unsigned int i=0;i<event->fields.position;i++){
- field_t *field = (field_t*)(event->fields.array[i]);
- type_descriptor_t *type = field->type;
-
- /* Set from */
- print_tabs(2, fd);
- switch(type->type) {
- case SEQUENCE:
- case UNION:
- case ARRAY:
- case STRUCT:
- case STRING:
- fprintf(fd, "*from = lttng_param_%s;\n", field->name);
- break;
- default:
- fprintf(fd, "*from = <tng_param_%s;\n", field->name);
- break;
- }
-
-
- if(print_type_write(type,
- fd, 2, basename, field->name, "lttng_param_", 0)) return 1;
- fprintf(fd, "\n");
-
- /* Don't forget to flush pending memcpy */
- print_tabs(2, fd);
- fprintf(fd, "/* Flush pending memcpy */\n");
- print_tabs(2, fd);
- fprintf(fd, "if(*len != 0) {\n");
- print_tabs(3, fd);
- fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
- print_tabs(3, fd);
- fprintf(fd, "*to += *len;\n");
- //print_tabs(3, fd);
- //fprintf(fd, "from += len;\n");
- print_tabs(3, fd);
- fprintf(fd, "*len = 0;\n");
- print_tabs(2, fd);
- fprintf(fd, "}\n");
- fprintf(fd, "\n");
- }
-
-
- /* commit */
- // for DEBUG only.
- //fprintf(fd, "commit:\n"); /* DEBUG! */
- print_tabs(2, fd);
- fprintf(fd, "ltt_commit_slot(relayfs_buf, buffer, slot_size);\n\n");
-
- print_tabs(1, fd);
- fprintf(fd, "}\n\n");
-
- /* Release locks */
- print_tabs(1, fd);
- fprintf(fd, "ltt_nesting[smp_processor_id()]--;\n");
- print_tabs(1, fd);
- fprintf(fd, "preempt_enable_no_resched();\n");
-
- fprintf(fd, "}\n");
- fprintf(fd, "#endif //(!defined(CONFIG_LTT) || !defined(CONFIG_LTT_FACILITY_%s))\n\n",
- fac->capname);
- return 0;
-}
-
-/* print_event_logging_function_user_generic
- * Print the logging function of an event for userspace tracing. This is the
- * core of genevent */
-int print_event_logging_function_user_generic(char *basename, facility_t *fac,
- event_t *event, FILE *fd)
-{
- char *attrib;
-
- fprintf(fd, "#ifndef LTT_TRACE_FAST\n");
-
- if(event->no_instrument_function) {
- attrib = "__attribute__((no_instrument_function)) ";
- } else {
- attrib = "";
- }
- if(event->param_buffer) {
- fprintf(fd, "static inline %sint trace_%s_param_buffer(\n", attrib, basename);
- } else {
- fprintf(fd, "static inline %sint trace_%s(\n",attrib, basename);
- }
- int has_argument = 0;
- int has_type_fixed = 0;
-
- if(event->param_buffer) {
- if(has_argument) {
- fprintf(fd, ",");
- fprintf(fd, "\n");
- }
- print_tabs(2, fd);
- fprintf(fd, "void *buffer");
- has_argument = 1;
- fprintf(fd, ",");
- fprintf(fd, "\n");
- print_tabs(2, fd);
- fprintf(fd, "size_t reserve_size");
- } else {
- for(unsigned int j = 0; j < event->fields.position; j++) {
- /* For each field, print the function argument */
- field_t *f = (field_t*)event->fields.array[j];
- type_descriptor_t *t = f->type;
- if(has_argument) {
- fprintf(fd, ",");
- fprintf(fd, "\n");
- }
- if(print_arg(t, fd, 2, basename, f->name)) return 1;
- has_argument = 1;
- }
- }
- if(!has_argument) {
- print_tabs(2, fd);
- fprintf(fd, "void");
- }
- fprintf(fd,")\n");
- fprintf(fd,
- "#ifndef LTT_TRACE\n");
- fprintf(fd, "{\n");
- fprintf(fd, "}\n");
- fprintf(fd,"#else\n");
- fprintf(fd, "{\n");
- /* Print the function variables */
- print_tabs(1, fd);
- fprintf(fd, "int ret = 0;\n");
- if(event->param_buffer) {
- print_tabs(1, fd);
- fprintf(fd, "reserve_size = ltt_align(reserve_size, sizeof(void *));\n");
- print_tabs(1, fd);
- fprintf(fd, "{\n");
- goto do_syscall;
- }
- print_tabs(1, fd);
- fprintf(fd, "void *buffer = NULL;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t *to_base = &real_to_base;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t real_to = 0;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t *to = &real_to;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t real_len = 0;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t *len = &real_len;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t reserve_size;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t slot_size;\n");
- print_tabs(1, fd);
-
- if(event->fields.position > 0) {
- for(unsigned int i=0;i<event->fields.position;i++){
- /* Search for at least one child with fixed size. It means
- * we need local variables.*/
- field_t *field = (field_t*)(event->fields.array[i]);
- type_descriptor_t *type = field->type;
- has_type_fixed = has_type_local(type);
- if(has_type_fixed) break;
- }
-
- if(has_type_fixed) {
- fprintf(fd, "size_t align;\n");
- print_tabs(1, fd);
- }
-
- fprintf(fd, "const void *real_from;\n");
- print_tabs(1, fd);
- fprintf(fd, "const void **from = &real_from;\n");
- print_tabs(1, fd);
- }
-
- /* Calculate event variable len + event data alignment offset.
- * Assume that the padding for alignment starts at a void*
- * address.
- * This excludes the header size and alignment. */
-
- print_tabs(1, fd);
- fprintf(fd, "/* For each field, calculate the field size. */\n");
- print_tabs(1, fd);
- fprintf(fd, "/* size = *to_base + *to + *len */\n");
- print_tabs(1, fd);
- fprintf(fd, "/* Assume that the padding for alignment starts at a\n");
- print_tabs(1, fd);
- fprintf(fd, " * sizeof(void *) address. */\n");
- fprintf(fd, "\n");
-
- for(unsigned int i=0;i<event->fields.position;i++){
- field_t *field = (field_t*)(event->fields.array[i]);
- type_descriptor_t *type = field->type;
- /* Set from */
- print_tabs(1, fd);
- switch(type->type) {
- case SEQUENCE:
- case UNION:
- case ARRAY:
- case STRUCT:
- case STRING:
- fprintf(fd, "*from = lttng_param_%s;\n", field->name);
- break;
- default:
- fprintf(fd, "*from = <tng_param_%s;\n", field->name);
- break;
- }
-
- if(print_type_write(type,
- fd, 1, basename, field->name, "lttng_param_", 0)) return 1;
- fprintf(fd, "\n");
- }
- print_tabs(1, fd);
- fprintf(fd, "reserve_size = *to_base + *to + *len;\n");
-
- print_tabs(1, fd);
- fprintf(fd, "{\n");
- print_tabs(2, fd);
- fprintf(fd, "char stack_buffer[reserve_size];\n");
- print_tabs(2, fd);
- fprintf(fd, "buffer = stack_buffer;\n");
- fprintf(fd, "\n");
-
-
- //print_tabs(2, fd);
- // for DEBUG only
- // fprintf(fd, "goto commit; /* DEBUG : never actually write. */\n\n");
- print_tabs(2, fd);
- fprintf(fd, "*to_base = *to = *len = 0;\n");
- fprintf(fd, "\n");
-
- /* write data. */
-
- for(unsigned int i=0;i<event->fields.position;i++){
- field_t *field = (field_t*)(event->fields.array[i]);
- type_descriptor_t *type = field->type;
-
- /* Set from */
- print_tabs(2, fd);
- switch(type->type) {
- case SEQUENCE:
- case UNION:
- case ARRAY:
- case STRUCT:
- case STRING:
- fprintf(fd, "*from = lttng_param_%s;\n", field->name);
- break;
- default:
- fprintf(fd, "*from = <tng_param_%s;\n", field->name);
- break;
- }
-
-
- if(print_type_write(type,
- fd, 2, basename, field->name, "lttng_param_", 0)) return 1;
- fprintf(fd, "\n");
-
- /* Don't forget to flush pending memcpy */
- print_tabs(2, fd);
- fprintf(fd, "/* Flush pending memcpy */\n");
- print_tabs(2, fd);
- fprintf(fd, "if(*len != 0) {\n");
- print_tabs(3, fd);
- fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
- print_tabs(3, fd);
- fprintf(fd, "*to += *len;\n");
- //print_tabs(3, fd);
- //fprintf(fd, "from += len;\n");
- print_tabs(3, fd);
- fprintf(fd, "*len = 0;\n");
- print_tabs(2, fd);
- fprintf(fd, "}\n");
- fprintf(fd, "\n");
- }
-
-do_syscall:
- print_tabs(2, fd);
- fprintf(fd, "ret = ltt_trace_generic(ltt_facility_%s_%X, event_%s_%s, buffer, reserve_size, LTT_BLOCKING);\n", fac->name, fac->checksum, fac->name, event->name);
-
- print_tabs(1, fd);
- fprintf(fd, "}\n\n");
-
- print_tabs(1, fd);
- fprintf(fd, "return ret;\n\n");
-
- fprintf(fd, "}\n");
- fprintf(fd,
- "#endif //LTT_TRACE\n");
- fprintf(fd, "#endif //!LTT_TRACE_FAST\n\n");
-
- return 0;
-}
-
-/* print_event_logging_function_user_fast
- * Print the logging function of an event for userspace tracing. This is the
- * core of genevent */
-int print_event_logging_function_user_fast(char *basename, facility_t *fac,
- event_t *event, FILE *fd)
-{
- char *attrib;
-
- fprintf(fd, "#ifdef LTT_TRACE_FAST\n");
-
- if(event->no_instrument_function) {
- attrib = "__attribute__((no_instrument_function)) ";
- } else {
- attrib = "";
- }
- fprintf(fd, "static inline %sint trace_%s(\n",attrib, basename);
-
- int has_argument = 0;
- int has_type_fixed = 0;
-
- for(unsigned int j = 0; j < event->fields.position; j++) {
- /* For each field, print the function argument */
- field_t *f = (field_t*)event->fields.array[j];
- type_descriptor_t *t = f->type;
- if(has_argument) {
- fprintf(fd, ",");
- fprintf(fd, "\n");
- }
- if(print_arg(t, fd, 2, basename, f->name)) return 1;
- has_argument = 1;
- }
- if(!has_argument) {
- print_tabs(2, fd);
- fprintf(fd, "void");
- }
- fprintf(fd,")\n");
- fprintf(fd,
- "#ifndef LTT_TRACE\n");
- fprintf(fd, "{\n");
- fprintf(fd, "}\n");
- fprintf(fd,"#else\n");
- fprintf(fd, "{\n");
- /* Print the function variables */
- print_tabs(1, fd);
- fprintf(fd, "unsigned int index;\n");
- print_tabs(1, fd);
- fprintf(fd, "struct ltt_trace_info *trace = thread_trace_info;\n");
- print_tabs(1, fd);
- fprintf(fd, "struct ltt_buf *ltt_buf;\n");
- print_tabs(1, fd);
- fprintf(fd, "void *buffer = NULL;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t *to_base = &real_to_base;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t real_to = 0;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t *to = &real_to;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t real_len = 0;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t *len = &real_len;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t reserve_size;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t slot_size;\n");
- print_tabs(1, fd);
-
- if(event->fields.position > 0) {
- for(unsigned int i=0;i<event->fields.position;i++){
- /* Search for at least one child with fixed size. It means
- * we need local variables.*/
- field_t *field = (field_t*)(event->fields.array[i]);
- type_descriptor_t *type = field->type;
- has_type_fixed = has_type_local(type);
- if(has_type_fixed) break;
- }
-
- if(has_type_fixed) {
- fprintf(fd, "size_t align;\n");
- print_tabs(1, fd);
- }
-
- fprintf(fd, "const void *real_from;\n");
- print_tabs(1, fd);
- fprintf(fd, "const void **from = &real_from;\n");
- print_tabs(1, fd);
- }
- fprintf(fd, "uint64_t tsc;\n");
- print_tabs(1, fd);
- fprintf(fd, "size_t before_hdr_pad, after_hdr_pad, header_size;\n");
- fprintf(fd, "\n");
-
- print_tabs(1, fd);
- fprintf(fd, "if(!trace) {\n");
- print_tabs(2, fd);
- fprintf(fd, "ltt_thread_init();\n");
- print_tabs(2, fd);
- fprintf(fd, "trace = thread_trace_info;\n");
- print_tabs(1, fd);
- fprintf(fd, "}\n\n");
- fprintf(fd, "\n");
-
- /* Calculate event variable len + event data alignment offset.
- * Assume that the padding for alignment starts at a void*
- * address.
- * This excludes the header size and alignment. */
-
- print_tabs(1, fd);
- fprintf(fd, "/* For each field, calculate the field size. */\n");
- print_tabs(1, fd);
- fprintf(fd, "/* size = *to_base + *to + *len */\n");
- print_tabs(1, fd);
- fprintf(fd, "/* Assume that the padding for alignment starts at a\n");
- print_tabs(1, fd);
- fprintf(fd, " * sizeof(void *) address. */\n");
- fprintf(fd, "\n");
-
- for(unsigned int i=0;i<event->fields.position;i++){
- field_t *field = (field_t*)(event->fields.array[i]);
- type_descriptor_t *type = field->type;
- /* Set from */
- print_tabs(1, fd);
- switch(type->type) {
- case SEQUENCE:
- case UNION:
- case ARRAY:
- case STRUCT:
- case STRING:
- fprintf(fd, "*from = lttng_param_%s;\n", field->name);
- break;
- default:
- fprintf(fd, "*from = <tng_param_%s;\n", field->name);
- break;
- }
-
- if(print_type_write(type,
- fd, 1, basename, field->name, "lttng_param_", 0)) return 1;
- fprintf(fd, "\n");
- }
- print_tabs(1, fd);
- fprintf(fd, "reserve_size = *to_base + *to + *len;\n");
-
- print_tabs(1, fd);
- fprintf(fd, "trace->nesting++;\n");
-
- /* Get facility index */
-
- print_tabs(1, fd);
- fprintf(fd,
- "index = ltt_get_index_from_facility(ltt_facility_%s_%X,\n"\
- "\t\t\t\t\t\tevent_%s_%s);\n",
- fac->name, fac->checksum, fac->name, event->name);
- fprintf(fd,"\n");
-
-
- print_tabs(1, fd);
- fprintf(fd, "{\n");
-
- if(event->per_trace) {
- print_tabs(2, fd);
- fprintf(fd, "if(dest_trace != trace) continue;\n\n");
- }
-
- print_tabs(2, fd);
- fprintf(fd, "ltt_buf = ltt_get_channel_from_index(trace, index);\n");
- print_tabs(2, fd);
-
-
- /* Relay reserve */
- /* If error, increment event lost counter (done by ltt_reserve_slot) and
- * return */
- print_tabs(2, fd);
- fprintf(fd, "slot_size = 0;\n");
- print_tabs(2, fd);
- fprintf(fd, "buffer = ltt_reserve_slot(trace, ltt_buf,\n");
- print_tabs(3, fd);
- fprintf(fd, "reserve_size, &slot_size, &tsc,\n");
- print_tabs(3, fd);
- fprintf(fd, "&before_hdr_pad, &after_hdr_pad, &header_size);\n");
- /* If error, return */
- print_tabs(2, fd);
- fprintf(fd, "if(!buffer) goto end; /* buffer full */\n\n");
- //print_tabs(2, fd);
- // for DEBUG only
- // fprintf(fd, "goto commit; /* DEBUG : never actually write. */\n\n");
- print_tabs(2, fd);
- fprintf(fd, "*to_base = *to = *len = 0;\n");
- fprintf(fd, "\n");
-
- /* Write event header */
- print_tabs(2, fd);
- fprintf(fd, "ltt_write_event_header(trace, ltt_buf, buffer,\n");
- print_tabs(3, fd);
- fprintf(fd, "ltt_facility_%s_%X, event_%s_%s,\n", fac->name, fac->checksum,
- fac->name, event->name);
- print_tabs(3, fd);
- fprintf(fd, "reserve_size, before_hdr_pad, tsc);\n");
- print_tabs(2, fd);
- fprintf(fd, "*to_base += before_hdr_pad + after_hdr_pad + header_size;\n");
- fprintf(fd, "\n");
-
- /* write data. */
-
- for(unsigned int i=0;i<event->fields.position;i++){
- field_t *field = (field_t*)(event->fields.array[i]);
- type_descriptor_t *type = field->type;
-
- /* Set from */
- print_tabs(2, fd);
- switch(type->type) {
- case SEQUENCE:
- case UNION:
- case ARRAY:
- case STRUCT:
- case STRING:
- fprintf(fd, "*from = lttng_param_%s;\n", field->name);
- break;
- default:
- fprintf(fd, "*from = <tng_param_%s;\n", field->name);
- break;
- }
-
-
- if(print_type_write(type,
- fd, 2, basename, field->name, "lttng_param_", 0)) return 1;
- fprintf(fd, "\n");
-
- /* Don't forget to flush pending memcpy */
- print_tabs(2, fd);
- fprintf(fd, "/* Flush pending memcpy */\n");
- print_tabs(2, fd);
- fprintf(fd, "if(*len != 0) {\n");
- print_tabs(3, fd);
- fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
- print_tabs(3, fd);
- fprintf(fd, "*to += *len;\n");
- //print_tabs(3, fd);
- //fprintf(fd, "from += len;\n");
- print_tabs(3, fd);
- fprintf(fd, "*len = 0;\n");
- print_tabs(2, fd);
- fprintf(fd, "}\n");
- fprintf(fd, "\n");
- }
-
-
- /* commit */
- // for DEBUG only.
- //fprintf(fd, "commit:\n"); /* DEBUG! */
- print_tabs(2, fd);
- fprintf(fd, "ltt_commit_slot(ltt_buf, buffer, slot_size);\n\n");
-
- fprintf(fd, "}\n\n");
-
- fprintf(fd, "end:\n");
- /* Release locks */
- print_tabs(1, fd);
- fprintf(fd, "trace->nesting--;\n");
-
-
- fprintf(fd, "}\n");
- fprintf(fd,
- "#endif //LTT_TRACE\n");
- fprintf(fd, "#endif //LTT_TRACE_FAST\n");
-
- return 0;
-}
-
-
-
-
-
-
-/* ltt-facility-name.h : main logging header.
- * log_header */
-
-void print_log_header_head(facility_t *fac, FILE *fd)
-{
- fprintf(fd, "#ifndef _LTT_FACILITY_%s_H_\n", fac->capname);
- fprintf(fd, "#define _LTT_FACILITY_%s_H_\n\n", fac->capname);
- fprintf(fd, "#include <linux/types.h>\n");
- if(!fac->arch)
- fprintf(fd, "#include <linux/ltt/ltt-facility-id-%s.h>\n", fac->name);
- else
- fprintf(fd, "#include <asm/ltt/ltt-facility-id-%s_%s.h>\n",
- fac->name,
- fac->arch);
- fprintf(fd, "#include <linux/ltt-core.h>\n");
- fprintf(fd, "\n");
-}
-
-/* ltt-facility-name.h : main logging header.
- * log_header */
-
-void print_log_header_head_user(facility_t *fac, FILE *fd)
-{
- fprintf(fd, "#ifndef _LTT_FACILITY_%s_H_\n", fac->capname);
- fprintf(fd, "#define _LTT_FACILITY_%s_H_\n\n", fac->capname);
- fprintf(fd, "#include <sys/types.h>\n");
- if(!fac->arch)
- fprintf(fd, "#include <ltt/ltt-facility-id-%s.h>\n", fac->name);
- else
- fprintf(fd, "#include <asm/ltt/ltt-facility-id-%s_%s.h>\n",
- fac->name,
- fac->arch);
- fprintf(fd, "#include <ltt/ltt-usertrace.h>\n");
- fprintf(fd, "\n");
-}
-
-
-int print_log_header_types(facility_t *fac, FILE *fd)
-{
- sequence_t *types = &fac->named_types.values;
- fprintf(fd, "/* Named types */\n");
- fprintf(fd, "\n");
-
- for(unsigned int i = 0; i < types->position; i++) {
- /* For each named type, print the definition */
- if(print_type_declaration(types->array[i], fd,
- 0, "", "")) return 1;
- /* Print also the align function */
- if(print_type_alignment_fct(types->array[i], fd,
- 0, "", "")) return 1;
- /* Print also the write function */
- if(print_type_write_fct(types->array[i], fd,
- 0, "", "")) return 1;
- }
- return 0;
-}
-
-int print_log_header_events(facility_t *fac, FILE *fd)
-{
- sequence_t *events = &fac->events;
- char basename[PATH_MAX];
- unsigned int facname_len;
-
- strncpy(basename, fac->name, PATH_MAX);
- facname_len = strlen(basename);
- strncat(basename, "_", PATH_MAX-facname_len);
- facname_len = strlen(basename);
-
- for(unsigned int i = 0; i < events->position; i++) {
- event_t *event = (event_t*)events->array[i];
- strncpy(&basename[facname_len], event->name, PATH_MAX-facname_len);
-
- /* For each event, print structure, and then logging function */
- fprintf(fd, "/* Event %s structures */\n",
- event->name);
- for(unsigned int j = 0; j < event->fields.position; j++) {
- /* For each unnamed type, print the definition */
- field_t *f = (field_t*)event->fields.array[j];
- type_descriptor_t *t = f->type;
- if(t->type_name == NULL) {
- if((print_type_declaration(t, fd, 0, basename, f->name))) return 1;
- /* Print also the align function */
- if((print_type_alignment_fct(t, fd, 0, basename, f->name))) return 1;
- /* Print also the write function */
- if((print_type_write_fct(t, fd, 0, basename, f->name))) return 1;
- }
- }
-
- fprintf(fd, "\n");
-
- fprintf(fd, "/* Event %s logging function */\n",
- event->name);
-
- if(!fac->user) {
- if(print_event_logging_function(basename, fac, event, fd)) return 1;
- } else {
- if(print_event_logging_function_user_generic(basename, fac, event, fd))
- return 1;
- if(print_event_logging_function_user_fast(basename, fac, event, fd))
- return 1;
- }
-
- fprintf(fd, "\n");
- }
-
- return 0;
-}
-
-
-void print_log_header_tail(facility_t *fac, FILE *fd)
-{
- fprintf(fd, "#endif //_LTT_FACILITY_%s_H_\n",fac->capname);
-}
-
-void print_log_header_tail_user(facility_t *fac, FILE *fd)
-{
- fprintf(fd, "#endif //_LTT_FACILITY_%s_H_\n",fac->capname);
-}
-
-int print_log_header(facility_t *fac)
-{
- char filename[PATH_MAX];
- unsigned int filename_size = 0;
- FILE *fd;
- dprintf("%s\n", fac->name);
-
- strcpy(filename, "ltt-facility-");
- filename_size = strlen(filename);
-
- strncat(filename, fac->name, PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- if(fac->arch) {
- strncat(filename, "_", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- strncat(filename, fac->arch, PATH_MAX - filename_size);
- filename_size = strlen(filename);
- }
-
- strncat(filename, ".h", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
-
- fd = fopen(filename, "w");
- if(fd == NULL) {
- printf("Error opening file %s for writing : %s\n",
- filename, strerror(errno));
- return errno;
- }
-
- /* Print file head */
- if(!fac->user)
- print_log_header_head(fac, fd);
- else
- print_log_header_head_user(fac, fd);
-
- /* print named types in declaration order */
- if(print_log_header_types(fac, fd)) return 1;
-
- /* Print events */
- if(print_log_header_events(fac, fd)) return 1;
-
- /* Print file tail */
- if(!fac->user)
- print_log_header_tail(fac, fd);
- else
- print_log_header_tail_user(fac, fd);
-
-
-
- fclose(fd);
-
- return 0;
-}
-
-
-/* ltt-facility-id-name.h : facility id.
- * log_id_header */
-int print_id_header(facility_t *fac)
-{
- char filename[PATH_MAX];
- unsigned int filename_size = 0;
- FILE *fd;
- char basename[PATH_MAX];
- char basename_len = 0;
-
- dprintf("%s\n", fac->name);
-
- strcpy(filename, "ltt-facility-id-");
- filename_size = strlen(filename);
-
- strncat(filename, fac->name, PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- if(fac->arch) {
- strncat(filename, "_", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- strncat(filename, fac->arch, PATH_MAX - filename_size);
- filename_size = strlen(filename);
- }
-
- strncat(filename, ".h", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
-
- fd = fopen(filename, "w");
- if(fd == NULL) {
- printf("Error opening file %s for writing : %s\n",
- filename, strerror(errno));
- return errno;
- }
-
- if(!fac->user) {
- fprintf(fd, "#ifndef _LTT_FACILITY_ID_%s_H_\n",fac->capname);
- fprintf(fd, "#define _LTT_FACILITY_ID_%s_H_\n\n",fac->capname);
- fprintf(fd, "#ifdef CONFIG_LTT\n");
-
- fprintf(fd,"#include <linux/ltt-facilities.h>\n\n");
-
- fprintf(fd,"/**** facility handle ****/\n\n");
- fprintf(fd,"extern ltt_facility_t ltt_facility_%s_%X;\n",
- fac->name, fac->checksum);
- fprintf(fd,"extern ltt_facility_t ltt_facility_%s;\n\n\n",fac->name);
-
- strncpy(basename, fac->name, PATH_MAX);
- basename_len = strlen(basename);
- strncat(basename, "_", PATH_MAX - basename_len);
- basename_len++;
-
- fprintf(fd,"/**** event index ****/\n\n");
- fprintf(fd,"enum %s_event {\n",fac->name);
-
- for(unsigned int i = 0; i < fac->events.position; i++) {
- event_t *event = (event_t*)fac->events.array[i];
- strncpy(basename+basename_len, event->name, PATH_MAX-basename_len);
- print_tabs(1, fd);
- fprintf(fd, "event_%s,\n", basename);
- }
- print_tabs(1, fd);
- fprintf(fd, "facility_%s_num_events\n", fac->name);
- fprintf(fd, "};\n");
- fprintf(fd, "\n");
-
-
- fprintf(fd, "#endif //CONFIG_LTT\n");
- fprintf(fd, "#endif //_LTT_FACILITY_ID_%s_H_\n",fac->capname);
- } else {
- fprintf(fd, "#ifndef _LTT_FACILITY_ID_%s_H_\n",fac->capname);
- fprintf(fd, "#define _LTT_FACILITY_ID_%s_H_\n\n",fac->capname);
- fprintf(fd, "#ifdef LTT_TRACE\n");
-
- fprintf(fd,"#include <ltt/ltt-usertrace.h>\n\n");
-
- fprintf(fd,"/**** facility handle ****/\n\n");
- fprintf(fd,"extern ltt_facility_t ltt_facility_%s_%X;\n",
- fac->name, fac->checksum);
- fprintf(fd,"extern ltt_facility_t ltt_facility_%s;\n\n\n",fac->name);
-
- strncpy(basename, fac->name, PATH_MAX);
- basename_len = strlen(basename);
- strncat(basename, "_", PATH_MAX - basename_len);
- basename_len++;
-
- fprintf(fd,"/**** event index ****/\n\n");
- fprintf(fd,"enum %s_event {\n",fac->name);
-
- for(unsigned int i = 0; i < fac->events.position; i++) {
- event_t *event = (event_t*)fac->events.array[i];
- strncpy(basename+basename_len, event->name, PATH_MAX-basename_len);
- print_tabs(1, fd);
- fprintf(fd, "event_%s,\n", basename);
- }
- print_tabs(1, fd);
- fprintf(fd, "facility_%s_num_events\n", fac->name);
- fprintf(fd, "};\n");
- fprintf(fd, "\n");
-
-
- fprintf(fd, "#endif //LTT_TRACE\n");
- fprintf(fd, "#endif //_LTT_FACILITY_ID_%s_H_\n",fac->capname);
- }
-
-
- fclose(fd);
-
- return 0;
-}
-
-
-/* ltt-facility-loader-name.h : facility specific loader info.
- * loader_header */
-int print_loader_header(facility_t *fac)
-{
- char filename[PATH_MAX];
- unsigned int filename_size = 0;
- FILE *fd;
- dprintf("%s\n", fac->name);
-
- strcpy(filename, "ltt-facility-loader-");
- filename_size = strlen(filename);
-
- strncat(filename, fac->name, PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- if(fac->arch) {
- strncat(filename, "_", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- strncat(filename, fac->arch, PATH_MAX - filename_size);
- filename_size = strlen(filename);
- }
-
- strncat(filename, ".h", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
-
- fd = fopen(filename, "w");
- if(fd == NULL) {
- printf("Error opening file %s for writing : %s\n",
- filename, strerror(errno));
- return errno;
- }
-
- fprintf(fd, "#ifndef _LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
- fprintf(fd, "#define _LTT_FACILITY_LOADER_%s_H_\n\n", fac->capname);
- fprintf(fd, "#ifdef CONFIG_LTT\n\n");
- fprintf(fd,"#include <linux/ltt-facilities.h>\n");
- if(!fac->arch)
- fprintf(fd,"#include <linux/ltt/ltt-facility-id-%s.h>\n\n",
- fac->name);
- else
- fprintf(fd,"#include <asm/ltt/ltt-facility-id-%s_%s.h>\n\n",
- fac->name,
- fac->arch);
- fprintf(fd,"ltt_facility_t\tltt_facility_%s;\n", fac->name);
- fprintf(fd,"ltt_facility_t\tltt_facility_%s_%X;\n\n",
- fac->name, fac->checksum);
-
- fprintf(fd,"#define LTT_FACILITY_SYMBOL\t\t\t\t\t\t\tltt_facility_%s\n",
- fac->name);
- fprintf(fd,"#define LTT_FACILITY_CHECKSUM_SYMBOL\t\tltt_facility_%s_%X\n",
- fac->name, fac->checksum);
- fprintf(fd,"#define LTT_FACILITY_CHECKSUM\t\t\t\t\t\t0x%X\n", fac->checksum);
- fprintf(fd,"#define LTT_FACILITY_NAME\t\t\t\t\t\t\t\t\"%s\"\n", fac->name);
- fprintf(fd,"#define LTT_FACILITY_NUM_EVENTS\t\t\t\t\tfacility_%s_num_events\n\n",
- fac->name);
- fprintf(fd, "#endif //CONFIG_LTT\n\n");
- fprintf(fd, "#endif //_LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
-
- fclose(fd);
-
- return 0;
-}
-
-int print_loader_header_user(facility_t *fac)
-{
- char filename[PATH_MAX];
- unsigned int filename_size = 0;
- FILE *fd;
- dprintf("%s\n", fac->name);
-
- strcpy(filename, "ltt-facility-loader-");
- filename_size = strlen(filename);
-
- strncat(filename, fac->name, PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- if(fac->arch) {
- strncat(filename, "_", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- strncat(filename, fac->arch, PATH_MAX - filename_size);
- filename_size = strlen(filename);
- }
-
- strncat(filename, ".h", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
-
- fd = fopen(filename, "w");
- if(fd == NULL) {
- printf("Error opening file %s for writing : %s\n",
- filename, strerror(errno));
- return errno;
- }
-
- fprintf(fd, "#ifndef _LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
- fprintf(fd, "#define _LTT_FACILITY_LOADER_%s_H_\n\n", fac->capname);
- fprintf(fd,"#include <ltt/ltt-usertrace.h>\n");
- if(!fac->arch)
- fprintf(fd,"#include <ltt/ltt-facility-id-%s.h>\n\n",
- fac->name);
- else
- fprintf(fd,"#include <asm/ltt/ltt-facility-id-%s_%s.h>\n\n",
- fac->name,
- fac->arch);
- fprintf(fd,"ltt_facility_t\tltt_facility_%s;\n", fac->name);
- fprintf(fd,"ltt_facility_t\tltt_facility_%s_%X;\n\n",
- fac->name, fac->checksum);
-
- fprintf(fd,"#define LTT_FACILITY_SYMBOL\t\t\t\t\t\t\tltt_facility_%s\n",
- fac->name);
- fprintf(fd,"#define LTT_FACILITY_CHECKSUM_SYMBOL\t\tltt_facility_%s_%X\n",
- fac->name, fac->checksum);
- fprintf(fd,"#define LTT_FACILITY_CHECKSUM\t\t\t\t\t\t0x%X\n", fac->checksum);
- fprintf(fd,"#define LTT_FACILITY_NAME\t\t\t\t\t\t\t\t\"%s\"\n", fac->name);
- fprintf(fd,"#define LTT_FACILITY_NUM_EVENTS\t\t\t\t\tfacility_%s_num_events\n\n",
- fac->name);
- fprintf(fd, "#endif //_LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
-
- fclose(fd);
-
- return 0;
-}
-
-
-
-/* ltt-facility-loader-name.c : generic facility loader
- * loader_c */
-int print_loader_c(facility_t *fac)
-{
- char filename[PATH_MAX];
- unsigned int filename_size = 0;
- FILE *fd;
- dprintf("%s\n", fac->name);
-
- strcpy(filename, "ltt-facility-loader-");
- filename_size = strlen(filename);
-
- strncat(filename, fac->name, PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- if(fac->arch) {
- strncat(filename, "_", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- strncat(filename, fac->arch, PATH_MAX - filename_size);
- filename_size = strlen(filename);
- }
-
- strncat(filename, ".c", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
-
- fd = fopen(filename, "w");
- if(fd == NULL) {
- printf("Error opening file %s for writing : %s\n",
- filename, strerror(errno));
- return errno;
- }
-
- fprintf(fd, "/*\n");
- if(!fac->arch)
- fprintf(fd, " * ltt-facility-loader-%s.c\n", fac->name);
- else
- fprintf(fd, " * ltt-facility-loader-%s_%s.c\n", fac->name, fac->arch);
- fprintf(fd, " *\n");
- fprintf(fd, " * (C) Copyright 2005 - \n");
- fprintf(fd, " * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)\n");
- fprintf(fd, " *\n");
- fprintf(fd, " * Contains the LTT facility loader.\n");
- fprintf(fd, " *\n");
- fprintf(fd, " */\n");
- fprintf(fd, "\n");
- fprintf(fd, "\n");
- fprintf(fd, "#include <linux/ltt-facilities.h>\n");
- fprintf(fd, "#include <linux/module.h>\n");
- fprintf(fd, "#include <linux/init.h>\n");
- fprintf(fd, "#include <linux/config.h>\n");
- if(!fac->arch)
- fprintf(fd, "#include \"ltt-facility-loader-%s.h\"\n", fac->name);
- else
- fprintf(fd, "#include \"ltt-facility-loader-%s_%s.h\"\n",
- fac->name, fac->arch);
- fprintf(fd, "\n");
- fprintf(fd, "\n");
- fprintf(fd, "#ifdef CONFIG_LTT\n");
- fprintf(fd, "\n");
- fprintf(fd, "EXPORT_SYMBOL(LTT_FACILITY_SYMBOL);\n");
- fprintf(fd, "EXPORT_SYMBOL(LTT_FACILITY_CHECKSUM_SYMBOL);\n");
- fprintf(fd, "\n");
- fprintf(fd, "static const char ltt_facility_name[] = LTT_FACILITY_NAME;\n");
- fprintf(fd, "\n");
- fprintf(fd, "#define SYMBOL_STRING(sym) #sym\n");
- fprintf(fd, "\n");
- fprintf(fd, "static struct ltt_facility facility = {\n");
- fprintf(fd, "\t.name = ltt_facility_name,\n");
- fprintf(fd, "\t.num_events = LTT_FACILITY_NUM_EVENTS,\n");
- fprintf(fd, "\t.checksum = LTT_FACILITY_CHECKSUM,\n");
- fprintf(fd, "\t.symbol = SYMBOL_STRING(LTT_FACILITY_SYMBOL),\n");
- fprintf(fd, "};\n");
- fprintf(fd, "\n");
- fprintf(fd, "static int __init facility_init(void)\n");
- fprintf(fd, "{\n");
- fprintf(fd, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init in kernel\\n\");\n", fac->name);
- fprintf(fd, "\n");
- fprintf(fd, "\tLTT_FACILITY_SYMBOL = ltt_facility_kernel_register(&facility);\n");
- fprintf(fd, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
- fprintf(fd, "\t\n");
- fprintf(fd, "\treturn LTT_FACILITY_SYMBOL;\n");
- fprintf(fd, "}\n");
- fprintf(fd, "\n");
- fprintf(fd, "#ifndef MODULE\n");
- fprintf(fd, "__initcall(facility_init);\n");
- fprintf(fd, "#else\n");
- fprintf(fd, "module_init(facility_init);\n");
- fprintf(fd, "static void __exit facility_exit(void)\n");
- fprintf(fd, "{\n");
- fprintf(fd, "\tint err;\n");
- fprintf(fd, "\n");
- fprintf(fd, "\terr = ltt_facility_unregister(LTT_FACILITY_SYMBOL);\n");
- fprintf(fd, "\tif(err != 0)\n");
- fprintf(fd, "\t\tprintk(KERN_ERR \"LTT : Error in unregistering facility.\\n\");\n");
- fprintf(fd, "\n");
- fprintf(fd, "}\n");
- fprintf(fd, "module_exit(facility_exit)\n");
- fprintf(fd, "\n");
- fprintf(fd, "MODULE_LICENSE(\"GPL\");\n");
- fprintf(fd, "MODULE_AUTHOR(\"Mathieu Desnoyers\");\n");
- fprintf(fd, "MODULE_DESCRIPTION(\"Linux Trace Toolkit Facility\");\n");
- fprintf(fd, "\n");
- fprintf(fd, "#endif //MODULE\n");
- fprintf(fd, "\n");
- fprintf(fd, "#endif //CONFIG_LTT\n");
-
- fclose(fd);
-
- return 0;
-}
-
-int print_loader_c_user(facility_t *fac)
-{
- char filename[PATH_MAX];
- unsigned int filename_size = 0;
- FILE *fd;
- dprintf("%s\n", fac->name);
-
- strcpy(filename, "ltt-facility-loader-");
- filename_size = strlen(filename);
-
- strncat(filename, fac->name, PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- if(fac->arch) {
- strncat(filename, "_", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
- strncat(filename, fac->arch, PATH_MAX - filename_size);
- filename_size = strlen(filename);
- }
-
- strncat(filename, ".c", PATH_MAX - filename_size);
- filename_size = strlen(filename);
-
-
- fd = fopen(filename, "w");
- if(fd == NULL) {
- printf("Error opening file %s for writing : %s\n",
- filename, strerror(errno));
- return errno;
- }
-
- fprintf(fd, "/*\n");
- if(!fac->arch)
- fprintf(fd, " * ltt-facility-loader-%s.c\n", fac->name);
- else
- fprintf(fd, " * ltt-facility-loader-%s_%s.c\n", fac->name, fac->arch);
- fprintf(fd, " *\n");
- fprintf(fd, " * (C) Copyright 2005 - \n");
- fprintf(fd, " * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)\n");
- fprintf(fd, " *\n");
- fprintf(fd, " * Contains the LTT user space facility loader.\n");
- fprintf(fd, " *\n");
- fprintf(fd, " */\n");
- fprintf(fd, "\n");
- fprintf(fd, "\n");
- fprintf(fd, "#define LTT_TRACE\n");
- fprintf(fd, "#include <error.h>\n");
- fprintf(fd, "#include <stdio.h>\n");
- fprintf(fd, "#include <ltt/ltt-usertrace.h>\n");
- if(!fac->arch)
- fprintf(fd, "#include \"ltt-facility-loader-%s.h\"\n", fac->name);
- else
- fprintf(fd, "#include \"ltt-facility-loader-%s_%s.h\"\n",
- fac->name, fac->arch);
- fprintf(fd, "\n");
- fprintf(fd, "static struct user_facility_info facility = {\n");
- fprintf(fd, "\t.name = LTT_FACILITY_NAME,\n");
- fprintf(fd, "\t.num_events = LTT_FACILITY_NUM_EVENTS,\n");
- fprintf(fd, "#ifndef LTT_PACK\n");
- fprintf(fd, "\t.alignment = sizeof(void*),\n");
- fprintf(fd, "#else\n");
- fprintf(fd, "\t.alignment = 0,\n");
- fprintf(fd, "#endif //LTT_PACK\n");
- fprintf(fd, "\t.checksum = LTT_FACILITY_CHECKSUM,\n");
- fprintf(fd, "\t.int_size = sizeof(int),\n");
- fprintf(fd, "\t.long_size = sizeof(long),\n");
- fprintf(fd, "\t.pointer_size = sizeof(void*),\n");
- fprintf(fd, "\t.size_t_size = sizeof(size_t)\n");
- fprintf(fd, "};\n");
- fprintf(fd, "\n");
- fprintf(fd, "static void __attribute__((constructor)) __ltt_user_init(void)\n");
- fprintf(fd, "{\n");
- fprintf(fd, "\tint err;\n");
- fprintf(fd, "#ifdef LTT_SHOW_DEBUG\n");
- fprintf(fd, "\tprintf(\"LTT : ltt-facility-%s init in userspace\\n\");\n", fac->name);
- fprintf(fd, "#endif //LTT_SHOW_DEBUG\n");
- fprintf(fd, "\n");
- fprintf(fd, "\terr = ltt_register_generic(<T_FACILITY_SYMBOL, &facility);\n");
- fprintf(fd, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
- fprintf(fd, "\t\n");
- fprintf(fd, "\tif(err) {\n");
- fprintf(fd, "#ifdef LTT_SHOW_DEBUG\n");
- fprintf(fd, "\t\tperror(\"Error in ltt_register_generic\");\n");
- fprintf(fd, "#endif //LTT_SHOW_DEBUG\n");
- fprintf(fd, "\t}\n");
- fprintf(fd, "}\n");
- fprintf(fd, "\n");
-
- fclose(fd);
-
- return 0;
-}
-
-
-
-/* open facility */
-/* code taken from ltt_facility_open in ltt/facility.c in lttv */
-
-/*****************************************************************************
- *Function name
- * ltt_facility_open : open facilities
- *Input params
- * pathname : the path name of the facility
- *
- * Open the facility corresponding to the right checksum.
- *
- *returns the facility on success, NULL on error.
- ****************************************************************************/
-facility_t *ltt_facility_open(char * pathname)
-{
- int ret = 0;
- char *token;
- parse_file_t in;
- facility_t * fac = NULL;
- char buffer[BUFFER_SIZE];
- int generated = FALSE;
-
- in.buffer = &(buffer[0]);
- in.lineno = 0;
- in.error = error_callback;
- in.name = pathname;
- in.unget = 0;
-
- in.fp = fopen(in.name, "r");
- if(in.fp == NULL) {
- ret = 1;
- goto open_error;
- }
-
- while(1){
- token = getToken(&in);
- if(in.type == ENDFILE) break;
-
- if(generated) {
- printf("More than one facility in the file. Only using the first one.\n");
- break;
- }
-
- if(strcmp(token, "<")) in.error(&in,"not a facility file");
- token = getName(&in);
- if(strcmp(token, "?")) in.error(&in,"not a facility file");
- token = getName(&in);
- if(strcmp(token, "xml")) in.error(&in,"not a facility file");
- token = getName(&in);
- if(strcmp(token, "version")) in.error(&in,"not a facility file");
- token = getName(&in);
- if(strcmp(token, "=")) in.error(&in,"not a facility file");
- token = getQuotedString(&in);
- if(strcmp(token, "1.0")) in.error(&in,"not a facility file");
- token = getName(&in);
- if(strcmp(token, "?")) in.error(&in,"not a facility file");
- token = getToken(&in);
- if(strcmp(token, ">")) in.error(&in,"not a facility file");
-
- token = getName(&in);
- if(strcmp(token, "<")) in.error(&in,"not a facility file");
- token = getName(&in);
- if(strcmp("facility",token) == 0) {
- fac = malloc(sizeof(facility_t));
- fac->name = NULL;
- fac->description = NULL;
- sequence_init(&(fac->events));
- table_init(&(fac->named_types));
- sequence_init(&(fac->unnamed_types));
-
- parseFacility(&in, fac);
-
- //check if any namedType is not defined
- checkNamedTypesImplemented(&fac->named_types);
-
- generateChecksum(fac->name, &fac->checksum, &fac->events);
-
- generated = TRUE;
- }
- else {
- printf("facility token was expected in file %s\n", in.name);
- ret = 1;
- goto parse_error;
- }
- }
-
- parse_error:
- fclose(in.fp);
-open_error:
-
- if(!generated) {
- printf("Cannot find facility %s\n", pathname);
- fac = NULL;
- }
-
- return fac;
-}
-
-/* Close the facility */
-void ltt_facility_close(facility_t *fac)
-{
- free(fac->name);
- free(fac->capname);
- free(fac->description);
- freeEvents(&fac->events);
- sequence_dispose(&fac->events);
- freeNamedType(&fac->named_types);
- table_dispose(&fac->named_types);
- freeTypes(&fac->unnamed_types);
- sequence_dispose(&fac->unnamed_types);
- free(fac);
-}
-
-
-/* Show help */
-void show_help(int argc, char ** argv)
-{
- printf("Genevent help : \n");
- printf("\n");
- printf("Use %s name.xml\n", argv[0]);
- printf("to create :\n");
- printf("ltt-facility-name.h\n");
- printf("ltt-facility-id-name.h\n");
- printf("ltt-facility-loader-name.h\n");
- printf("ltt-facility-loader-name.c\n");
- printf("In the current directory.\n");
- printf("\n");
-}
-
-/* Parse program arguments */
-/* Return values :
- * 0 : continue program
- * -1 : stop program, return 0
- * > 0 : stop program, return value as exit.
- */
-int check_args(int argc, char **argv)
-{
- if(argc < 2) {
- printf("Not enough arguments\n");
- show_help(argc, argv);
- return EINVAL;
- }
-
- if(strcmp(argv[1], "-h") == 0) {
- show_help(argc, argv);
- return -1;
- }
-
- return 0;
-}
-
-int main(int argc, char **argv)
-{
- int err = 0;
- facility_t *fac;
-
- err = check_args(argc, argv);
- if(err > 0) return err;
- else if(err < 0) return 0;
-
- /* open the facility */
- fac = ltt_facility_open(argv[1]);
- if(fac == NULL) {
- printf("Error opening file %s for reading : %s\n",
- argv[1], strerror(errno));
- return errno;
- }
-
- /* generate the output C files */
-
-
- /* ltt-facility-name.h : main logging header.
- * log_header */
- err = print_log_header(fac);
- if(err) return err;
-
- /* ltt-facility-id-name.h : facility id.
- * log_id_header */
- err = print_id_header(fac);
- if(err) return err;
-
- /* ltt-facility-loader-name.h : facility specific loader info.
- * loader_header */
- if(!fac->user)
- err = print_loader_header(fac);
- else
- err = print_loader_header_user(fac);
- if(err) return err;
-
- /* ltt-facility-loader-name.c : generic faciilty loader
- * loader_c */
- if(!fac->user)
- err = print_loader_c(fac);
- else
- err = print_loader_c_user(fac);
- if(err) return err;
-
- /* close the facility */
- ltt_facility_close(fac);
-
- return 0;
-}
-
-
+++ /dev/null
-/******************************************************************************
- * Genevent
- *
- * Event generator. XML to logging C code converter.
- *
- * Supports :
- * - C Alignment
- * - C types : struct, union, enum, basic types.
- * - Architectures : LP32, ILP32, ILP64, LLP64, LP64.
- *
- * Additionnal structures supported :
- * - embedded variable size strings
- * - embedded variable size arrays
- * - embedded variable size sequences
- *
- * Notes :
- * (1)
- * enums are limited to integer type, as this is what is used in C. Note,
- * however, that ISO/IEC 9899:TC2 specify that the type of enum can be char,
- * unsigned int or int. This is implementation defined (compiler). That's why we
- * add a check for sizeof enum.
- *
- * (2)
- * Because of archtecture defined type sizes, we need to ask for ltt_align
- * (which gives the alignment) by passing basic types, not their actual sizes.
- * It's up to ltt_align to determine sizes of types.
- *
- * Note that, from
- * http://www.usenix.org/publications/login/standards/10.data.html
- * (Andrew Josey <a.josey@opengroup.org>) :
- *
- * Data Type LP32 ILP32 ILP64 LLP64 LP64
- * char 8 8 8 8 8
- * short 16 16 16 16 16
- * int32 32
- * int 16 32 64 32 32
- * long 32 32 64 32 64
- * long long (int64) 64
- * pointer 32 32 64 64 64
- *
- * With these constraints :
- * sizeof(char) <= sizeof(short) <= sizeof(int)
- * <= sizeof(long) = sizeof(size_t)
- *
- * and therefore sizeof(long) <= sizeof(pointer) <= sizeof(size_t)
- *
- * Which means we only have to remember which is the biggest type in a structure
- * to know the structure's alignment.
- */
-
-
-
-/* Code printing */
-
-/* Type size checking */
-int print_check(int fd);
-
-
-/* Print types */
-int print_types(int fd);
-
-/* Print events */
-int print_events(int fd);
-
-
-
+++ /dev/null
-
-#define __KERNEL__
-
-#include <assert.h>
-#include <sys/types.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <linux/compiler.h>
-
-#define min(a,b) (((a)<(b))?a:b)
-#define max(a,b) (((a)>(b))?a:b)
-#define BUG_ON(a) assert(!(a))
-
-// Useful outside __KERNEL__. Not used here because inline is already redefined.
-#define force_inline inline __attribute__((always_inline))
-
-/* Calculate the offset needed to align the type */
-static inline unsigned int ltt_align(size_t align_drift,
- size_t size_of_type)
-{
- size_t alignment = min(sizeof(void*), size_of_type);
-
- return ((alignment - align_drift) & (alignment-1));
-}
-
-
-/* TEMPLATE */
-
-enum lttng_tasklet_priority {
- LTTNG_LOW,
- LTTNG_HIGH,
-};
-
-enum lttng_irq_mode {
- LTTNG_user,
- LTTNG_kernel,
-};
-
-struct lttng_mystruct2 {
- unsigned int irq_id;
- enum lttng_irq_mode mode;
- //struct lttng_mystruct teststr1;
-};
-
-#if 0
-static inline size_t lttng_get_size_mystruct2(
- struct lttng_mystruct2 * obj)
-{
- size_t size=0, locsize;
-
- locsize = sizeof(unsigned int);
- size += ltt_align(size, locsize) + locsize;
-
- locsize = sizeof(enum lttng_irq_mode);
- size += ltt_align(size, locsize) + locsize;
-
- BUG_ON(sizeof(struct lttng_mystruct2) != size);
-
- return sizeof(struct lttng_mystruct2);
-}
-#endif //0
-
-static inline size_t lttng_get_alignment_mystruct2(
- struct lttng_mystruct2 *obj)
-{
- size_t align=0, localign;
-
- localign = sizeof(unsigned int);
- align = max(align, localign);
-
- localign = sizeof(enum lttng_irq_mode);
- align = max(align, localign);
-
- return align;
-}
-
-static inline void lttng_write_mystruct2(
- void *buffer,
- size_t *to_base,
- size_t *to,
- void **from,
- size_t *len,
- struct lttng_mystruct2 *obj)
-{
- size_t align, size;
-
- align = lttng_get_alignment_mystruct2(obj);
- //size = lttng_get_size_mystruct2(obj);
- size = sizeof(struct lttng_mystruct2);
-
- if(*len == 0) {
- *to += ltt_align(*to, align); /* align output */
- } else {
- *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
- }
-
- *len += size;
-}
-
-
-
-#define LTTNG_ARRAY_SIZE_mystruct_myarray 10
-typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];
-
-#if 0
-static inline size_t lttng_get_size_array_mystruct_myarray(
- lttng_array_mystruct_myarray obj)
-{
- size_t size=0, locsize;
-
- locsize = sizeof(uint64_t);
- /* ltt_align == 0 always*/
- //size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
- BUG_ON(ltt_align(size, locsize) != 0);
- size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;
-
- BUG_ON(sizeof(lttng_array_mystruct_myarray) != size);
-
- return sizeof(lttng_array_mystruct_myarray);
-}
-#endif //0
-
-static inline size_t lttng_get_alignment_array_mystruct_myarray(
- lttng_array_mystruct_myarray obj)
-{
- size_t align=0, localign;
-
- localign = sizeof(uint64_t);
- align = max(align, localign);
-
- return align;
-}
-
-
-static inline void lttng_write_array_mystruct_myarray(
- void *buffer,
- size_t *to_base,
- size_t *to,
- void **from,
- size_t *len,
- lttng_array_mystruct_myarray obj)
-{
- size_t align, size;
-
- align = lttng_get_alignment_array_mystruct_myarray(obj);
- //size = lttng_get_size_array_mystruct_myarray(obj);
- size = sizeof(lttng_array_mystruct_myarray);
-
- if(*len == 0) {
- *to += ltt_align(*to, align); /* align output */
- } else {
- *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
- }
-
- *len += size;
-#if 0
- /* For varlen child : let the child align itself. */
- for(unsigned int i=0; i<LTTNG_ARRAY_SIZE_mystruct_myarray; i++) {
- lttng_write_child(buffer, to_base, to, from, len, obj[i]);
- }
-#endif //0
-
-}
-
-
-typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence;
-struct lttng_sequence_mystruct_mysequence {
- unsigned int len;
- double *array;
-};
-
-#if 0
-static inline size_t lttng_get_size_sequence_mystruct_mysequence(
- lttng_sequence_mystruct_mysequence *obj)
-{
- size_t size=0, locsize;
-
- locsize = sizeof(unsigned int);
- size += ltt_align(size, locsize) + locsize;
-
- locsize = sizeof(double);
- size += ltt_align(size, locsize) + (obj->len * locsize);
-
- /* Realign on arch size */
- locsize = sizeof(void *);
- size += ltt_align(size, locsize);
-
- return size;
-}
-#endif //0
-
-static inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
- lttng_sequence_mystruct_mysequence *obj)
-{
- size_t align=0, localign;
-
- localign = sizeof(unsigned int);
- align = max(align, localign);
-
- localign = sizeof(double);
- align = max(align, localign);
-
- return align;
-}
-
-
-static inline void lttng_write_sequence_mystruct_mysequence(
- void *buffer,
- size_t *to_base,
- size_t *to,
- void **from,
- size_t *len,
- lttng_sequence_mystruct_mysequence *obj)
-{
- size_t align;
- size_t size;
-
- /* Flush pending memcpy */
- if(*len != 0) {
- if(buffer != NULL)
- memcpy(buffer+*to_base+*to, *from, *len);
- }
- *to += *len;
- *len = 0;
-
- align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
- //no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
-
- /* Align output */
- *to += ltt_align(*to, align); /* *len = 0 in this function */
-
- /* Copy members */
- size = sizeof(unsigned int);
- *to += ltt_align(*to, size);
- if(buffer != NULL)
- memcpy(buffer+*to_base+*to, &obj->len, size);
- *to += size;
-
- size = sizeof(double);
- *to += ltt_align(*to, size);
- size = obj->len * sizeof(double);
- if(buffer != NULL)
- memcpy(buffer+*to_base+*to, obj->array, size);
- *to += size;
-#if 0
- /* If varlen child : let child align itself */
- for(unsigned int i=0; i<obj->len; i++) {
- lttng_write_child(buffer, to_base, to, from, len, obj->array[i]);
- }
-#endif //0
-
-
- /* Realign the *to_base on arch size, set *to to 0 */
- *to = ltt_align(*to, sizeof(void *));
- *to_base = *to_base+*to;
- *to = 0;
-
- /* Put source *from just after the C sequence */
- *from = obj+1;
-}
-
-
-
-union lttng_mystruct_myunion {
- double myfloat;
- unsigned long myulong;
-};
-
-#if 0
-static inline size_t lttng_get_size_mystruct_myunion(
- union lttng_mystruct_myunion *obj)
-{
- size_t size=0, locsize;
-
- locsize = sizeof(double);
- size = max(size, locsize);
-
- locsize = sizeof(unsigned long);
- size = max(size, locsize);
-
- BUG_ON(size != sizeof(union lttng_mystruct_myunion));
-
- return sizeof(union lttng_mystruct_myunion);
-}
-#endif //0
-
-static inline size_t lttng_get_alignment_mystruct_myunion(
- union lttng_mystruct_myunion *obj)
-{
- size_t align=0, localign;
-
- localign = sizeof(double);
- align = max(align, localign);
-
- localign = sizeof(unsigned long);
- align = max(align, localign);
-
- return align;
-}
-
-
-static inline void lttng_write_mystruct_myunion(
- void *buffer,
- size_t *to_base,
- size_t *to,
- void **from,
- size_t *len,
- union lttng_mystruct_myunion *obj)
-{
- size_t align, size;
-
- align = lttng_get_alignment_mystruct_myunion(obj);
- //size = lttng_get_size_mystruct_myunion(obj);
- size = sizeof(union lttng_mystruct_myunion);
-
- if(*len == 0) {
- *to += ltt_align(*to, align); /* align output */
- } else {
- *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
- }
-
- *len += size;
-
- /* Assert : no varlen child. */
-}
-
-
-struct lttng_mystruct {
- unsigned int irq_id;
- enum lttng_irq_mode mode;
- struct lttng_mystruct2 teststr;
- lttng_array_mystruct_myarray myarray;
- lttng_sequence_mystruct_mysequence mysequence;
- union lttng_mystruct_myunion myunion;
-};
-
-#if 0
-static inline size_t lttng_get_size_mystruct(
- struct lttng_mystruct *obj)
-{
- size_t size=0, locsize, localign;
-
- locsize = sizeof(unsigned int);
- size += ltt_align(size, locsize) + locsize;
-
- locsize = sizeof(enum lttng_irq_mode);
- size += ltt_align(size, locsize) + locsize;
-
- localign = lttng_get_alignment_mystruct2(&obj->teststr);
- locsize = lttng_get_size_mystruct2(&obj->teststr);
- size += ltt_align(size, localign) + locsize;
-
- localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
- locsize = lttng_get_size_array_mystruct_myarray(obj->myarray);
- size += ltt_align(size, localign) + locsize;
-
- localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
- locsize = lttng_get_size_sequence_mystruct_mysequence(&obj->mysequence);
- size += ltt_align(size, localign) + locsize;
-
- localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
- locsize = lttng_get_size_mystruct_myunion(&obj->myunion);
- size += ltt_align(size, localign) + locsize;
-
- return size;
-}
-#endif //0
-
-static inline size_t lttng_get_alignment_mystruct(
- struct lttng_mystruct *obj)
-{
- size_t align=0, localign;
-
- localign = sizeof(unsigned int);
- align = max(align, localign);
-
- localign = sizeof(enum lttng_irq_mode);
- align = max(align, localign);
-
- localign = lttng_get_alignment_mystruct2(&obj->teststr);
- align = max(align, localign);
-
- localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
- align = max(align, localign);
-
- localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
- align = max(align, localign);
-
- localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
- align = max(align, localign);
-
- return align;
-}
-
-static inline void lttng_write_mystruct(
- void *buffer,
- size_t *to_base,
- size_t *to,
- void **from,
- size_t *len,
- struct lttng_mystruct *obj)
-{
- size_t align, size;
-
- align = lttng_get_alignment_mystruct(obj);
- // no need : contains variable size fields.
- // locsize = lttng_get_size_mystruct(obj);
-
- if(*len == 0) {
- *to += ltt_align(*to, align); /* align output */
- } else {
- *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
- }
-
- /* Contains variable sized fields : must explode the structure */
-
- size = sizeof(unsigned int);
- size += ltt_align(*to+*len, size) + size;
- *len += size;
-
- size = sizeof(enum lttng_irq_mode);
- size += ltt_align(*to+*len, size) + size;
- *len += size;
-
- lttng_write_mystruct2(buffer, to_base, to, from, len, &obj->teststr);
-
- lttng_write_array_mystruct_myarray(buffer, to_base, to, from, len, obj->myarray);
-
- /* Variable length field */
- lttng_write_sequence_mystruct_mysequence(buffer, to_base, to, from, len, &obj->mysequence);
- /* After this previous write, we are sure that *to is 0, *len is 0 and
- * *to_base is aligned on the architecture size : to rest of alignment will
- * be calculated statically. */
-
- lttng_write_mystruct_myunion(buffer, to_base, to, from, len, &obj->myunion);
-
- /* Don't forget to flush last write..... */
-}
-
-
-
-
-
-
-//void main()
-void test()
-{
- struct lttng_mystruct test;
- test.mysequence.len = 20;
- test.mysequence.array = malloc(20);
-
- //size_t size = lttng_get_size_mystruct(&test);
- //size_t align = lttng_get_alignment_mystruct(&test);
- //
- size_t to_base = 0; /* the buffer is allocated on arch_size alignment */
- size_t to = 0;
- void *from = &test;
- size_t len = 0;
-
- /* Get size */
- lttng_write_mystruct(NULL, &to_base, &to, &from, &len, &test);
- /* Size = to_base + to + len */
-
- void *buffer = malloc(to_base + to + len);
- to_base = 0; /* the buffer is allocated on arch_size alignment */
- to = 0;
- from = &test;
- len = 0;
-
- lttng_write_mystruct(buffer, &to_base, &to, &from, &len, &test);
- /* Final flush */
- /* Flush pending memcpy */
- if(len != 0) {
- // Assert buffer != NULL */
- memcpy(buffer+to_base+to, from, len);
- to += len;
- from += len;
- len = 0;
- }
-
- free(test.mysequence.array);
- free(buffer);
-}
+++ /dev/null
-#ifndef _LTT_FACILITY_TEST_H_
-#define _LTT_FACILITY_TEST_H_
-
-
-/* Facility activation at compile time. */
-#ifdef CONFIG_LTT_FACILITY_TEST
-
-/* Named types */
-
-
-enum lttng_tasklet_priority {
- LTTNG_LOW,
- LTTNG_HIGH,
-};
-
-enum lttng_irq_mode {
- LTTNG_user,
- LTTNG_kernel,
-};
-
-struct lttng_mystruct2 {
- unsigned int irq_id;
- enum lttng_irq_mode mode;
- //struct lttng_mystruct teststr1;
-};
-
-
-size_t lttng_get_size_mystruct2(
- struct lttng_mystruct2 *obj)
-{
- size_t size=0, locsize;
-
- locsize = sizeof(unsigned int);
- size += ltt_align(size, locsize) + locsize;
-
- locsize = sizeof(enum lttng_irq_mode);
- size += ltt_align(size, locsize) + locsize;
-
- BUG_ON(sizeof(struct lttng_mystruct2) != size);
-
- return sizeof(struct lttng_mystruct2);
-}
-
-size_t lttng_get_alignment_mystruct2(
- struct lttng_mystruct2 *obj)
-{
- size_t align=0, localign;
-
- localign = sizeof(unsigned int);
- align = max(align, localign);
-
- localign = sizeof(enum lttng_irq_mode);
- align = max(align, localign);
-
- return align;
-}
-
-void lttng_write_mystruct2(void **to,
- void **from,
- size_t *len,
- struct lttng_mystruct2 *obj)
-{
- size_t align, size;
-
- align = lttng_get_alignment_mystruct2(obj);
- size = lttng_get_size_mystruct2(obj);
-
- if(*len == 0) {
- *to += ltt_align((size_t)(*to), align); /* align output */
- } else {
- *len += ltt_align((size_t)(*to+*len), align); /* C alignment, ok to do a memcpy of it */
- }
-
- *len += size;
-}
-
-
-
-#define LTTNG_ARRAY_SIZE_mystruct_myarray 10
-typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];
-
-size_t lttng_get_size_array_mystruct_myarray(
- lttng_array_mystruct_myarray obj)
-{
- size_t size=0, locsize;
-
- locsize = sizeof(uint64_t);
- /* ltt_align == 0 always*/
- //size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
- BUG_ON(ltt_align(size, locsize) != 0);
- size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;
-
- BUG_ON(size != LTTNG_ARRAY_SIZE_mystruct_myarray * sizeof(uint64_t));
-
- return size;
-}
-
-size_t lttng_get_alignment_array_mystruct_myarray(
- lttng_array_mystruct_myarray obj)
-{
- size_t align=0, localign;
-
- localign = sizeof(uint64_t);
- align = max(align, localign);
-
- return align;
-}
-
-
-void lttng_write_array_mystruct_myarray(void **to,
- void **from,
- size_t *len,
- lttng_array_mystruct_myarray obj)
-{
- size_t align, size;
-
- align = lttng_get_alignment_array_mystruct_myarray(obj);
- size = lttng_get_size_array_mystruct_myarray(obj);
-
- if(*len == 0) {
- *to += ltt_align((size_t)(*to), align); /* align output */
- } else {
- *len += ltt_align((size_t)(*to+*len), align); /* C alignment, ok to do a memcpy of it */
- }
-
- *len += size;
-}
-
-
-typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence;
-struct lttng_sequence_mystruct_mysequence {
- unsigned int len;
- double *array;
-};
-
-
-size_t lttng_get_size_sequence_mystruct_mysequence(
- lttng_sequence_mystruct_mysequence *obj)
-{
- size_t size=0, locsize;
-
- locsize = sizeof(unsigned int);
- size += ltt_align(size, locsize) + locsize;
-
- locsize = sizeof(double);
- size += ltt_align(size, locsize) + (obj->len * locsize);
-
- return size;
-}
-
-size_t lttng_get_alignment_sequence_mystruct_mysequence(
- lttng_sequence_mystruct_mysequence *obj)
-{
- size_t align=0, localign;
-
- localign = sizeof(unsigned int);
- align = max(align, localign);
-
- localign = sizeof(double);
- align = max(align, localign);
-
- return align;
-}
-
-
-void lttng_write_sequence_mystruct_mysequence(void **to,
- void **from,
- size_t *len,
- lttng_sequence_mystruct_mysequence *obj)
-{
- size_t align, size;
- void *varfrom;
- size_t varlen=0;
-
- /* Flush pending memcpy */
- if(*len != 0) {
- memcpy(*to, *from, *len);
- *to += *len;
- *len = 0;
- }
-
- align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
- //no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
-
- /* Align output */
- *to += ltt_align((size_t)(*to), align);
-
- /* Copy members */
- *to += ltt_align((size_t)*to, sizeof(unsigned int));
- varfrom = &obj->len;
- varlen += sizeof(unsigned int);
- memcpy(*to, varfrom, varlen);
- *to += varlen;
- varlen = 0;
-
- *to += ltt_align((size_t)*to, sizeof(double));
- varfrom = obj->array;
- varlen += obj->len * sizeof(double);
- memcpy(*to, varfrom, varlen);
- *to += varlen;
- varlen = 0;
-
- /* Put source *from just after the C sequence */
- *from = obj+1;
-}
-
-
-
-union lttng_mystruct_myunion {
- double myfloat;
- unsigned long myulong;
-};
-
-
-size_t lttng_get_size_mystruct_myunion(
- union lttng_mystruct_myunion *obj)
-{
- size_t size=0, locsize;
-
- locsize = sizeof(double);
- size = max(size, locsize);
-
- locsize = sizeof(unsigned long);
- size = max(size, locsize);
-
- BUG_ON(size != sizeof(union lttng_mystruct_myunion));
-
- return size;
-}
-
-
-size_t lttng_get_alignment_mystruct_myunion(
- union lttng_mystruct_myunion *obj)
-{
- size_t align=0, localign;
-
- localign = sizeof(double);
- align = max(align, localign);
-
- localign = sizeof(unsigned long);
- align = max(align, localign);
-
- return align;
-}
-
-
-void lttng_write_mystruct_myunion(void **to,
- void **from,
- size_t *len,
- union lttng_mystruct_myunion *obj)
-{
- size_t align, size;
-
- align = lttng_get_alignment_mystruct_myunion(obj);
- size = lttng_get_size_mystruct_myunion(obj);
-
- if(*len == 0) {
- *to += ltt_align((size_t)(*to), align); /* align output */
- } else {
- *len += ltt_align((size_t)(*to+*len), align); /* C alignment, ok to do a memcpy of it */
- }
-
- *len += size;
-}
-
-
-struct lttng_mystruct {
- unsigned int irq_id;
- enum lttng_irq_mode mode;
- struct lttng_mystruct2 teststr;
- lttng_array_mystruct_myarray myarray;
- lttng_sequence_mystruct_mysequence mysequence;
- union lttng_mystruct_myunion myunion;
-};
-
-size_t lttng_get_size_mystruct(
- struct lttng_mystruct *obj)
-{
- size_t size=0, locsize, localign;
-
- locsize = sizeof(unsigned int);
- size += ltt_align(size, locsize) + locsize;
-
- locsize = sizeof(enum lttng_irq_mode);
- size += ltt_align(size, locsize) + locsize;
-
- localign = lttng_get_alignment_mystruct2(&obj->teststr);
- locsize = lttng_get_size_mystruct2(&obj->teststr);
- size += ltt_align(size, localign) + locsize;
-
- localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
- locsize = lttng_get_size_array_mystruct_myarray(obj->myarray);
- size += ltt_align(size, localign) + locsize;
-
- localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
- locsize = lttng_get_size_sequence_mystruct_mysequence(&obj->mysequence);
- size += ltt_align(size, localign) + locsize;
-
- localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
- locsize = lttng_get_size_mystruct_myunion(&obj->myunion);
- size += ltt_align(size, localign) + locsize;
-
- return size;
-}
-
-
-size_t lttng_get_alignment_mystruct(
- struct lttng_mystruct *obj)
-{
- size_t align=0, localign;
-
- localign = sizeof(unsigned int);
- align = max(align, localign);
-
- localign = sizeof(enum lttng_irq_mode);
- align = max(align, localign);
-
- localign = lttng_get_alignment_mystruct2(&obj->teststr);
- align = max(align, localign);
-
- localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
- align = max(align, localign);
-
- localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
- align = max(align, localign);
-
- localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
- align = max(align, localign);
-
- return align;
-}
-
-void lttng_write_mystruct(void **to,
- void **from,
- size_t *len,
- struct lttng_mystruct *obj)
-{
- size_t align, size;
-
- align = lttng_get_alignment_mystruct(obj);
- // no need : contains variable size fields.
- // locsize = lttng_get_size_mystruct(obj);
-
- if(*len == 0) {
- *to += ltt_align((size_t)(*to), align); /* align output */
- } else {
- *len += ltt_align((size_t)(*to+*len), align); /* C alignment, ok to do a memcpy of it */
- }
-
- /* Contains variable sized fields : must explode the structure */
-
- size = sizeof(unsigned int);
- *len += ltt_align((size_t)(*to+*len), size) + size;
-
- size = sizeof(enum lttng_irq_mode);
- *len += ltt_align((size_t)(*to+*len), size) + size;
-
- lttng_write_mystruct2(to, from, len, &obj->teststr);
-
- lttng_write_array_mystruct_myarray(to, from, len, obj->myarray);
-
- /* Variable length field */
- lttng_write_sequence_mystruct_mysequence(to, from, len, &obj->mysequence);
-
- lttng_write_mystruct_myunion(to, from, len, &obj->myunion);
-
- /* Don't forget to flush last write..... */
-}
-
-
-
-
-/* Event syscall_entry structures */
-
-/* Event syscall_entry logging function */
-static inline void trace_test_syscall_entry(
- unsigned int syscall_id,
- void * address)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-/* Event syscall_exit structures */
-
-/* Event syscall_exit logging function */
-static inline void trace_test_syscall_exit(
- void)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-/* Event trap_entry structures */
-
-/* Event trap_entry logging function */
-static inline void trace_test_trap_entry(
- unsigned int trap_id,
- void * address)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-/* Event trap_exit structures */
-
-/* Event trap_exit logging function */
-static inline void trace_test_trap_exit(
- void)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-/* Event soft_irq_entry structures */
-
-/* Event soft_irq_entry logging function */
-static inline void trace_test_soft_irq_entry(
- void * softirq_id)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-/* Event soft_irq_exit structures */
-
-/* Event soft_irq_exit logging function */
-static inline void trace_test_soft_irq_exit(
- void * softirq_id)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-/* Event tasklet_entry structures */
-
-/* Event tasklet_entry logging function */
-static inline void trace_test_tasklet_entry(
- enum lttng_tasklet_priority priority,
- void * address,
- unsigned long data)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-/* Event tasklet_exit structures */
-
-/* Event tasklet_exit logging function */
-static inline void trace_test_tasklet_exit(
- enum lttng_tasklet_priority priority,
- void * address,
- unsigned long data)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-/* Event irq_entry structures */
-
-/* Event irq_entry logging function */
-static inline void trace_test_irq_entry(
- unsigned int irq_id,
- enum lttng_irq_mode mode)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-/* Event irq_exit structures */
-
-/* Event irq_exit logging function */
-static inline void trace_test_irq_exit(
- void)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-/* Event big_array structures */
-union lttng_test_big_array_myarray_b {
- void * c;
-};
-
-struct lttng_test_big_array_myarray {
- void * a;
- union lttng_test_big_array_myarray_b b;
-};
-
-#define LTTNG_ARRAY_SIZE_test_big_array_myarray 2
-typedef struct lttng_test_big_array_myarray lttng_array_test_big_array_myarray[LTTNG_ARRAY_SIZE_test_big_array_myarray];
-
-#define LTTNG_ARRAY_SIZE_test_big_array_myarray 10000
-typedef lttng_array_test_big_array_myarray lttng_array_test_big_array_myarray[LTTNG_ARRAY_SIZE_test_big_array_myarray];
-
-
-/* Event big_array logging function */
-static inline void trace_test_big_array(
- lttng_array_test_big_array_myarray myarray)
-#ifndef CONFIG_LTT
-{
-}
-#else
-{
-}
-#endif //CONFIG_LTT
-
-
-#endif //CONFIG_LTT_FACILITY_TEST
-
-#endif //_LTT_FACILITY_TEST_H_
+++ /dev/null
-/*
-
-parser.c: Generate helper declarations and functions to trace events
- from an event description file.
-
- Copyright (C) 2005, Mathieu Desnoyers
- Copyright (C) 2002, Xianxiu Yang
- Copyright (C) 2002, Michel Dagenais
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; version 2 of the License.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-/* This program reads the ".xml" event definitions input files
- and constructs structure for each event.
-
- The program uses a very simple tokenizer, called from a hand written
- recursive descent parser to fill a data structure describing the events.
- The result is a sequence of events definitions which refer to type
- definitions.
-
- A table of named types is maintained to allow refering to types by name
- when the same type is used at several places. Finally a sequence of
- all types is maintained to facilitate the freeing of all type
- information when the processing of an ".xml" file is finished. */
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <linux/errno.h>
-#include <assert.h>
-#include <ctype.h>
-
-#include "parser.h"
-
-
-char *intOutputTypes[] = {
- "int8_t", "int16_t", "int32_t", "int64_t" };
-
-char *uintOutputTypes[] = {
- "uint8_t", "uint16_t", "uint32_t", "uint64_t" };
-
-char *floatOutputTypes[] = {
- "undef", "undef", "float", "double" };
-
-
-
-
-/* helper function */
-void strupper(char *string)
-{
- char *ptr = string;
-
- while(*ptr != '\0') {
- *ptr = toupper(*ptr);
- ptr++;
- }
-}
-
-
-int getSizeindex(unsigned int value)
-{
- switch(value) {
- case 1:
- return 0;
- case 2:
- return 1;
- case 4:
- return 2;
- case 8:
- return 3;
- default:
- printf("Error : unknown value size %d\n", value);
- exit(-1);
- }
-}
-
-/*****************************************************************************
- *Function name
- * getSize : translate from string to integer
- *Input params
- * in : input file handle
- *Return values
- * size
- *****************************************************************************/
-
-unsigned long long int getSize(parse_file_t *in)
-{
- char *token, *token2;
- unsigned long long int ret;
-
- token = getToken(in);
-
-
- if(in->type == QUOTEDSTRING) {
- in->type = NUMBER;
- token2 = token;
- do {
- if (!isdigit(*token2)) {
- in->type = QUOTEDSTRING;
- break;
- }
- } while (*(++token2) != '\0');
- }
-
- if(in->type == NUMBER) {
- ret = strtoull(token, NULL, 0);
- } else {
- goto error;
- }
-
- return ret;
-error:
- in->error(in,"incorrect size specification");
- return -1;
-}
-
-/*****************************************************************************
- *Function name
- * error_callback : print out error info
- *Input params
- * in : input file handle
- * msg : message to be printed
- ****************************************************************************/
-
-void error_callback(parse_file_t *in, char *msg)
-{
- if(in)
- printf("Error in file %s, line %d: %s\n", in->name, in->lineno, msg);
- else
- printf("%s\n",msg);
- assert(0);
- exit(1);
-}
-
-/*****************************************************************************
- *Function name
- * memAlloc : allocate memory
- *Input params
- * size : required memory size
- *return value
- * void * : pointer to allocate memory or NULL
- ****************************************************************************/
-
-void * memAlloc(int size)
-{
- void * addr;
- if(size == 0) return NULL;
- addr = malloc(size);
- if(!addr){
- printf("Failed to allocate memory");
- exit(1);
- }
- return addr;
-}
-
-/*****************************************************************************
- *Function name
- * allocAndCopy : allocate memory and initialize it
- *Input params
- * str : string to be put in memory
- *return value
- * char * : pointer to allocate memory or NULL
- ****************************************************************************/
-
-char *allocAndCopy(char *str)
-{
- char * addr;
- if(str == NULL) return NULL;
- addr = (char *)memAlloc(strlen(str)+1);
- strcpy(addr,str);
- return addr;
-}
-
-/**************************************************************************
- * Function :
- * getTypeAttributes
- * Description :
- * Read the attribute from the input file.
- *
- * Parameters :
- * in , input file handle.
- * t , the type descriptor to fill.
- *
- **************************************************************************/
-
-void getTypeAttributes(parse_file_t *in, type_descriptor_t *t,
- sequence_t * unnamed_types, table_t * named_types)
-{
- char * token;
- char car;
-
- t->fmt = NULL;
- t->size = 0;
- t->custom_write = 0;
- t->network = 0;
-
- while(1) {
- token = getToken(in);
- if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
- ungetToken(in);
- break;
- }
-
- if(!strcmp("format",token)) {
- getEqual(in);
- t->fmt = allocAndCopy(getQuotedString(in));
- //} else if(!strcmp("name",token)) {
- // getEqual(in);
- // car = seekNextChar(in);
- // if(car == EOF) in->error(in,"name was expected");
- // else if(car == '\"') t->type_name = allocAndCopy(getQuotedString(in));
- // else t->type_name = allocAndCopy(getName(in));
- } else if(!strcmp("size",token)) {
- getEqual(in);
- t->size = getSize(in);
- } else if(!strcmp("custom_write", token)) {
- t->custom_write = 1;
- } else if(!strcmp("byte_order",token)) {
- getEqual(in);
- car = seekNextChar(in);
- if(car == EOF) in->error(in,"byte order was expected (network?)");
- else if(car == '\"') token = getQuotedString(in);
- else token = getName(in);
- if(!strcmp("network", token)) {
- t->network = 1;
- }
- } else if(!strcmp("write",token)) {
- getEqual(in);
- car = seekNextChar(in);
- if(car == EOF) in->error(in,"write type was expected (custom?)");
- else if(car == '\"') token = getQuotedString(in);
- else token = getName(in);
- if(!strcmp("custom", token)) {
- t->custom_write = 1;
- }
- }
- }
-}
-
-/**************************************************************************
- * Function :
- * getEventAttributes
- * Description :
- * Read the attribute from the input file.
- *
- * Parameters :
- * in , input file handle.
- * ev , the event to fill.
- *
- **************************************************************************/
-
-void getEventAttributes(parse_file_t *in, event_t *ev)
-{
- char * token;
- char car;
-
- ev->name = NULL;
- ev->per_trace = 0;
- ev->per_tracefile = 0;
- ev->param_buffer = 0;
- ev->no_instrument_function = 0;
-
- while(1) {
- token = getToken(in);
- if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
- ungetToken(in);
- break;
- }
-
- if(!strcmp("name",token)) {
- getEqual(in);
- car = seekNextChar(in);
- if(car == EOF) in->error(in,"name was expected");
- else if(car == '\"') ev->name = allocAndCopy(getQuotedString(in));
- else ev->name = allocAndCopy(getName(in));
- } else if(!strcmp("scope", token)) {
- getEqual(in);
- car = seekNextChar(in);
- if(car == EOF) in->error(in,"scope was expected");
- else if(car == '\"') token = getQuotedString(in);
- else token = getName(in);
- if(!strcmp(token, "trace")) ev->per_trace = 1;
- else if(!strcmp(token, "tracefile")) ev->per_tracefile = 1;
- } else if(!strcmp("param", token)) {
- getEqual(in);
- car = seekNextChar(in);
- if(car == EOF) in->error(in,"parameter type was expected");
- else if(car == '\"') token = getQuotedString(in);
- else token = getName(in);
- if(!strcmp(token, "buffer")) ev->param_buffer = 1;
- } else if(!strcmp("attribute", token)) {
- getEqual(in);
- car = seekNextChar(in);
- if(car == EOF) in->error(in,"attribute was expected");
- else if(car == '\"') token = getQuotedString(in);
- else token = getName(in);
- if(!strcmp(token, "no_instrument_function"))
- ev->no_instrument_function = 1;
- }
- }
-}
-
-/**************************************************************************
- * Function :
- * getFacilityAttributes
- * Description :
- * Read the attribute from the input file.
- *
- * Parameters :
- * in , input file handle.
- * fac , the facility to fill.
- *
- **************************************************************************/
-
-void getFacilityAttributes(parse_file_t *in, facility_t *fac)
-{
- char * token;
- char car;
-
- fac->name = NULL;
- fac->arch = NULL;
- fac->user = 0;
-
- while(1) {
- token = getToken(in);
- if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
- ungetToken(in);
- break;
- }
-
- if(!strcmp("name",token)) {
- getEqual(in);
- car = seekNextChar(in);
- if(car == EOF) in->error(in,"name was expected");
- else if(car == '\"') fac->name = allocAndCopy(getQuotedString(in));
- else fac->name = allocAndCopy(getName(in));
- if(!strncmp(fac->name, "user_", sizeof("user_")-1))
- fac->user = 1;
- } else if(!strcmp("arch", token)) {
- getEqual(in);
- car = seekNextChar(in);
- if(car == '\"') fac->arch = allocAndCopy(getQuotedString(in));
- else fac->arch = allocAndCopy(getName(in));
- }
- }
-}
-
-/**************************************************************************
- * Function :
- * getFieldAttributes
- * Description :
- * Read the attribute from the input file.
- *
- * Parameters :
- * in , input file handle.
- * f , the field to fill.
- *
- **************************************************************************/
-
-void getFieldAttributes(parse_file_t *in, field_t *f)
-{
- char * token;
- char car;
-
- f->name = NULL;
-
- while(1) {
- token = getToken(in);
- if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
- ungetToken(in);
- break;
- }
-
- if(!strcmp("name",token)) {
- getEqual(in);
- car = seekNextChar(in);
- if(car == EOF) in->error(in,"name was expected");
- else if(car == '\"') f->name = allocAndCopy(getQuotedString(in));
- else f->name = allocAndCopy(getName(in));
- }
- }
-}
-
-char *getNameAttribute(parse_file_t *in)
-{
- char * token;
- char *name = NULL;
- char car;
-
- while(1) {
- token = getToken(in);
- if(!strcmp("name",token)) {
- getEqual(in);
- car = seekNextChar(in);
- if(car == EOF) in->error(in,"name was expected");
- else if(car == '\"') name = allocAndCopy(getQuotedString(in));
- else name = allocAndCopy(getName(in));
- } else {
- ungetToken(in);
- break;
- }
-
- }
- if(name == NULL) in->error(in, "Name was expected");
- return name;
-}
-
-
-
-//for <label name=label_name value=n format="...">, value is an option
-//Return value : 0 : no value, 1 : has a value
-int getValueAttribute(parse_file_t *in, long long *value)
-{
- char * token, *token2;
-
- token = getToken(in);
-
- if(strcmp("/",token) == 0 || strcmp(">", token) == 0){
- ungetToken(in);
- return 0;
- }
- if(strcmp("value",token))in->error(in,"value was expected");
-
- getEqual(in);
- token = getToken(in);
-
- if(in->type == QUOTEDSTRING) {
- in->type = NUMBER;
- token2 = token;
- do {
- if (!isdigit(*token2)) {
- in->type = QUOTEDSTRING;
- break;
- }
- } while (*(++token2) != '\0');
- }
-
- if(in->type == NUMBER)
- *value = strtoll(token, NULL, 0);
- else
- goto error;
- return 1;
-error:
- in->error(in,"incorrect size specification");
- return 0;
-}
-
-char * getDescription(parse_file_t *in)
-{
- long int pos;
- char * token, car, *str;
-
- pos = ftell(in->fp);
-
- getLAnglebracket(in);
- token = getName(in);
- if(strcmp("description",token)){
- fseek(in->fp, pos, SEEK_SET);
- return NULL;
- }
-
- getRAnglebracket(in);
-
- pos = 0;
- while((car = getc(in->fp)) != EOF) {
- if(car == '<') break;
- if(car == '\0') continue;
- in->buffer[pos] = car;
- pos++;
- }
- if(car == EOF)in->error(in,"not a valid description");
- in->buffer[pos] = '\0';
-
- str = allocAndCopy(in->buffer);
-
- getForwardslash(in);
- token = getName(in);
- if(strcmp("description", token))in->error(in,"not a valid description");
- getRAnglebracket(in);
-
- return str;
-}
-
-/*****************************************************************************
- *Function name
- * parseFacility : generate event list
- *Input params
- * in : input file handle
- * fac : empty facility
- *Output params
- * fac : facility filled with event list
- ****************************************************************************/
-
-void parseFacility(parse_file_t *in, facility_t * fac)
-{
- char * token;
- event_t *ev;
-
- getFacilityAttributes(in, fac);
- if(fac->name == NULL) in->error(in, "Attribute not named");
-
- fac->capname = allocAndCopy(fac->name);
- strupper(fac->capname);
- getRAnglebracket(in);
-
- fac->description = getDescription(in);
-
- while(1){
- getLAnglebracket(in);
-
- token = getToken(in);
- if(in->type == ENDFILE)
- in->error(in,"the definition of the facility is not finished");
-
- if(strcmp("event",token) == 0){
- ev = (event_t*) memAlloc(sizeof(event_t));
- sequence_push(&(fac->events),ev);
- parseEvent(in,ev, &(fac->unnamed_types), &(fac->named_types));
- }else if(strcmp("type",token) == 0){
- parseTypeDefinition(in, &(fac->unnamed_types), &(fac->named_types));
- }else if(in->type == FORWARDSLASH){
- break;
- }else in->error(in,"event or type token expected\n");
- }
-
- token = getName(in);
- if(strcmp("facility",token)) in->error(in,"not the end of the facility");
- getRAnglebracket(in); //</facility>
-}
-
-/*****************************************************************************
- *Function name
- * parseEvent : generate event from event definition
- *Input params
- * in : input file handle
- * ev : new event
- * unnamed_types : array of unamed types
- * named_types : array of named types
- *Output params
- * ev : new event (parameters are passed to it)
- ****************************************************************************/
-
-void parseEvent(parse_file_t *in, event_t * ev, sequence_t * unnamed_types,
- table_t * named_types)
-{
- char *token;
- field_t *f;
-
- sequence_init(&(ev->fields));
- //<event name=eventtype_name>
- getEventAttributes(in, ev);
- if(ev->name == NULL) in->error(in, "Event not named");
- getRAnglebracket(in);
-
- //<description>...</description>
- ev->description = getDescription(in);
-
- int got_end = 0;
- /* Events can have multiple fields. each field form at least a function
- * parameter of the logging function. */
- while(!got_end) {
- getLAnglebracket(in);
- token = getToken(in);
-
- switch(in->type) {
- case FORWARDSLASH: /* </event> */
- token = getName(in);
- if(strcmp("event",token))in->error(in,"not an event definition");
- getRAnglebracket(in); //</event>
- got_end = 1;
- break;
- case NAME: /* a field */
- if(strcmp("field",token))in->error(in,"expecting a field");
- f = (field_t *)memAlloc(sizeof(field_t));
- sequence_push(&(ev->fields),f);
- parseFields(in, f, unnamed_types, named_types, 1);
- break;
- default:
- in->error(in, "expecting </event> or <field >");
- break;
- }
- }
-#if 0
- if(in->type == FORWARDSLASH){ //</event> NOTHING
- ev->type = NULL;
- }else if(in->type == NAME){
- if(strcmp("struct",token)==0 || strcmp("typeref",token)==0){
- ungetToken(in);
- ev->type = parseType(in,NULL, unnamed_types, named_types);
- if(ev->type->type != STRUCT && ev->type->type != NONE)
- in->error(in,"type must be a struct");
- }else in->error(in, "not a valid type");
-
- getLAnglebracket(in);
- getForwardslash(in);
- }else in->error(in,"not a struct type");
- getLAnglebracket(in);
- getForwardslash(in);
- token = getName(in);
- if(strcmp("event",token))in->error(in,"not an event definition");
- getRAnglebracket(in); //</event>
-#endif //0
-}
-
-/*****************************************************************************
- *Function name
- * parseField : get field infomation from buffer
- *Input params
- * in : input file handle
- * f : field
- * unnamed_types : array of unamed types
- * named_types : array of named types
- * tag : is field surrounded by a <field> </field> tag ?
- ****************************************************************************/
-
-void parseFields(parse_file_t *in, field_t *f,
- sequence_t * unnamed_types,
- table_t * named_types,
- int tag)
-{
- char * token;
- if(tag) {
- //<field name=field_name> <description> <type> </field>
- getFieldAttributes(in, f);
- if(f->name == NULL) in->error(in, "Field not named");
- getRAnglebracket(in);
-
- f->description = getDescription(in);
- } else {
- f->description = NULL;
- }
-
- //<int size=...>
- getLAnglebracket(in);
- f->type = parseType(in,NULL, unnamed_types, named_types);
-
- if(tag) {
- getLAnglebracket(in);
- getForwardslash(in);
- token = getName(in);
- if(strcmp("field",token))in->error(in,"not a valid field definition");
- getRAnglebracket(in); //</field>
- }
-}
-
-
-/*****************************************************************************
- *Function name
- * parseType : get type information, type can be :
- * Primitive:
- * int(size,fmt); uint(size,fmt); float(size,fmt);
- * string(fmt); enum(size,fmt,(label1,label2...))
- * Compound:
- * array(arraySize, type); sequence(lengthSize,type)
- * struct(field(name,type,description)...)
- * type name:
- * type(name,type)
- *Input params
- * in : input file handle
- * inType : a type descriptor
- * unnamed_types : array of unamed types
- * named_types : array of named types
- *Return values
- * type_descriptor* : a type descriptor
- ****************************************************************************/
-
-type_descriptor_t *parseType(parse_file_t *in, type_descriptor_t *inType,
- sequence_t * unnamed_types, table_t * named_types)
-{
- char *token;
- type_descriptor_t *t;
- field_t *f;
-
- if(inType == NULL) {
- t = (type_descriptor_t *) memAlloc(sizeof(type_descriptor_t));
- t->type_name = NULL;
- t->type = NONE;
- t->fmt = NULL;
- sequence_push(unnamed_types,t);
- }
- else t = inType;
-
- token = getName(in);
-
- if(strcmp(token,"struct") == 0) {
- t->type = STRUCT;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getRAnglebracket(in); //<struct>
- getLAnglebracket(in); //<field name=..>
- token = getToken(in);
- sequence_init(&(t->fields));
- while(strcmp("field",token) == 0){
- f = (field_t *)memAlloc(sizeof(field_t));
- sequence_push(&(t->fields),f);
-
- parseFields(in, f, unnamed_types, named_types, 1);
-
- //next field
- getLAnglebracket(in);
- token = getToken(in);
- }
- if(strcmp("/",token))in->error(in,"not a valid structure definition");
- token = getName(in);
- if(strcmp("struct",token)!=0)
- in->error(in,"not a valid structure definition");
- getRAnglebracket(in); //</struct>
- }
- else if(strcmp(token,"union") == 0) {
- t->type = UNION;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getRAnglebracket(in); //<union>
-
- getLAnglebracket(in); //<field name=..>
- token = getToken(in);
- sequence_init(&(t->fields));
- while(strcmp("field",token) == 0){
- f = (field_t *)memAlloc(sizeof(field_t));
- sequence_push(&(t->fields),f);
- parseFields(in, f, unnamed_types, named_types, 1);
-
- //next field
- getLAnglebracket(in);
- token = getToken(in);
- }
- if(strcmp("/",token))in->error(in,"not a valid union definition");
- token = getName(in);
- if(strcmp("union",token)!=0)
- in->error(in,"not a valid union definition");
- getRAnglebracket(in); //</union>
- }
- else if(strcmp(token,"array") == 0) {
- t->type = ARRAY;
- sequence_init(&(t->fields));
- getTypeAttributes(in, t, unnamed_types, named_types);
- if(t->size == 0) in->error(in, "Array has empty size");
- getForwardslash(in);
- getRAnglebracket(in); //<array size=n>
-
- //getLAnglebracket(in); //<subtype>
- /* subfield */
- f = (field_t *)memAlloc(sizeof(field_t));
- sequence_push(&(t->fields),f);
- parseFields(in, f, unnamed_types, named_types, 0);
-
- //getLAnglebracket(in); //<type struct>
- //t->nested_type = parseType(in, NULL, unnamed_types, named_types);
-
- getLAnglebracket(in); //</array>
- getForwardslash(in);
- token = getName(in);
- if(strcmp("array",token))in->error(in,"not a valid array definition");
- getRAnglebracket(in); //</array>
- }
- else if(strcmp(token,"sequence") == 0) {
- t->type = SEQUENCE;
- sequence_init(&(t->fields));
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in); //<sequence>
-
- //getLAnglebracket(in); //<sequence size type>
- /* subfield */
- f = (field_t *)memAlloc(sizeof(field_t));
- sequence_push(&(t->fields),f);
- parseFields(in, f, unnamed_types, named_types, 0);
-
- //getLAnglebracket(in); //<subtype>
- /* subfield */
- f = (field_t *)memAlloc(sizeof(field_t));
- sequence_push(&(t->fields),f);
- parseFields(in, f, unnamed_types, named_types, 0);
-
- //getLAnglebracket(in); //<type sequence>
- //t->length_type = parseType(in, NULL, unnamed_types, named_types);
-
- //getLAnglebracket(in); //<type sequence>
-
- //t->nested_type = parseType(in, NULL, unnamed_types, named_types);
-
- if(t->fields.position < 1) in->error(in, "Sequence has no length type");
- if(t->fields.position < 2) in->error(in, "Sequence has no subtype");
- switch(((field_t*)t->fields.array[0])->type->type) {
- case UINT_FIXED :
- case UCHAR :
- case USHORT :
- case UINT :
- case ULONG :
- case SIZE_T :
- case OFF_T :
- break;
- default:
- in->error(in, "Wrong length type for sequence");
- }
-
- getLAnglebracket(in); //</sequence>
- getForwardslash(in);
- token = getName(in);
- if(strcmp("sequence",token))in->error(in,"not a valid sequence definition");
- getRAnglebracket(in); //</sequence>
- }
- else if(strcmp(token,"enum") == 0) {
- char * str;
- long long value = -1;
-
- t->type = ENUM;
- sequence_init(&(t->labels));
- sequence_init(&(t->labels_values));
- sequence_init(&(t->labels_description));
- t->already_printed = 0;
- getTypeAttributes(in, t, unnamed_types, named_types);
- //if(t->size == 0) in->error(in, "Sequence has empty size");
- //Mathieu : we fix enum size to target int size. GCC is always like this.
- //fox copy optimisation.
- if(t->size != 0) in->error(in, "Enum has fixed size of target int.");
- t->size = 0;
- getRAnglebracket(in);
-
- //<label name=label1 value=n/>
- getLAnglebracket(in);
- token = getToken(in); //"label" or "/"
- while(strcmp("label",token) == 0){
- int *label_value = malloc(sizeof(int));
- int has_value = 0;
- long long loc_value;
-
- str = allocAndCopy(getNameAttribute(in));
- has_value = getValueAttribute(in, &loc_value);
-
- sequence_push(&(t->labels),str);
-
- if(has_value) value = loc_value;
- else value++;
-
- *label_value = value;
- sequence_push(&(t->labels_values), label_value);
-
- getForwardslash(in);
- getRAnglebracket(in);
-
- //read description if any. May be NULL.
- str = allocAndCopy(getDescription(in));
- sequence_push(&(t->labels_description),str);
-
- //next label definition
- getLAnglebracket(in);
- token = getToken(in); //"label" or "/"
- }
- if(strcmp("/",token))in->error(in, "not a valid enum definition");
- token = getName(in);
- if(strcmp("enum",token))in->error(in, "not a valid enum definition");
- getRAnglebracket(in); //</label>
- }
- else if(strcmp(token,"int_fixed") == 0) {
- t->type = INT_FIXED;
- getTypeAttributes(in, t, unnamed_types, named_types);
- if(t->size == 0) in->error(in, "int has empty size");
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"uint_fixed") == 0) {
- t->type = UINT_FIXED;
- getTypeAttributes(in, t, unnamed_types, named_types);
- if(t->size == 0) in->error(in, "uint has empty size");
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"char") == 0) {
- t->type = CHAR;
- getTypeAttributes(in, t, unnamed_types, named_types);
- t->size = 1;
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"uchar") == 0) {
- t->type = UCHAR;
- getTypeAttributes(in, t, unnamed_types, named_types);
- t->size = 1;
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"short") == 0) {
- t->type = SHORT;
- getTypeAttributes(in, t, unnamed_types, named_types);
- t->size = 2;
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"ushort") == 0) {
- t->type = USHORT;
- getTypeAttributes(in, t, unnamed_types, named_types);
- t->size = 2;
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"int") == 0) {
- t->type = INT;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"uint") == 0) {
- t->type = UINT;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in);
- }
-
- else if(strcmp(token,"pointer") == 0) {
- t->type = POINTER;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"long") == 0) {
- t->type = LONG;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"ulong") == 0) {
- t->type = ULONG;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"size_t") == 0) {
- t->type = SIZE_T;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"ssize_t") == 0) {
- t->type = SSIZE_T;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"off_t") == 0) {
- t->type = OFF_T;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"float") == 0) {
- t->type = FLOAT;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"string") == 0) {
- t->type = STRING;
- getTypeAttributes(in, t, unnamed_types, named_types);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"typeref") == 0){
- // Must be a named type
- free(t);
- sequence_pop(unnamed_types);
- token = getNameAttribute(in);
- t = find_named_type(token, named_types);
- if(t == NULL) in->error(in,"Named referred to must be pre-declared.");
- getForwardslash(in); //<typeref name=type_name/>
- getRAnglebracket(in);
- return t;
- }else in->error(in,"not a valid type");
-
- return t;
-}
-
-/*****************************************************************************
- *Function name
- * find_named_type : find a named type from hash table
- *Input params
- * name : type name
- * named_types : array of named types
- *Return values
- * type_descriptor * : a type descriptor
- *****************************************************************************/
-
-type_descriptor_t * find_named_type(char *name, table_t * named_types)
-{
- type_descriptor_t *t;
-
- t = table_find(named_types,name);
-
- return t;
-}
-
-type_descriptor_t * create_named_type(char *name, table_t * named_types)
-{
- type_descriptor_t *t;
-
- t = (type_descriptor_t *)memAlloc(sizeof(type_descriptor_t));
- t->type_name = allocAndCopy(name);
- t->type = NONE;
- t->fmt = NULL;
- table_insert(named_types,t->type_name,t);
- // table_insert(named_types,allocAndCopy(name),t);
- return t;
-}
-
-/*****************************************************************************
- *Function name
- * parseTypeDefinition : get type information from type definition
- *Input params
- * in : input file handle
- * unnamed_types : array of unamed types
- * named_types : array of named types
- *****************************************************************************/
-
-void parseTypeDefinition(parse_file_t * in, sequence_t * unnamed_types,
- table_t * named_types)
-{
- char *token;
- type_descriptor_t *t;
-
- token = getNameAttribute(in);
- if(token == NULL) in->error(in, "Type has empty name");
- t = create_named_type(token, named_types);
-
- if(t->type != NONE) in->error(in,"redefinition of named type");
- getRAnglebracket(in); //<type name=type_name>
- getLAnglebracket(in); //<
- token = getName(in);
- //MD ??if(strcmp("struct",token))in->error(in,"not a valid type definition");
- ungetToken(in);
- parseType(in,t, unnamed_types, named_types);
-
- //</type>
- getLAnglebracket(in);
- getForwardslash(in);
- token = getName(in);
- if(strcmp("type",token))in->error(in,"not a valid type definition");
- getRAnglebracket(in); //</type>
-}
-
-/**************************************************************************
- * Function :
- * getComa, getName, getNumber, getEqual
- * Description :
- * Read a token from the input file, check its type, return it scontent.
- *
- * Parameters :
- * in , input file handle.
- *
- * Return values :
- * address of token content.
- *
- **************************************************************************/
-
-char *getName(parse_file_t * in)
-{
- char *token;
-
- token = getToken(in);
- // Optional descriptions
- // if(in->type != NAME) in->error(in,"Name token was expected");
- return token;
-}
-
-int getNumber(parse_file_t * in)
-{
- char *token;
-
- token = getToken(in);
- if(in->type != NUMBER) in->error(in, "Number token was expected");
- return atoi(token);
-}
-
-char *getForwardslash(parse_file_t * in)
-{
- char *token;
-
- token = getToken(in);
- //if(in->type != FORWARDSLASH) in->error(in, "forward slash token was expected");
- /* Mathieu : final / is optional now. */
- if(in->type != FORWARDSLASH) ungetToken(in);
-
- return token;
-}
-
-char *getLAnglebracket(parse_file_t * in)
-{
- char *token;
-
- token = getToken(in);
- if(in->type != LANGLEBRACKET) in->error(in, "Left angle bracket was expected");
- return token;
-}
-
-char *getRAnglebracket(parse_file_t * in)
-{
- char *token;
-
- token = getToken(in);
- if(in->type != RANGLEBRACKET) in->error(in, "Right angle bracket was expected");
- return token;
-}
-
-char *getQuotedString(parse_file_t * in)
-{
- char *token;
-
- token = getToken(in);
- if(in->type != QUOTEDSTRING) in->error(in, "quoted string was expected");
- return token;
-}
-
-char * getEqual(parse_file_t *in)
-{
- char *token;
-
- token = getToken(in);
- if(in->type != EQUAL) in->error(in, "equal was expected");
- return token;
-}
-
-char seekNextChar(parse_file_t *in)
-{
- char car;
- while((car = getc(in->fp)) != EOF) {
- if(!isspace(car)){
- ungetc(car,in->fp);
- return car;
- }
- }
- return EOF;
-}
-
-/******************************************************************
- * Function :
- * getToken, ungetToken
- * Description :
- * Read a token from the input file and return its type and content.
- * Line numbers are accounted for and whitespace/comments are skipped.
- *
- * Parameters :
- * in, input file handle.
- *
- * Return values :
- * address of token content.
- *
- ******************************************************************/
-
-void ungetToken(parse_file_t * in)
-{
- in->unget = 1;
-}
-
-char *getToken(parse_file_t * in)
-{
- FILE *fp = in->fp;
- char car, car1;
- int pos = 0, escaped;
-
- if(in->unget == 1) {
- in->unget = 0;
- return in->buffer;
- }
-
- /* skip whitespace and comments */
-
- while((car = getc(fp)) != EOF) {
- if(car == '/') {
- car1 = getc(fp);
- if(car1 == '*') skipComment(in);
- else if(car1 == '/') skipEOL(in);
- else {
- car1 = ungetc(car1,fp);
- break;
- }
- }
- else if(car == '\n') in->lineno++;
- else if(!isspace(car)) break;
- }
-
- switch(car) {
- case EOF:
- in->type = ENDFILE;
- break;
- case '/':
- in->type = FORWARDSLASH;
- in->buffer[pos] = car;
- pos++;
- break;
- case '<':
- in->type = LANGLEBRACKET;
- in->buffer[pos] = car;
- pos++;
- break;
- case '>':
- in->type = RANGLEBRACKET;
- in->buffer[pos] = car;
- pos++;
- break;
- case '=':
- in->type = EQUAL;
- in->buffer[pos] = car;
- pos++;
- break;
- case '"':
- escaped = 0;
- while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
- if(car == '\\' && escaped == 0) {
- in->buffer[pos] = car;
- pos++;
- escaped = 1;
- continue;
- }
- if(car == '"' && escaped == 0) break;
- if(car == '\n' && escaped == 0) {
- in->error(in, "non escaped newline inside quoted string");
- }
- if(car == '\n') in->lineno++;
- in->buffer[pos] = car;
- pos++;
- escaped = 0;
- }
- if(car == EOF) in->error(in,"no ending quotemark");
- if(pos == BUFFER_SIZE) in->error(in, "quoted string token too large");
- in->type = QUOTEDSTRING;
- break;
- default:
- if(isdigit(car)) {
- in->buffer[pos] = car;
- pos++;
- while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
- if(!isdigit(car)) {
- ungetc(car,fp);
- break;
- }
- in->buffer[pos] = car;
- pos++;
- }
- if(car == EOF) ungetc(car,fp);
- if(pos == BUFFER_SIZE) in->error(in, "number token too large");
- in->type = NUMBER;
- }
- else if(isalnum(car) || car == '_' || car == '-') {
- in->buffer[0] = car;
- pos = 1;
- while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
- if(!(isalnum(car) || car == '_' || car == '-')) {
- ungetc(car,fp);
- break;
- }
- in->buffer[pos] = car;
- pos++;
- }
- if(car == EOF) ungetc(car,fp);
- if(pos == BUFFER_SIZE) in->error(in, "name token too large");
- in->type = NAME;
- } else if(car == '?') {
- in->buffer[0] = car;
- pos++;
- }
- else in->error(in, "invalid character, unrecognized token");
- }
- in->buffer[pos] = 0;
- return in->buffer;
-}
-
-void skipComment(parse_file_t * in)
-{
- char car;
- while((car = getc(in->fp)) != EOF) {
- if(car == '\n') in->lineno++;
- else if(car == '*') {
- car = getc(in->fp);
- if(car ==EOF) break;
- if(car == '/') return;
- ungetc(car,in->fp);
- }
- }
- if(car == EOF) in->error(in,"comment begining with '/*' has no ending '*/'");
-}
-
-void skipEOL(parse_file_t * in)
-{
- char car;
- while((car = getc(in->fp)) != EOF) {
- if(car == '\n') {
- ungetc(car,in->fp);
- break;
- }
- }
- if(car == EOF)ungetc(car, in->fp);
-}
-
-/*****************************************************************************
- *Function name
- * checkNamedTypesImplemented : check if all named types have definition
- ****************************************************************************/
-
-void checkNamedTypesImplemented(table_t * named_types)
-{
- type_descriptor_t *t;
- int pos;
- char str[256];
-
- for(pos = 0 ; pos < named_types->values.position; pos++) {
- t = (type_descriptor_t *) named_types->values.array[pos];
- if(t->type == NONE){
- sprintf(str,"named type '%s' has no definition",
- (char*)named_types->keys.array[pos]);
- error_callback(NULL,str);
- }
- }
-}
-
-
-/*****************************************************************************
- *Function name
- * generateChecksum : generate checksum for the facility
- *Input Params
- * facName : name of facility
- *Output Params
- * checksum : checksum for the facility
- ****************************************************************************/
-
-void generateChecksum(char* facName,
- unsigned int * checksum, sequence_t * events)
-{
- unsigned long crc ;
- int pos;
- event_t * ev;
- unsigned int i;
-
- crc = crc32(facName);
- for(pos = 0; pos < events->position; pos++){
- ev = (event_t *)(events->array[pos]);
- crc = partial_crc32(ev->name, crc);
- for(i = 0; i < ev->fields.position; i++) {
- field_t *f = (field_t*)ev->fields.array[i];
- crc = partial_crc32(f->name, crc);
- crc = getTypeChecksum(crc, f->type);
- }
- }
- *checksum = crc;
-}
-
-/*****************************************************************************
- *Function name
- * getTypeChecksum : generate checksum by type info
- *Input Params
- * crc : checksum generated so far
- * type : type descriptor containing type info
- *Return value
- * unsigned long : checksum
- *****************************************************************************/
-
-unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor_t * type)
-{
- unsigned long crc = aCrc;
- char * str = NULL, buf[16];
- int flag = 0, pos;
- field_t * fld;
-
- switch(type->type){
- case INT_FIXED:
- str = intOutputTypes[getSizeindex(type->size)];
- break;
- case UINT_FIXED:
- str = uintOutputTypes[getSizeindex(type->size)];
- break;
- case POINTER:
- str = allocAndCopy("void *");
- flag = 1;
- break;
- case CHAR:
- str = allocAndCopy("signed char");
- flag = 1;
- break;
- case UCHAR:
- str = allocAndCopy("unsigned char");
- flag = 1;
- break;
- case SHORT:
- str = allocAndCopy("short");
- flag = 1;
- break;
- case USHORT:
- str = allocAndCopy("unsigned short");
- flag = 1;
- break;
- case INT:
- str = allocAndCopy("int");
- flag = 1;
- break;
- case UINT:
- str = allocAndCopy("uint");
- flag = 1;
- break;
- case LONG:
- str = allocAndCopy("long");
- flag = 1;
- break;
- case ULONG:
- str = allocAndCopy("unsigned long");
- flag = 1;
- break;
- case SIZE_T:
- str = allocAndCopy("size_t");
- flag = 1;
- break;
- case SSIZE_T:
- str = allocAndCopy("ssize_t");
- flag = 1;
- break;
- case OFF_T:
- str = allocAndCopy("off_t");
- flag = 1;
- break;
- case FLOAT:
- str = floatOutputTypes[getSizeindex(type->size)];
- break;
- case STRING:
- str = allocAndCopy("string");
- flag = 1;
- break;
- case ENUM:
- //str = appendString("enum ", uintOutputTypes[getSizeindex(type->size)]);
- str = allocAndCopy("enum");
- flag = 1;
- break;
- case ARRAY:
- sprintf(buf,"%zu", type->size);
- str = appendString("array ",buf);
- flag = 1;
- break;
- case SEQUENCE:
- str = allocAndCopy("sequence ");
- flag = 1;
- break;
- case STRUCT:
- str = allocAndCopy("struct");
- flag = 1;
- break;
- case UNION:
- str = allocAndCopy("union");
- flag = 1;
- break;
- default:
- error_callback(NULL, "named type has no definition");
- break;
- }
-
- crc = partial_crc32(str,crc);
- if(flag) free(str);
-
- if(type->fmt) crc = partial_crc32(type->fmt,crc);
-
- if(type->type == ARRAY){
- crc = getTypeChecksum(crc,((field_t*)type->fields.array[0])->type);
- } else if(type->type ==SEQUENCE) {
- crc = getTypeChecksum(crc,((field_t*)type->fields.array[0])->type);
- crc = getTypeChecksum(crc,((field_t*)type->fields.array[1])->type);
- } else if(type->type == STRUCT || type->type == UNION){
- for(pos =0; pos < type->fields.position; pos++){
- fld = (field_t *) type->fields.array[pos];
- crc = partial_crc32(fld->name,crc);
- crc = getTypeChecksum(crc, fld->type);
- }
- }else if(type->type == ENUM){
- for(pos = 0; pos < type->labels.position; pos++)
- crc = partial_crc32((char*)type->labels.array[pos],crc);
- }
-
- return crc;
-}
-
-
-/* Event type descriptors */
-void freeType(type_descriptor_t * tp)
-{
- int pos2;
- field_t *f;
-
- if(tp->fmt != NULL) free(tp->fmt);
- if(tp->type == ENUM) {
- for(pos2 = 0; pos2 < tp->labels.position; pos2++) {
- free(tp->labels.array[pos2]);
- }
- sequence_dispose(&(tp->labels));
- for(pos2 = 0; pos2 < tp->labels_values.position; pos2++) {
- free(tp->labels_values.array[pos2]);
- }
- sequence_dispose(&(tp->labels_values));
- }
- if(tp->type == STRUCT) {
- for(pos2 = 0; pos2 < tp->fields.position; pos2++) {
- f = (field_t *) tp->fields.array[pos2];
- free(f->name);
- free(f->description);
- free(f);
- }
- sequence_dispose(&(tp->fields));
- }
-}
-
-void freeNamedType(table_t * t)
-{
- int pos;
- type_descriptor_t * td;
-
- for(pos = 0 ; pos < t->keys.position; pos++) {
- free((char *)t->keys.array[pos]);
- td = (type_descriptor_t*)t->values.array[pos];
- freeType(td);
- free(td);
- }
-}
-
-void freeTypes(sequence_t *t)
-{
- int pos;
- type_descriptor_t *tp;
-
- for(pos = 0 ; pos < t->position; pos++) {
- tp = (type_descriptor_t *)t->array[pos];
- freeType(tp);
- free(tp);
- }
-}
-
-void freeEvents(sequence_t *t)
-{
- int pos;
- event_t *ev;
-
- for(pos = 0 ; pos < t->position; pos++) {
- ev = (event_t *) t->array[pos];
- free(ev->name);
- free(ev->description);
- sequence_dispose(&ev->fields);
- free(ev);
- }
-
-}
-
-
-/* Extensible array */
-
-void sequence_init(sequence_t *t)
-{
- t->size = 10;
- t->position = 0;
- t->array = (void **)memAlloc(t->size * sizeof(void *));
-}
-
-void sequence_dispose(sequence_t *t)
-{
- t->size = 0;
- free(t->array);
- t->array = NULL;
-}
-
-void sequence_push(sequence_t *t, void *elem)
-{
- void **tmp;
-
- if(t->position >= t->size) {
- tmp = t->array;
- t->array = (void **)memAlloc(t->size * 2 * sizeof(void *));
- memcpy(t->array, tmp, t->size * sizeof(void *));
- t->size = t->size * 2;
- free(tmp);
- }
- t->array[t->position] = elem;
- t->position++;
-}
-
-void *sequence_pop(sequence_t *t)
-{
- if(t->position == 0) printf("Error : trying to pop an empty sequence");
- return t->array[--t->position];
-}
-
-
-/* Hash table API, implementation is just linear search for now */
-
-void table_init(table_t *t)
-{
- sequence_init(&(t->keys));
- sequence_init(&(t->values));
-}
-
-void table_dispose(table_t *t)
-{
- sequence_dispose(&(t->keys));
- sequence_dispose(&(t->values));
-}
-
-void table_insert(table_t *t, char *key, void *value)
-{
- sequence_push(&(t->keys),key);
- sequence_push(&(t->values),value);
-}
-
-void *table_find(table_t *t, char *key)
-{
- int pos;
- for(pos = 0 ; pos < t->keys.position; pos++) {
- if(strcmp((char *)key,(char *)t->keys.array[pos]) == 0)
- return(t->values.array[pos]);
- }
- return NULL;
-}
-
-void table_insert_int(table_t *t, int *key, void *value)
-{
- sequence_push(&(t->keys),key);
- sequence_push(&(t->values),value);
-}
-
-void *table_find_int(table_t *t, int *key)
-{
- int pos;
- for(pos = 0 ; pos < t->keys.position; pos++) {
- if(*key == *(int *)t->keys.array[pos])
- return(t->values.array[pos]);
- }
- return NULL;
-}
-
-
-/* Concatenate strings */
-
-char *appendString(char *s, char *suffix)
-{
- char *tmp;
- if(suffix == NULL) return s;
-
- tmp = (char *)memAlloc(strlen(s) + strlen(suffix) + 1);
- strcpy(tmp,s);
- strcat(tmp,suffix);
- return tmp;
-}
+++ /dev/null
-#ifndef PARSER_H
-#define PARSER_H
-
-/* Extensible array container */
-
-typedef struct _sequence {
- int size;
- int position;
- void **array;
-} sequence_t;
-
-void sequence_init(sequence_t *t);
-void sequence_dispose(sequence_t *t);
-void sequence_push(sequence_t *t, void *elem);
-void *sequence_pop(sequence_t *t);
-
-
-/* Hash table */
-
-typedef struct _table {
- sequence_t keys;
- sequence_t values;
-} table_t;
-
-void table_init(table_t *t);
-void table_dispose(table_t *t);
-void table_insert(table_t *t, char *key, void *value);
-void *table_find(table_t *t, char *key);
-void table_insert_int(table_t *t, int *key, void *value);
-void *table_find_int(table_t *t, int *key);
-
-
-/* Token types */
-
-typedef enum _token_type {
- ENDFILE,
- FORWARDSLASH,
- LANGLEBRACKET,
- RANGLEBRACKET,
- EQUAL,
- QUOTEDSTRING,
- NUMBER,
- NAME
-} token_type_t;
-
-
-/* State associated with a file being parsed */
-typedef struct _parse_file {
- char *name;
- FILE * fp;
- int lineno;
- char *buffer;
- token_type_t type;
- int unget;
- void (*error) (struct _parse_file *, char *);
-} parse_file_t;
-
-void ungetToken(parse_file_t * in);
-char *getToken(parse_file_t *in);
-char *getForwardslash(parse_file_t *in);
-char *getLAnglebracket(parse_file_t *in);
-char *getRAnglebracket(parse_file_t *in);
-char *getQuotedString(parse_file_t *in);
-char *getName(parse_file_t *in);
-int getNumber(parse_file_t *in);
-char *getEqual(parse_file_t *in);
-char seekNextChar(parse_file_t *in);
-
-void skipComment(parse_file_t * in);
-void skipEOL(parse_file_t * in);
-
-/* Some constants */
-
-static const int BUFFER_SIZE = 1024;
-
-
-/* Events data types */
-
-typedef enum _data_type {
- INT_FIXED,
- UINT_FIXED,
- POINTER,
- CHAR,
- UCHAR,
- SHORT,
- USHORT,
- INT,
- UINT,
- LONG,
- ULONG,
- SIZE_T,
- SSIZE_T,
- OFF_T,
- FLOAT,
- STRING,
- ENUM,
- ARRAY,
- SEQUENCE,
- STRUCT,
- UNION,
- NONE
-} data_type_t;
-
-typedef struct _type_descriptor {
- char * type_name; //used for named type
- data_type_t type;
- char *fmt;
- size_t size;
- sequence_t labels; // for enumeration
- sequence_t labels_values; // for enumeration
- sequence_t labels_description;
- int already_printed;
- sequence_t fields; // for structure, array and sequence (field_t type)
- int custom_write; /* Should we use a custom write function ? */
- int network; /* Is the type a in network byte order ? */
-} type_descriptor_t;
-
-
-
-/* Fields within types or events */
-typedef struct _field{
- char *name;
- char *description;
- type_descriptor_t *type;
-} field_t;
-
-
-/* Events definitions */
-
-typedef struct _event {
- char *name;
- char *description;
- //type_descriptor_t *type;
- sequence_t fields; /* event fields */
- int per_trace; /* Is the event able to be logged to a specific trace ? */
- int per_tracefile; /* Must we log this event in a specific tracefile ? */
- int param_buffer; /* For userspace tracing : takes a buffer as parameter? */
- int no_instrument_function;
-} event_t;
-
-typedef struct _facility {
- char * name;
- char * capname;
- char * arch;
- char * description;
- sequence_t events;
- sequence_t unnamed_types; //FIXME : remove
- table_t named_types;
- unsigned int checksum;
- int user; /* Is this a userspace facility ? */
-} facility_t;
-
-int getSizeindex(unsigned int value);
-unsigned long long int getSize(parse_file_t *in);
-unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor_t * type);
-
-void parseFacility(parse_file_t *in, facility_t * fac);
-void parseEvent(parse_file_t *in, event_t *ev, sequence_t * unnamed_types,
- table_t * named_types);
-void parseTypeDefinition(parse_file_t *in,
- sequence_t * unnamed_types, table_t * named_types);
-type_descriptor_t *parseType(parse_file_t *in,
- type_descriptor_t *t, sequence_t * unnamed_types, table_t * named_types);
-void parseFields(parse_file_t *in, field_t *f,
- sequence_t * unnamed_types,
- table_t * named_types,
- int tag);
-void checkNamedTypesImplemented(table_t * namedTypes);
-type_descriptor_t * find_named_type(char *name, table_t * named_types);
-void generateChecksum(char * facName,
- unsigned int * checksum, sequence_t * events);
-
-
-/* get attributes */
-char * getNameAttribute(parse_file_t *in);
-char * getFormatAttribute(parse_file_t *in);
-int getSizeAttribute(parse_file_t *in);
-int getValueAttribute(parse_file_t *in, long long *value);
-
-char * getDescription(parse_file_t *in);
-
-
-/* Dynamic memory allocation and freeing */
-
-void * memAlloc(int size);
-char *allocAndCopy(char * str);
-char *appendString(char *s, char *suffix);
-void freeTypes(sequence_t *t);
-void freeType(type_descriptor_t * td);
-void freeEvents(sequence_t *t);
-void freeNamedType(table_t * t);
-void error_callback(parse_file_t *in, char *msg);
-
-
-//checksum part
-static const unsigned int crctab32[] =
-{
-#include "crc32.tab"
-};
-
-static inline unsigned long
-partial_crc32_one(unsigned char c, unsigned long crc)
-{
- return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
-}
-
-static inline unsigned long
-partial_crc32(const char *s, unsigned long crc)
-{
- while (*s)
- crc = partial_crc32_one(*s++, crc);
- return crc;
-}
-
-static inline unsigned long
-crc32(const char *s)
-{
- return partial_crc32(s, 0xffffffff) ^ 0xffffffff;
-}
-
-
-extern char *intOutputTypes[];
-
-extern char *uintOutputTypes[];
-
-extern char *floatOutputTypes[];
-
-
-
-
-#endif // PARSER_H
+++ /dev/null
-<?xml version="1.0"?>
-<facility name="test">
- <description>The kernel facility has events related to kernel execution status.</description>
-
-
- <type name="tasklet_priority">
- <enum>
- <label name="LOW" value="0"> <description>Low priority tasklet</description>
- <label name="HIGH" value="1"> <description>High priority tasklet</description>
- </enum>
- </type>
-
- <type name="irq_mode">
- <enum>
- <label name="user" value="0"> <description>User context</description>
- <label name="kernel" value="1"> <description>Kernel context</description>
- </enum>
- </type>
-
- <type name="mystruct2">
- <struct>
- <field name="irq_id"> <description>IRQ number</description> <uint size="4"> </field>
- <field name="mode"> <description>Are we executing kernel code</description> <typeref name="irq_mode"> </field>
- </struct>
- </type>
-
- <type name="mystruct">
- <struct>
- <field name="irq_id"> <description>IRQ number</description> <uint size="4"> </field>
- <field name="mode"> <description>Are we executing kernel code</description> <typeref name="irq_mode"> </field>
-
- <field name="teststr"><typeref name="mystruct2"></field>
- <field name="myarray">
- <array size="10">
- <uint_fixed size="8">
- </array>
- </field>
- <field name="mysequence">
- <sequence>
- <uint>
- <float size="8">
- </sequence>
- </field>
- <field name="myunion">
- <union>
- <field name="myfloat"><float size="8"></field>
- <field name="myulong"><ulong></field>
- </union>
- </field>
- </struct>
- </type>
-
-
-
-
- <event name="syscall_entry">
- <description>System call entry</description>
- <field name="syscall_id"> <description>Syscall entry number in entry.S</description> <uint size="1"> </field>
- <field name="address"> <description>Address from which call was made</description> <pointer> </field>
- </event>
-
- <event name="syscall_exit">
- <description>System call exit</description>
- </event>
-
- <event name="trap_entry">
- <description>Entry in a trap</description>
- <field name="trap_id"> <description>Trap number</description> <uint size="2"> </field>
- <field name="address"> <description>Address where trap occured</description> <pointer> </field>
- </event>
-
- <event name="trap_exit">
- <description>Exit from a trap</description>
- </event>
-
- <event name="soft_irq_entry">
- <description>Soft IRQ entry</description>
- <field name="softirq_id"> <description>Soft IRQ number</description> <pointer> </field>
- </event>
-
- <event name="soft_irq_exit">
- <description>Soft IRQ exit</description>
- <field name="softirq_id"> <description>Soft IRQ number</description> <pointer> </field>
- </event>
-
- <event name="tasklet_entry">
- <description>Tasklet entry</description>
- <field name="priority"> <description>Tasklet priority</description> <typeref name="tasklet_priority"> </field>
- <field name="address"> <description>Tasklet function address</description> <pointer> </field>
- <field name="data"> <description>Tasklet data address</description> <ulong> </field>
- </event>
-
- <event name="tasklet_exit">
- <description>Tasklet exit</description>
- <field name="priority"> <description>Tasklet priority</description> <typeref name="tasklet_priority"> </field>
- <field name="address"> <description>Tasklet function address</description> <pointer> </field>
- <field name="data"> <description>Tasklet data address</description> <ulong> </field>
- </event>
-
- <event name="irq_entry">
- <description>Entry in an irq</description>
- <field name="irq_id"> <description>IRQ number</description> <uint size="4"> </field>
- <field name="mode"> <description>Are we executing kernel code</description><typeref name=""irq_mode""> </field>
- </event>
-
- <event name="irq_exit">
- <description>Exit from an IRQ</description>
- </event>
-
- <event name="big_array">
- <field name="myarray">
- <array size="10000">
- <array size="2">
- <struct>
- <field name="a"><pointer></field>
- <field name="b"><union>
- <field name="c"><pointer></field>
- </union>
- </field>
- </struct>
- </array>
- </array>
- </field>
- </event>
-
-</facility>
--- /dev/null
+SHELL = /bin/sh
+
+CC = gcc
+
+#CFLAGS = -std=c99 -Wall -g -DDEBUG
+CFLAGS = -std=c99 -Wall -g
+
+all: genevent
+
+install: genevent
+ cp -f genevent /usr/local/bin
+
+genevent: genevent.o parser.o
+ $(CC) $(CFLAGS) -o $@ $^
+
+genevent.o: genevent.c genevent.h parser.h
+ $(CC) $(CFLAGS) -c -o $@ $<
+
+parser.o: parser.c parser.h
+ $(CC) $(CFLAGS) -c -o $@ $<
+
+.PHONY: clean
+
+clean:
+ rm -rf *.o *~ *# genevent
+
+
--- /dev/null
+
+Mathieu Desnoyers -- November 2005
+
+This is a complete rework of genevent.
+
+The 'genevent' program parses event descriptions and generates
+the inline functions to record events in the kernel.
+
+There are several files in the directory:
+ genevent.c, genevent.h, crc32.tab, parser.c and parser.h
+
+In fact, crc32.tab, parser.c and parser.h are the same files as
+those in LTT library.
+
+Important notes :
+ * Do not put "-" symbols in facilities name.
+ * Use the exact same name for facility xml file and for facility name.
+ * As from genevent 0.17, a standard XML 1.0 description is "required". It must
+ begin with the <?xml version="1.0"?> header.
+
+Note about strings :
+There are three methods to write strings in genevent, each suitable and
+efficient for a particular case. They are explained here from the fastest
+to the slowest.
+1 - The C code presents a fixed size string.
+ For example, you find :
+ char mystring[10];
+ as string definition.
+
+ you must then define it as an array of char :
+ <array size="10"><char></array>
+
+ Note, however, that you might not want to declare a fixed size for trace size
+ and unnecessary copy matters.
+
+ For instance, on a 32 bits architecture, copying a n bytes array takes
+ approximately* n/4 memory read and write, for n/2 memory operations.
+
+ Using the slower method described in (3), with a strlen and memcpy, where
+ "u" is the number of used caracters, takes u+1 reads for the strlen, and
+ approximately* (u+1)/4 read and write for the memcpy, for a total of :
+ (3/2)*(u+1) memory access.
+
+ So, if (n/2) > (3/2)*(u+1), or : n > 3*u+3
+ where n is the size of the array
+ u is the average number of used caracters (excluding the \0)
+ it becomes faster to use the method number 3 with strlen.
+
+2 - The C code presents a variable size string together with its
+ size.
+
+ A typical use for this case is filenames in the Linux kernel. The
+ dentry strucure has a d_name member, which is a struct qstr containing
+ a unsigned int len and const unsigned char *name.
+
+ you must use a sequence to declare this efficiently :
+ <sequence><uint><char></sequence>
+
+3 - The C code presents a \0 terminated string.
+
+ This is the slowest, but most convenient way to declare a string. You are
+ discouraged to use it when options 1 or 2 are available. It will dynamically
+ calculate the string length (byte by byte read) and only afterward do a
+ memcpy.
+
+ Note that, as explained in 1, if n > 3*u+3, it becomes faster to use this
+ method instead of copying the whole fixed size array.
+
+ Declare like this :
+ <string>
+
+Here is a brief description of how to use genevent.
+
+make
+make install
+
+
+* Add new events to the kernel with genevent
+
+su -
+cd /usr/local/share/LinuxTraceToolkitViewer/facilities
+cp process.xml yourfacility.xml
+ * edit yourfacility.xml to fit your needs.
+cd /tmp
+/usr/local/bin/genevent /usr/local/share/LinuxTraceToolkitViewer/yourfacility.xml
+cp ltt-facility-yourfacility.h ltt-facility-id-yourfacility.h \
+ /usr/src/linux-2.6.12-rc4-mm2-lttng-0.2/include/linux/ltt
+cp ltt-facility-loader-yourfacility.c ltt-facility-loader-yourfacility.h \
+ /usr/src/linux-2.6.12-rc4-mm2-lttng-0.2/ltt
+ * edit the kernel file you want to instrument
+ - Add #include <linux/ltt/ltt-facility-yourfacility.h> at the beginning
+ of the file.
+ - Add a call to the tracing functions. See their names and parameters in
+ /usr/src/linux-2.6.12-rc4-mm2-lttng-0.2/include/linux/ltt/ltt-facility-yourfacility.h
+
+
+
+* The approximation comes from the fact that copies of number of caracters non
+ multiple of the architecture size takes more operations (maximum of :
+ (architecture size (in bytes) - 1) operations).
+
--- /dev/null
+ 0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U,
+ 0x706af48fU, 0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U,
+ 0xe0d5e91eU, 0x97d2d988U, 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U,
+ 0x90bf1d91U, 0x1db71064U, 0x6ab020f2U, 0xf3b97148U, 0x84be41deU,
+ 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U, 0x136c9856U,
+ 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U,
+ 0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U,
+ 0xa2677172U, 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU,
+ 0x35b5a8faU, 0x42b2986cU, 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U,
+ 0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U, 0x26d930acU, 0x51de003aU,
+ 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U, 0xcfba9599U,
+ 0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U,
+ 0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U,
+ 0x01db7106U, 0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU,
+ 0x9fbfe4a5U, 0xe8b8d433U, 0x7807c9a2U, 0x0f00f934U, 0x9609a88eU,
+ 0xe10e9818U, 0x7f6a0dbbU, 0x086d3d2dU, 0x91646c97U, 0xe6635c01U,
+ 0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U, 0xf262004eU, 0x6c0695edU,
+ 0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U, 0x12b7e950U,
+ 0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U,
+ 0xfbd44c65U, 0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U,
+ 0x4adfa541U, 0x3dd895d7U, 0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU,
+ 0x346ed9fcU, 0xad678846U, 0xda60b8d0U, 0x44042d73U, 0x33031de5U,
+ 0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU, 0x270241aaU, 0xbe0b1010U,
+ 0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U, 0xce61e49fU,
+ 0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U,
+ 0x2eb40d81U, 0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U,
+ 0x03b6e20cU, 0x74b1d29aU, 0xead54739U, 0x9dd277afU, 0x04db2615U,
+ 0x73dc1683U, 0xe3630b12U, 0x94643b84U, 0x0d6d6a3eU, 0x7a6a5aa8U,
+ 0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U, 0x7d079eb1U, 0xf00f9344U,
+ 0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU, 0x806567cbU,
+ 0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU,
+ 0x67dd4accU, 0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U,
+ 0xd6d6a3e8U, 0xa1d1937eU, 0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U,
+ 0xa6bc5767U, 0x3fb506ddU, 0x48b2364bU, 0xd80d2bdaU, 0xaf0a1b4cU,
+ 0x36034af6U, 0x41047a60U, 0xdf60efc3U, 0xa867df55U, 0x316e8eefU,
+ 0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U, 0x5268e236U,
+ 0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU,
+ 0xb2bd0b28U, 0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U,
+ 0x2cd99e8bU, 0x5bdeae1dU, 0x9b64c2b0U, 0xec63f226U, 0x756aa39cU,
+ 0x026d930aU, 0x9c0906a9U, 0xeb0e363fU, 0x72076785U, 0x05005713U,
+ 0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU, 0x0cb61b38U, 0x92d28e9bU,
+ 0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U, 0xf1d4e242U,
+ 0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U,
+ 0x18b74777U, 0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU,
+ 0x8f659effU, 0xf862ae69U, 0x616bffd3U, 0x166ccf45U, 0xa00ae278U,
+ 0xd70dd2eeU, 0x4e048354U, 0x3903b3c2U, 0xa7672661U, 0xd06016f7U,
+ 0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU, 0xd9d65adcU, 0x40df0b66U,
+ 0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU, 0x30b5ffe9U,
+ 0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U,
+ 0xcdd70693U, 0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U,
+ 0x5d681b02U, 0x2a6f2b94U, 0xb40bbe37U, 0xc30c8ea1U, 0x5a05df1bU,
+ 0x2d02ef8dU
--- /dev/null
+/******************************************************************************
+ * Genevent
+ *
+ * Event generator. XML to logging C code converter.
+ *
+ * Program parameters :
+ * ./genevent name.xml
+ *
+ * Will generate ltt-facility-name.h, ltt-facility-id-name.h
+ * ltt-facility-loader-name.c, ltt-facility-loader-name.h
+ * in the current directory.
+ *
+ * Supports :
+ * - C Alignment
+ * - C types : struct, union, enum, basic types.
+ * - Architectures : LP32, ILP32, ILP64, LLP64, LP64.
+ *
+ * Additionnal structures supported :
+ * - embedded variable size strings
+ * - embedded variable size arrays
+ * - embedded variable size sequences
+ *
+ * Notes :
+ * (1)
+ * enums are limited to integer type, as this is what is used in C. Note,
+ * however, that ISO/IEC 9899:TC2 specify that the type of enum can be char,
+ * unsigned int or int. This is implementation defined (compiler). That's why we
+ * add a check for sizeof enum.
+ *
+ * (2)
+ * Because of archtecture defined type sizes, we need to ask for ltt_align
+ * (which gives the alignment) by passing basic types, not their actual sizes.
+ * It's up to ltt_align to determine sizes of types.
+ *
+ * Note that, from
+ * http://www.usenix.org/publications/login/standards/10.data.html
+ * (Andrew Josey <a.josey@opengroup.org>) :
+ *
+ * Data Type LP32 ILP32 ILP64 LLP64 LP64
+ * char 8 8 8 8 8
+ * short 16 16 16 16 16
+ * int32 32
+ * int 16 32 64 32 32
+ * long 32 32 64 32 64
+ * long long (int64) 64
+ * pointer 32 32 64 64 64
+ *
+ * With these constraints :
+ * sizeof(char) <= sizeof(short) <= sizeof(int)
+ * <= sizeof(long) = sizeof(size_t)
+ *
+ * and therefore sizeof(long) <= sizeof(pointer) <= sizeof(size_t)
+ *
+ * Which means we only have to remember which is the biggest type in a structure
+ * to know the structure's alignment.
+ */
+
+#define _GNU_SOURCE
+#include <limits.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include "genevent.h"
+#include "parser.h"
+
+
+#define TRUE 1
+#define FALSE (!TRUE)
+
+/* Debugging printf */
+#ifdef DEBUG
+#define dprintf(...) \
+ do {\
+ printf(__FILE__ ",%u,%s: ",\
+ __LINE__, __func__);\
+ printf(__VA_ARGS__);\
+ } while(0)
+#else
+#define dprintf(...)
+#endif
+
+/* Code printing */
+
+void print_tabs(unsigned int tabs, FILE *fd)
+{
+ for(unsigned int i = 0; i<tabs;i++)
+ fprintf(fd, "\t");
+}
+
+/* print type.
+ *
+ * Copied from construct_types_and_fields in LTTV facility.c */
+
+int print_type(type_descriptor_t * td, FILE *fd, unsigned int tabs,
+ char *nest_name, char *field_name)
+{
+ char basename[PATH_MAX];
+ unsigned int basename_len = 0;
+
+ strcpy(basename, nest_name);
+ basename_len = strlen(basename);
+
+ /* For a named type, we use the type_name directly */
+ if(td->type_name != NULL) {
+ strncpy(basename, td->type_name, PATH_MAX);
+ basename_len = strlen(basename);
+ } else {
+ /* For a unnamed type, there must be a field name */
+ if((basename_len != 0)
+ && (basename[basename_len-1] != '_')
+ && (field_name[0] != '\0')) {
+ strncat(basename, "_", PATH_MAX - basename_len);
+ basename_len = strlen(basename);
+ }
+ strncat(basename, field_name, PATH_MAX - basename_len);
+ }
+
+ switch(td->type) {
+ case INT_FIXED:
+ fprintf(fd, "%s", intOutputTypes[getSizeindex(td->size)]);
+ break;
+ case UINT_FIXED:
+ fprintf(fd, "%s", uintOutputTypes[getSizeindex(td->size)]);
+ break;
+ case CHAR:
+ fprintf(fd, "signed char");
+ break;
+ case UCHAR:
+ fprintf(fd, "unsigned char");
+ break;
+ case SHORT:
+ fprintf(fd, "short");
+ break;
+ case USHORT:
+ fprintf(fd, "unsigned short");
+ break;
+ case INT:
+ fprintf(fd, "int");
+ break;
+ case UINT:
+ fprintf(fd, "unsigned int");
+ break;
+ case FLOAT:
+ fprintf(fd, "%s", floatOutputTypes[getSizeindex(td->size)]);
+ break;
+ case POINTER:
+ fprintf(fd, "const void *");
+ break;
+ case LONG:
+ fprintf(fd, "long");
+ break;
+ case ULONG:
+ fprintf(fd, "unsigned long");
+ break;
+ case SIZE_T:
+ fprintf(fd, "size_t");
+ break;
+ case SSIZE_T:
+ fprintf(fd, "ssize_t");
+ break;
+ case OFF_T:
+ fprintf(fd, "off_t");
+ break;
+ case STRING:
+ fprintf(fd, "const char *");
+ break;
+ case ENUM:
+ fprintf(fd, "enum lttng_%s", basename);
+ break;
+ case ARRAY:
+ fprintf(fd, "lttng_array_%s", basename);
+ break;
+ case SEQUENCE:
+ fprintf(fd, "lttng_sequence_%s", basename);
+ break;
+ case STRUCT:
+ fprintf(fd, "struct lttng_%s", basename);
+ break;
+ case UNION:
+ fprintf(fd, "union lttng_%s", basename);
+ break;
+ default:
+ printf("print_type : unknown type\n");
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Print logging function argument */
+int print_arg(type_descriptor_t * td, FILE *fd, unsigned int tabs,
+ char *nest_name, char *field_name)
+{
+ char basename[PATH_MAX];
+ unsigned int basename_len = 0;
+
+ strcpy(basename, nest_name);
+ basename_len = strlen(basename);
+
+ /* For a named type, we use the type_name directly */
+ if(td->type_name != NULL) {
+ strncpy(basename, td->type_name, PATH_MAX);
+ basename_len = strlen(basename);
+ } else {
+ /* For a unnamed type, there must be a field name */
+ if((basename_len != 0)
+ && (basename[basename_len-1] != '_')
+ && (field_name[0] != '\0')) {
+ strncat(basename, "_", PATH_MAX - basename_len);
+ basename_len = strlen(basename);
+ }
+ strncat(basename, field_name, PATH_MAX - basename_len);
+ }
+
+ print_tabs(tabs, fd);
+
+ switch(td->type) {
+ case INT_FIXED:
+ fprintf(fd, "%s", intOutputTypes[getSizeindex(td->size)]);
+ fprintf(fd, "lttng_param_%s", field_name);
+ break;
+ case UINT_FIXED:
+ fprintf(fd, "%s", uintOutputTypes[getSizeindex(td->size)]);
+ fprintf(fd, "lttng_param_%s", field_name);
+ break;
+ case CHAR:
+ fprintf(fd, "signed char");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case UCHAR:
+ fprintf(fd, "unsigned char");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case SHORT:
+ fprintf(fd, "short");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case USHORT:
+ fprintf(fd, "unsigned short");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case INT:
+ fprintf(fd, "int");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case UINT:
+ fprintf(fd, "unsigned int");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case FLOAT:
+ fprintf(fd, "%s", floatOutputTypes[getSizeindex(td->size)]);
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case POINTER:
+ fprintf(fd, "const void *");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case LONG:
+ fprintf(fd, "long");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case ULONG:
+ fprintf(fd, "unsigned long");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case SIZE_T:
+ fprintf(fd, "size_t");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case SSIZE_T:
+ fprintf(fd, "ssize_t");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case OFF_T:
+ fprintf(fd, "off_t");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case STRING:
+ fprintf(fd, "const char *");
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case ENUM:
+ fprintf(fd, "enum lttng_%s", basename);
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case ARRAY:
+ fprintf(fd, "lttng_array_%s", basename);
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case SEQUENCE:
+ fprintf(fd, "lttng_sequence_%s *", basename);
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case STRUCT:
+ fprintf(fd, "struct lttng_%s *", basename);
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ case UNION:
+ fprintf(fd, "union lttng_%s *", basename);
+ fprintf(fd, " lttng_param_%s", field_name);
+ break;
+ default:
+ printf("print_type : unknown type\n");
+ return 1;
+ }
+
+ return 0;
+}
+
+
+/* Does the type has a fixed size ? (as know from the compiler)
+ *
+ * 1 : fixed size
+ * 0 : variable length
+ */
+int has_type_fixed_size(type_descriptor_t *td)
+{
+ switch(td->type) {
+ case INT_FIXED:
+ case UINT_FIXED:
+ case CHAR:
+ case UCHAR:
+ case SHORT:
+ case USHORT:
+ case INT:
+ case UINT:
+ case FLOAT:
+ case POINTER:
+ case LONG:
+ case ULONG:
+ case SIZE_T:
+ case SSIZE_T:
+ case OFF_T:
+ case ENUM:
+ case UNION: /* The union must have fixed size children. Must be checked by
+ the parser */
+ return 1;
+ break;
+ case STRING:
+ case SEQUENCE:
+ return 0;
+ break;
+ case STRUCT:
+ {
+ int has_type_fixed = 0;
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+
+ has_type_fixed = has_type_fixed_size(type);
+ if(!has_type_fixed) return 0;
+ }
+ return 1;
+ }
+ break;
+ case ARRAY:
+ assert(td->size >= 0);
+ return has_type_fixed_size(((field_t*)td->fields.array[0])->type);
+ break;
+ case NONE:
+ printf("There is a type defined to NONE : bad.\n");
+ assert(0);
+ break;
+ }
+ return 0; //make gcc happy.
+}
+
+
+
+
+
+/* print type declaration.
+ *
+ * Copied from construct_types_and_fields in LTTV facility.c */
+
+int print_type_declaration(type_descriptor_t * td, FILE *fd, unsigned int tabs,
+ char *nest_name, char *field_name)
+{
+ char basename[PATH_MAX];
+ unsigned int basename_len = 0;
+
+ if(td->custom_write) return 0; /* Does print custom type */
+
+ strncpy(basename, nest_name, PATH_MAX);
+ basename_len = strlen(basename);
+
+ /* For a named type, we use the type_name directly */
+ if(td->type_name != NULL) {
+ strncpy(basename, td->type_name, PATH_MAX);
+ basename_len = strlen(basename);
+ } else {
+ /* For a unnamed type, there must be a field name, except for
+ * the array. */
+ if((basename_len != 0)
+ && (basename[basename_len-1] != '_'
+ && (field_name[0] != '\0'))) {
+ strncat(basename, "_", PATH_MAX - basename_len);
+ basename_len = strlen(basename);
+ }
+ strncat(basename, field_name, PATH_MAX - basename_len);
+ }
+
+ switch(td->type) {
+ case ENUM:
+ fprintf(fd, "enum lttng_%s", basename);
+ fprintf(fd, " {\n");
+ for(unsigned int i=0;i<td->labels.position;i++){
+ print_tabs(1, fd);
+ fprintf(fd, "LTTNG_%s = %d", ((char*)td->labels.array[i]),
+ (*(int*)td->labels_values.array[i]));
+ fprintf(fd, ",\n");
+ }
+ fprintf(fd, "};\n");
+ fprintf(fd, "\n");
+ break;
+
+ case ARRAY:
+ dprintf("%s\n", basename);
+ assert(td->size >= 0);
+ if(((field_t*)td->fields.array[0])->type->type_name == NULL) {
+ /* Not a named nested type : we must print its declaration first */
+ if(print_type_declaration(((field_t*)td->fields.array[0])->type,
+ fd, 0, basename, "")) return 1;
+ }
+ fprintf(fd, "#define LTTNG_ARRAY_SIZE_%s %zu\n", basename,
+ td->size);
+ fprintf(fd, "typedef ");
+ if(print_type(((field_t*)td->fields.array[0])->type,
+ fd, tabs, basename, "")) return 1;
+ fprintf(fd, " lttng_array_%s[LTTNG_ARRAY_SIZE_%s];\n", basename,
+ basename);
+ fprintf(fd, "\n");
+ break;
+ case SEQUENCE:
+ /* We assume that the sequence length type does not need to be declared.
+ */
+ if(((field_t*)td->fields.array[1])->type->type_name == NULL) {
+ /* Not a named nested type : we must print its declaration first */
+ if(print_type_declaration(((field_t*)td->fields.array[1])->type,
+ fd, 0, basename, "")) return 1;
+ }
+ fprintf(fd, "typedef struct lttng_sequence_%s lttng_sequence_%s;\n",
+ basename,
+ basename);
+ fprintf(fd, "struct lttng_sequence_%s", basename);
+ fprintf(fd, " {\n");
+ print_tabs(1, fd);
+ if(print_type(((field_t*)td->fields.array[0])->type,
+ fd, tabs, basename, "")) return 1;
+ fprintf(fd, " len;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "const ");
+ if(print_type(((field_t*)td->fields.array[1])->type,
+ fd, tabs, basename, "")) return 1;
+ fprintf(fd, " *array;\n");
+ fprintf(fd, "};\n"); /* We do not LTT_ALIGN, because we never copy
+ it to the buffer directly. */
+ fprintf(fd, "\n");
+ break;
+
+ case STRUCT:
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ if(type->type_name == NULL) {
+ /* Not a named nested type : we must print its declaration first */
+ if(print_type_declaration(type,
+ fd, 0, basename, field->name)) return 1;
+ }
+ }
+ fprintf(fd, "struct lttng_%s", basename);
+ fprintf(fd, " {\n");
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ print_tabs(1, fd);
+ if(print_type(type, fd, tabs, basename, field->name)) return 1;
+ fprintf(fd, " ");
+ fprintf(fd, "%s", field->name);
+ fprintf(fd, ";\n");
+ }
+ fprintf(fd, "} LTT_ALIGN;\n");
+ fprintf(fd, "\n");
+ break;
+ case UNION:
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ if(type->type_name == NULL) {
+ /* Not a named nested type : we must print its declaration first */
+ if(print_type_declaration(type,
+ fd, 0, basename, field->name)) return 1;
+ }
+ }
+ fprintf(fd, "union lttng_%s", basename);
+ fprintf(fd, " {\n");
+ for(unsigned i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ print_tabs(1, fd);
+ if(print_type(type, fd, tabs, basename, field->name)) return 1;
+ fprintf(fd, " ");
+ fprintf(fd, "%s", field->name);
+ fprintf(fd, ";\n");
+ }
+ fprintf(fd, "} LTT_ALIGN;\n");
+ fprintf(fd, "\n");
+ break;
+ default:
+ dprintf("print_type_declaration : unknown type or nothing to declare.\n");
+ break;
+ }
+
+ return 0;
+}
+
+
+/* print type alignment.
+ *
+ * Copied from construct_types_and_fields in LTTV facility.c
+ *
+ * basename is the name which identifies the type (along with a prefix
+ * (possibly)). */
+
+int print_type_alignment(type_descriptor_t * td, FILE *fd, unsigned int tabs,
+ char *nest_name, char *field_name, char *obj_prefix)
+{
+ char basename[PATH_MAX];
+ unsigned int basename_len = 0;
+
+ strncpy(basename, nest_name, PATH_MAX);
+ basename_len = strlen(basename);
+
+ /* For a named type, we use the type_name directly */
+ if(td->type_name != NULL) {
+ strncpy(basename, td->type_name, PATH_MAX);
+ basename_len = strlen(basename);
+ } else {
+ /* For a unnamed type, there must be a field name, except for
+ * the array. */
+ if((basename_len != 0)
+ && (basename[basename_len-1] != '_'
+ && field_name != NULL
+ && (field_name[0] != '\0'))) {
+ strncat(basename, "_", PATH_MAX - basename_len);
+ basename_len = strlen(basename);
+ }
+ if(field_name != NULL)
+ strncat(basename, field_name, PATH_MAX - basename_len);
+ }
+
+ if(field_name[0] == '\0') {
+ /* We are in a write function : it's the obj that we must align. */
+ switch(td->type) {
+ case SEQUENCE:
+ fprintf(fd, "lttng_get_alignment_sequence_%s(%s)", basename,
+ obj_prefix);
+ break;
+ case STRUCT:
+ fprintf(fd, "lttng_get_alignment_struct_%s(%s)", basename,
+ obj_prefix);
+ break;
+ case UNION:
+ fprintf(fd, "lttng_get_alignment_union_%s(%s)", basename,
+ obj_prefix);
+ break;
+ case ARRAY:
+ fprintf(fd, "lttng_get_alignment_array_%s(%s)", basename,
+ obj_prefix);
+ case STRING:
+ fprintf(fd, "sizeof(char)");
+ break;
+ case INT_FIXED:
+ case UINT_FIXED:
+ case CHAR:
+ case UCHAR:
+ case SHORT:
+ case USHORT:
+ case INT:
+ case UINT:
+ case FLOAT:
+ case POINTER:
+ case LONG:
+ case ULONG:
+ case SIZE_T:
+ case SSIZE_T:
+ case OFF_T:
+ case ENUM:
+ fprintf(fd, "sizeof(");
+ if(print_type(td, fd, 0, basename, "")) return 1;
+ fprintf(fd, ")");
+ break;
+
+ default:
+ printf("error : type unexpected\n");
+ return 1;
+ break;
+ }
+ } else {
+
+ switch(td->type) {
+ case INT_FIXED:
+ case UINT_FIXED:
+ case CHAR:
+ case UCHAR:
+ case SHORT:
+ case USHORT:
+ case INT:
+ case UINT:
+ case FLOAT:
+ case POINTER:
+ case LONG:
+ case ULONG:
+ case SIZE_T:
+ case SSIZE_T:
+ case OFF_T:
+ case ENUM:
+ fprintf(fd, "sizeof(");
+ if(print_type(td, fd, 0, basename, "")) return 1;
+ fprintf(fd, ")");
+ break;
+ case STRING:
+ fprintf(fd, "sizeof(char)");
+ break;
+ case SEQUENCE:
+ fprintf(fd, "lttng_get_alignment_sequence_%s(&%s%s)", basename,
+ obj_prefix, field_name);
+ break;
+ case STRUCT:
+ fprintf(fd, "lttng_get_alignment_struct_%s(&%s%s)", basename,
+ obj_prefix, field_name);
+ break;
+ case UNION:
+ fprintf(fd, "lttng_get_alignment_union_%s(&%s%s)", basename,
+ obj_prefix, field_name);
+ break;
+ case ARRAY:
+ fprintf(fd, "lttng_get_alignment_array_%s(%s%s)", basename,
+ obj_prefix, field_name);
+ break;
+ case NONE:
+ printf("error : type NONE unexpected\n");
+ return 1;
+ break;
+ }
+ }
+
+ return 0;
+}
+
+/* print type write.
+ *
+ * Copied from construct_types_and_fields in LTTV facility.c
+ *
+ * basename is the name which identifies the type (along with a prefix
+ * (possibly)). */
+
+int print_type_write(type_descriptor_t * td, FILE *fd, unsigned int tabs,
+ char *nest_name, char *field_name, char *obj_prefix, int get_ptr)
+{
+ char basename[PATH_MAX];
+ unsigned int basename_len = 0;
+ char get_ptr_char[2] = "";
+ char custom[PATH_MAX] = "";
+
+ strncpy(basename, nest_name, PATH_MAX);
+ basename_len = strlen(basename);
+
+ /* For a named type, we use the type_name directly */
+ if(td->type_name != NULL) {
+ strncpy(basename, td->type_name, PATH_MAX);
+ basename_len = strlen(basename);
+ } else {
+ /* For a unnamed type, there must be a field name, except for
+ * the array. */
+ if((basename_len != 0)
+ && (basename[basename_len-1] != '_'
+ && (field_name[0] != '\0'))) {
+ strncat(basename, "_", PATH_MAX - basename_len);
+ basename_len = strlen(basename);
+ }
+ strncat(basename, field_name, PATH_MAX - basename_len);
+ }
+
+ if(get_ptr) {
+ strcpy(get_ptr_char, "&");
+ }
+
+ if(td->custom_write) {
+ strcpy(custom, "_custom");
+ }
+
+ switch(td->type) {
+ case INT_FIXED:
+ case UINT_FIXED:
+ case CHAR:
+ case UCHAR:
+ case SHORT:
+ case USHORT:
+ case INT:
+ case UINT:
+ case FLOAT:
+ case POINTER:
+ case LONG:
+ case ULONG:
+ case SIZE_T:
+ case SSIZE_T:
+ case OFF_T:
+ case ENUM:
+ print_tabs(tabs, fd);
+ fprintf(fd, "align = ");
+ if(print_type_alignment(td, fd, 0, basename, "", "obj")) return 1;
+ fprintf(fd, ";\n");
+ fprintf(fd, "\n");
+ print_tabs(tabs, fd);
+ fprintf(fd, "if(*len == 0) {\n");
+ print_tabs(tabs+1, fd);
+ fprintf(fd, "*to += ltt_align(*to, align); /* align output */\n");
+ print_tabs(tabs, fd);
+ fprintf(fd, "} else {\n");
+ print_tabs(tabs+1, fd);
+ fprintf(fd, "*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */\n");
+ print_tabs(tabs, fd);
+ fprintf(fd, "}\n");
+ fprintf(fd, "\n");
+
+ print_tabs(tabs, fd);
+ fprintf(fd, "*len += ");
+ fprintf(fd, "sizeof(");
+ if(print_type(td, fd, 0, basename, "")) return 1;
+ fprintf(fd, ");\n");
+
+ break;
+ case STRING:
+ print_tabs(tabs, fd);
+ fprintf(fd,
+ "lttng_write%s_string_%s(buffer, to_base, to, from, len, %s%s);\n",
+ custom, basename, obj_prefix, field_name);
+ break;
+ case SEQUENCE:
+ print_tabs(tabs, fd);
+ fprintf(fd,
+ "lttng_write%s_sequence_%s(buffer, to_base, to, from, len, %s%s%s);",
+ custom, basename, get_ptr_char, obj_prefix, field_name);
+ break;
+ case STRUCT:
+ print_tabs(tabs, fd);
+ fprintf(fd,
+ "lttng_write%s_struct_%s(buffer, to_base, to, from, len, %s%s%s);",
+ custom, basename, get_ptr_char, obj_prefix, field_name);
+ break;
+ case UNION:
+ print_tabs(tabs, fd);
+ fprintf(fd,
+ "lttng_write%s_union_%s(buffer, to_base, to, from, len, %s%s%s);",
+ custom, basename, get_ptr_char, obj_prefix, field_name);
+ break;
+ case ARRAY:
+ print_tabs(tabs, fd);
+ fprintf(fd,
+ "lttng_write%s_array_%s(buffer, to_base, to, from, len, %s%s);",
+ custom, basename, obj_prefix, field_name);
+ break;
+ case NONE:
+ printf("Error : type NONE unexpected\n");
+ return 1;
+ break;
+ }
+
+ return 0;
+}
+
+/* print need local vars ?.
+ *
+ * Copied from print_type_write
+ *
+ * Does the type_write call needs local size and from variables ?
+ * return value : 1 yes, 0 no.
+ */
+
+int has_type_local(type_descriptor_t * td)
+{
+ switch(td->type) {
+ case INT_FIXED:
+ case UINT_FIXED:
+ case CHAR:
+ case UCHAR:
+ case SHORT:
+ case USHORT:
+ case INT:
+ case UINT:
+ case FLOAT:
+ case POINTER:
+ case LONG:
+ case ULONG:
+ case SIZE_T:
+ case SSIZE_T:
+ case OFF_T:
+ case ENUM:
+ return 1;
+ break;
+ case STRING:
+ case SEQUENCE:
+ case STRUCT:
+ case UNION:
+ case ARRAY:
+ return 0;
+ break;
+ case NONE:
+ printf("Error : type NONE unexpected\n");
+ return 1;
+ break;
+ }
+
+ return 0;
+}
+
+
+
+/* print type alignment function.
+ *
+ * Copied from construct_types_and_fields in LTTV facility.c
+ *
+ * basename is the name which identifies the type (along with a prefix
+ * (possibly)). */
+
+int print_type_alignment_fct(type_descriptor_t * td, FILE *fd,
+ unsigned int tabs,
+ char *nest_name, char *field_name)
+{
+ char basename[PATH_MAX];
+ unsigned int basename_len = 0;
+
+ if(td->custom_write) return 0; /* Does print custom type */
+
+ strncpy(basename, nest_name, PATH_MAX);
+ basename_len = strlen(basename);
+
+ /* For a named type, we use the type_name directly */
+ if(td->type_name != NULL) {
+ strncpy(basename, td->type_name, PATH_MAX);
+ basename_len = strlen(basename);
+ } else {
+ /* For a unnamed type, there must be a field name, except for
+ * the array. */
+ if((basename_len != 0)
+ && (basename[basename_len-1] != '_'
+ && (field_name[0] != '\0'))) {
+ strncat(basename, "_", PATH_MAX - basename_len);
+ basename_len = strlen(basename);
+ }
+ strncat(basename, field_name, PATH_MAX - basename_len);
+ }
+
+ switch(td->type) {
+ case SEQUENCE:
+ if(((field_t*)td->fields.array[1])->type->type_name == NULL) {
+ /* Not a named nested type : we must print its align fct */
+ if(print_type_alignment_fct(((field_t*)td->fields.array[1])->type, fd,
+ 0, basename, "")) return 1;
+ }
+ /* Function header */
+ fprintf(fd, "static inline size_t lttng_get_alignment_sequence_%s(\n",
+ basename);
+ print_tabs(2, fd);
+ if(print_type(td, fd, 0, basename, "")) return 1;
+ fprintf(fd, " *obj)\n");
+ fprintf(fd, "{\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t align=0, localign;");
+ fprintf(fd, "\n");
+ print_tabs(1, fd);
+ fprintf(fd, "localign = ");
+ if(print_type_alignment(((field_t*)td->fields.array[0])->type,
+ fd, 0, basename, "len", "obj->")) return 1;
+ fprintf(fd, ";\n");
+ print_tabs(1, fd);
+ fprintf(fd, "align = max(align, localign);\n");
+ fprintf(fd, "\n");
+ print_tabs(1, fd);
+ fprintf(fd, "localign = ");
+ if(print_type_alignment(((field_t*)td->fields.array[1])->type,
+ fd, 0, basename, "array[0]", "obj->")) return 1;
+ fprintf(fd, ";\n");
+ print_tabs(1, fd);
+ fprintf(fd, "align = max(align, localign);\n");
+ fprintf(fd, "\n");
+ print_tabs(1, fd);
+ fprintf(fd, "return align;\n");
+ break;
+ case STRUCT:
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ if(type->type_name == NULL) {
+ /* Not a named nested type : we must print its align fct */
+ if(print_type_alignment_fct(type, fd,
+ 0, basename, field->name)) return 1;
+ }
+ }
+ /* Function header */
+ fprintf(fd, "static inline size_t lttng_get_alignment_struct_%s(\n",
+ basename);
+ print_tabs(2, fd);
+ if(print_type(td, fd, 0, basename, "")) return 1;
+ fprintf(fd, " *obj)\n");
+ fprintf(fd, "{\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t align=0, localign;");
+ fprintf(fd, "\n");
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ print_tabs(1, fd);
+ fprintf(fd, "localign = ");
+ if(print_type_alignment(type, fd, 0, basename, field->name, "obj->"))
+ return 1;
+ fprintf(fd, ";\n");
+ print_tabs(1, fd);
+ fprintf(fd, "align = max(align, localign);\n");
+ fprintf(fd, "\n");
+ }
+ print_tabs(1, fd);
+ fprintf(fd, "return align;\n");
+
+ break;
+ case UNION:
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ if(type->type_name == NULL) {
+ /* Not a named nested type : we must print its align fct */
+ if(print_type_alignment_fct(type, fd,
+ 0, basename, field->name)) return 1;
+ }
+ }
+ /* Function header */
+ fprintf(fd, "static inline size_t lttng_get_alignment_union_%s(\n",
+ basename);
+ print_tabs(2, fd);
+ if(print_type(td, fd, 0, basename, "")) return 1;
+ fprintf(fd, " *obj)\n");
+ fprintf(fd, "{\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t align=0, localign;");
+ fprintf(fd, "\n");
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ print_tabs(1, fd);
+ fprintf(fd, "localign = ");
+ if(print_type_alignment(type, fd, 0, basename, field->name, "obj->"))
+ return 1;
+ fprintf(fd, ";\n");
+ print_tabs(1, fd);
+ fprintf(fd, "align = max(align, localign);\n");
+ fprintf(fd, "\n");
+ }
+ print_tabs(1, fd);
+ fprintf(fd, "return align;\n");
+
+ break;
+ case ARRAY:
+ if(((field_t*)td->fields.array[0])->type->type_name == NULL) {
+ /* Not a named nested type : we must print its align fct */
+ if(print_type_alignment_fct(((field_t*)td->fields.array[0])->type, fd,
+ 0, basename, "")) return 1;
+ }
+ /* Function header */
+ fprintf(fd, "static inline size_t lttng_get_alignment_array_%s(\n",
+ basename);
+ print_tabs(2, fd);
+ if(print_type(td, fd, 0, basename, "")) return 1;
+ fprintf(fd, " obj)\n");
+ fprintf(fd, "{\n");
+ print_tabs(1, fd);
+ fprintf(fd, "return \n");
+ if(print_type_alignment(((field_t*)td->fields.array[0])->type,
+ fd, 0, basename, "", "obj[0]"))
+ return 1;
+ fprintf(fd, ";\n");
+ break;
+ default:
+ dprintf("print_type_alignment_fct : type has no alignment function.\n");
+ return 0;
+ break;
+ }
+
+
+ /* Function footer */
+ fprintf(fd, "}\n");
+ fprintf(fd, "\n");
+
+ return 0;
+}
+
+/* print type write function.
+ *
+ * Copied from construct_types_and_fields in LTTV facility.c
+ *
+ * basename is the name which identifies the type (along with a prefix
+ * (possibly)). */
+
+int print_type_write_fct(type_descriptor_t * td, FILE *fd, unsigned int tabs,
+ char *nest_name, char *field_name)
+{
+ char basename[PATH_MAX];
+ unsigned int basename_len = 0;
+
+ if(td->custom_write) return 0; /* Does print custom type */
+
+ strncpy(basename, nest_name, PATH_MAX);
+ basename_len = strlen(basename);
+
+ /* For a named type, we use the type_name directly */
+ if(td->type_name != NULL) {
+ strncpy(basename, td->type_name, PATH_MAX);
+ basename_len = strlen(basename);
+ } else {
+ /* For a unnamed type, there must be a field name, except for
+ * the array. */
+ if((basename_len != 0)
+ && (basename[basename_len-1] != '_'
+ && (field_name[0] != '\0'))) {
+ strncat(basename, "_", PATH_MAX - basename_len);
+ basename_len = strlen(basename);
+ }
+ strncat(basename, field_name, PATH_MAX - basename_len);
+ }
+
+ switch(td->type) {
+ case SEQUENCE:
+ if(((field_t*)td->fields.array[1])->type->type_name == NULL) {
+ /* Not a named nested type : we must print its write fct */
+ if(print_type_write_fct(((field_t*)td->fields.array[1])->type, fd,
+ 0, basename, "")) return 1;
+ }
+ break;
+ case STRUCT:
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ if(type->type_name == NULL) {
+ /* Not a named nested type : we must print its write fct */
+ if(print_type_write_fct(type, fd,
+ 0, basename, field->name)) return 1;
+ }
+ }
+ break;
+ case UNION:
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ if(type->type_name == NULL) {
+ /* Not a named nested type : we must print its write fct */
+ if(print_type_write_fct(type, fd,
+ 0, basename, field->name)) return 1;
+ }
+ }
+ break;
+ case ARRAY:
+ if(((field_t*)td->fields.array[0])->type->type_name == NULL) {
+ /* Not a named nested type : we must print its write fct */
+ if(print_type_write_fct(((field_t*)td->fields.array[0])->type, fd,
+ 0, basename, "")) return 1;
+ }
+ break;
+ case STRING:
+ break;
+ default:
+ dprintf("print_type_write_fct : type has no write function.\n");
+ return 0;
+ break;
+ }
+
+ /* Print header */
+ switch(td->type) {
+ case SEQUENCE:
+ fprintf(fd, "static inline void lttng_write_sequence_%s(\n",
+ basename);
+ break;
+ case STRUCT:
+ fprintf(fd, "static inline void lttng_write_struct_%s(\n", basename);
+ break;
+ case UNION:
+ fprintf(fd, "static inline void lttng_write_union_%s(\n", basename);
+ break;
+ case ARRAY:
+ fprintf(fd, "static inline void lttng_write_array_%s(\n", basename);
+ break;
+ case STRING:
+ fprintf(fd, "static inline void lttng_write_string_%s(\n", basename);
+ break;
+ default:
+ printf("print_type_write_fct : type has no write function.\n");
+ break;
+ }
+
+ print_tabs(2, fd);
+ fprintf(fd, "void *buffer,\n");
+ print_tabs(2, fd);
+ fprintf(fd, "size_t *to_base,\n");
+ print_tabs(2, fd);
+ fprintf(fd, "size_t *to,\n");
+ print_tabs(2, fd);
+ fprintf(fd, "const void **from,\n");
+ print_tabs(2, fd);
+ fprintf(fd, "size_t *len,\n");
+ print_tabs(2, fd);
+ if(print_type(td, fd, 0, basename, "")) return 1;
+
+ switch(td->type) {
+ case SEQUENCE:
+ fprintf(fd, " *obj)\n");
+ break;
+ case STRUCT:
+ fprintf(fd, " *obj)\n");
+ break;
+ case UNION:
+ fprintf(fd, " *obj)\n");
+ break;
+ case ARRAY:
+ fprintf(fd, " obj)\n");
+ break;
+ case STRING:
+ fprintf(fd, " obj)\n");
+ break;
+ default:
+ printf("print_type_write_fct : type has no write function.\n");
+ break;
+ }
+
+ fprintf(fd, "{\n");
+
+ switch(td->type) {
+ case STRING:
+ print_tabs(1, fd);
+ fprintf(fd, "size_t size;\n");
+ break;
+ default:
+ break;
+ }
+
+ print_tabs(1, fd);
+ fprintf(fd, "size_t align;\n");
+ fprintf(fd, "\n");
+
+ switch(td->type) {
+ case SEQUENCE:
+ case STRING:
+ print_tabs(1, fd);
+ fprintf(fd, "/* Flush pending memcpy */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "if(*len != 0) {\n");
+ print_tabs(2, fd);
+ fprintf(fd, "if(buffer != NULL)\n");
+ print_tabs(3, fd);
+ fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
+ print_tabs(1, fd);
+ fprintf(fd, "}\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*to += *len;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*len = 0;\n");
+ fprintf(fd, "\n");
+ break;
+ case STRUCT:
+ case UNION:
+ case ARRAY:
+ break;
+ default:
+ printf("print_type_write_fct : type has no write function.\n");
+ break;
+ }
+
+ print_tabs(1, fd);
+ fprintf(fd, "align = ");
+ if(print_type_alignment(td, fd, 0, basename, "", "obj")) return 1;
+ fprintf(fd, ";\n");
+ fprintf(fd, "\n");
+ print_tabs(1, fd);
+ fprintf(fd, "if(*len == 0) {\n");
+ print_tabs(2, fd);
+ fprintf(fd, "*to += ltt_align(*to, align); /* align output */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "} else {\n");
+ print_tabs(2, fd);
+ fprintf(fd, "*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "}\n");
+ fprintf(fd, "\n");
+
+ /* First, check if the type has a fixed size. If it is the case, then the size
+ * to write is know by the compiler : simply use a sizeof() */
+ if(has_type_fixed_size(td)) {
+ print_tabs(1, fd);
+ fprintf(fd, "/* Contains only fixed size fields : use compiler sizeof() */\n");
+ fprintf(fd, "\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*len += sizeof(");
+ if(print_type(td, fd, 0, basename, field_name)) return 1;
+ fprintf(fd, ");\n");
+ } else {
+ /* The type contains nested variable size subtypes :
+ * we must write field by field. */
+ print_tabs(1, fd);
+ fprintf(fd, "/* Contains variable sized fields : must explode the structure */\n");
+ fprintf(fd, "\n");
+
+ switch(td->type) {
+ case SEQUENCE:
+ print_tabs(1, fd);
+ fprintf(fd, "/* Copy members */\n");
+// print_tabs(1, fd);
+// fprintf(fd, "size = sizeof(\n");
+ if(print_type_write(((field_t*)td->fields.array[0])->type,
+ fd, 1, basename, "len", "obj->", 1)) return 1;
+ fprintf(fd, "\n");
+// fprintf(fd, ");\n");
+// print_tabs(1, fd);
+// fprintf(fd, "*to += ltt_align(*to, size);\n");
+ print_tabs(1, fd);
+ fprintf(fd, "if(buffer != NULL)\n");
+ print_tabs(2, fd);
+ fprintf(fd, "memcpy(buffer+*to_base+*to, &obj->len, *len);\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*to += *len;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*len = 0;\n");
+ fprintf(fd, "\n");
+
+ /* Write the child : varlen child or not ? */
+ if(has_type_fixed_size(((field_t*)td->fields.array[1])->type)) {
+ /* Fixed size len child : use a multiplication of its size */
+// print_tabs(1, fd);
+// fprintf(fd, "size = sizeof(\n");
+
+ //print_tabs(1, fd);
+ /* We know that *len does not contain alignment because of the
+ * previous align output. len is always 0 here. */
+ if(print_type_write(((field_t*)td->fields.array[1])->type,
+ fd, 1, basename, "array[0]", "obj->", 1))
+ return 1;
+// fprintf(fd, ");\n");
+ fprintf(fd, "\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*len = obj->len * (*len);\n");
+ print_tabs(1, fd);
+ fprintf(fd, "if(buffer != NULL)\n");
+ print_tabs(2, fd);
+ fprintf(fd, "memcpy(buffer+*to_base+*to, obj->array, *len);\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*to += *len;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*len = 0;\n");
+ fprintf(fd, "\n");
+ } else {
+ print_tabs(1, fd);
+ fprintf(fd, "/* Variable length child : iter. */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "for(unsigned int i=0; i<obj->len; i++) {\n");
+ if(print_type_write(((field_t*)td->fields.array[1])->type,
+ fd, 2, basename, "array[i]", "obj->", 1)) return 1;
+ print_tabs(1, fd);
+ fprintf(fd, "}\n");
+ }
+ fprintf(fd, "\n");
+ print_tabs(1, fd);
+ fprintf(fd, "/* Realign the *to_base on arch size, set *to to 0 */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*to += ltt_align(*to, sizeof(void *));\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*to_base = *to_base+*to;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*to = 0;\n");
+ fprintf(fd, "\n");
+ print_tabs(1, fd);
+ fprintf(fd, "/* Put source *from just after the C sequence */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*from = obj+1;\n");
+ break;
+ case STRING:
+ print_tabs(1, fd);
+ fprintf(fd, "size = strlen(obj) + 1; /* Include final NULL char. */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "if(buffer != NULL)\n");
+ print_tabs(2, fd);
+ fprintf(fd, "memcpy(buffer+*to_base+*to, obj, size);\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*to += size;\n");
+ fprintf(fd, "\n");
+ print_tabs(1, fd);
+ fprintf(fd, "/* Realign the *to_base on arch size, set *to to 0 */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*to += ltt_align(*to, sizeof(void *));\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*to_base = *to_base+*to;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*to = 0;\n");
+ fprintf(fd, "\n");
+ print_tabs(1, fd);
+ fprintf(fd, "/* Put source *from just after the C string */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "*from += size;\n");
+ break;
+ case STRUCT:
+ for(unsigned int i=0;i<td->fields.position;i++){
+ field_t *field = (field_t*)(td->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ if(print_type_write(type,
+ fd, 1, basename, field->name, "obj->", 1)) return 1;
+ fprintf(fd, "\n");
+ }
+ break;
+ case UNION:
+ printf("ERROR : A union CANNOT contain a variable size child.\n");
+ return 1;
+ break;
+ case ARRAY:
+ /* Write the child : varlen child or not ? */
+ if(has_type_fixed_size(((field_t*)td->fields.array[0])->type)) {
+ /* Error : if an array has a variable size, then its child must also
+ * have a variable size. */
+ assert(0);
+ } else {
+ print_tabs(1, fd);
+ fprintf(fd, "/* Variable length child : iter. */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "for(unsigned int i=0; i<LTTNG_ARRAY_SIZE_%s; i++) {\n", basename);
+ if(print_type_write(((field_t*)td->fields.array[0])->type,
+ fd, 2, basename, "", "obj->array[i]", 1)) return 1;
+ print_tabs(1, fd);
+ fprintf(fd, "}\n");
+ }
+ break;
+ default:
+ printf("print_type_write_fct : type has no write function.\n");
+ break;
+ }
+
+
+ }
+
+
+ /* Function footer */
+ fprintf(fd, "}\n");
+ fprintf(fd, "\n");
+ return 0;
+}
+
+
+
+/* Print the logging function of an event. This is the core of genevent */
+int print_event_logging_function(char *basename, facility_t *fac,
+ event_t *event, FILE *fd)
+{
+ fprintf(fd, "static inline void trace_%s(\n", basename);
+ int has_argument = 0;
+ int has_type_fixed = 0;
+
+ /* Does it support per trace tracing ? */
+ if(event->per_trace) {
+ print_tabs(2, fd);
+ fprintf(fd, "struct ltt_trace_struct *dest_trace");
+ has_argument = 1;
+ }
+
+ /* Does it support per tracefile tracing ? */
+ if(event->per_tracefile) {
+ if(has_argument) {
+ fprintf(fd, ",");
+ fprintf(fd, "\n");
+ }
+ fprintf(fd, "unsigned int tracefile_index");
+ has_argument = 1;
+ }
+
+ for(unsigned int j = 0; j < event->fields.position; j++) {
+ /* For each field, print the function argument */
+ field_t *f = (field_t*)event->fields.array[j];
+ type_descriptor_t *t = f->type;
+ if(has_argument) {
+ fprintf(fd, ",");
+ fprintf(fd, "\n");
+ }
+ if(print_arg(t, fd, 2, basename, f->name)) return 1;
+ has_argument = 1;
+ }
+ if(!has_argument) {
+ print_tabs(2, fd);
+ fprintf(fd, "void");
+ }
+ fprintf(fd,")\n");
+ fprintf(fd,
+ "#if (!defined(CONFIG_LTT) || !defined(CONFIG_LTT_FACILITY_%s))\n",
+ fac->capname);
+ fprintf(fd, "{\n");
+ fprintf(fd, "}\n");
+ fprintf(fd,"#else\n");
+ fprintf(fd, "{\n");
+ /* Print the function variables */
+ print_tabs(1, fd);
+ fprintf(fd, "unsigned int index;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "struct ltt_channel_struct *channel;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "struct ltt_trace_struct *trace;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "struct rchan_buf *relayfs_buf;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "void *buffer = NULL;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t *to_base = &real_to_base;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t real_to = 0;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t *to = &real_to;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t real_len = 0;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t *len = &real_len;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t reserve_size;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t slot_size;\n");
+ print_tabs(1, fd);
+
+ if(event->fields.position > 0) {
+ for(unsigned int i=0;i<event->fields.position;i++){
+ /* Search for at least one child with fixed size. It means
+ * we need local variables.*/
+ field_t *field = (field_t*)(event->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ has_type_fixed = has_type_local(type);
+ if(has_type_fixed) break;
+ }
+
+ if(has_type_fixed) {
+ fprintf(fd, "size_t align;\n");
+ print_tabs(1, fd);
+ }
+
+ fprintf(fd, "const void *real_from;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "const void **from = &real_from;\n");
+ print_tabs(1, fd);
+ }
+ fprintf(fd, "u64 tsc;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t before_hdr_pad, after_hdr_pad, header_size;\n");
+ fprintf(fd, "\n");
+
+ print_tabs(1, fd);
+ fprintf(fd, "if(ltt_traces.num_active_traces == 0) return;\n");
+ fprintf(fd, "\n");
+
+ /* Calculate event variable len + event data alignment offset.
+ * Assume that the padding for alignment starts at a void*
+ * address.
+ * This excludes the header size and alignment. */
+
+ print_tabs(1, fd);
+ fprintf(fd, "/* For each field, calculate the field size. */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "/* size = *to_base + *to + *len */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "/* Assume that the padding for alignment starts at a\n");
+ print_tabs(1, fd);
+ fprintf(fd, " * sizeof(void *) address. */\n");
+ fprintf(fd, "\n");
+
+ for(unsigned int i=0;i<event->fields.position;i++){
+ field_t *field = (field_t*)(event->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ /* Set from */
+ print_tabs(1, fd);
+ switch(type->type) {
+ case SEQUENCE:
+ case UNION:
+ case ARRAY:
+ case STRUCT:
+ case STRING:
+ fprintf(fd, "*from = lttng_param_%s;\n", field->name);
+ break;
+ default:
+ fprintf(fd, "*from = <tng_param_%s;\n", field->name);
+ break;
+ }
+
+ if(print_type_write(type,
+ fd, 1, basename, field->name, "lttng_param_", 0)) return 1;
+ fprintf(fd, "\n");
+ }
+ print_tabs(1, fd);
+ fprintf(fd, "reserve_size = *to_base + *to + *len;\n");
+
+ /* Take locks : make sure the trace does not vanish while we write on
+ * it. A simple preemption disabling is enough (using rcu traces). */
+ print_tabs(1, fd);
+ fprintf(fd, "preempt_disable();\n");
+ print_tabs(1, fd);
+ fprintf(fd, "ltt_nesting[smp_processor_id()]++;\n");
+
+ /* Get facility index */
+
+ if(event->per_tracefile) {
+ print_tabs(1, fd);
+ fprintf(fd, "index = tracefile_index;\n");
+ } else {
+ print_tabs(1, fd);
+ fprintf(fd,
+ "index = ltt_get_index_from_facility(ltt_facility_%s_%X,\n"\
+ "\t\t\t\t\t\tevent_%s_%s);\n",
+ fac->name, fac->checksum, fac->name, event->name);
+ }
+ fprintf(fd,"\n");
+
+
+ /* For each trace */
+ print_tabs(1, fd);
+ fprintf(fd, "list_for_each_entry_rcu(trace, <t_traces.head, list) {\n");
+ print_tabs(2, fd);
+ fprintf(fd, "if(!trace->active) continue;\n\n");
+
+ if(event->per_trace) {
+ print_tabs(2, fd);
+ fprintf(fd, "if(dest_trace != trace) continue;\n\n");
+ }
+
+ print_tabs(2, fd);
+ fprintf(fd, "channel = ltt_get_channel_from_index(trace, index);\n");
+ print_tabs(2, fd);
+ fprintf(fd, "relayfs_buf = channel->rchan->buf[smp_processor_id()];\n");
+ fprintf(fd, "\n");
+
+
+ /* Relay reserve */
+ /* If error, increment event lost counter (done by ltt_reserve_slot) and
+ * return */
+ print_tabs(2, fd);
+ fprintf(fd, "slot_size = 0;\n");
+ print_tabs(2, fd);
+ fprintf(fd, "buffer = ltt_reserve_slot(trace, relayfs_buf,\n");
+ print_tabs(3, fd);
+ fprintf(fd, "reserve_size, &slot_size, &tsc,\n");
+ print_tabs(3, fd);
+ fprintf(fd, "&before_hdr_pad, &after_hdr_pad, &header_size);\n");
+ /* If error, return */
+ print_tabs(2, fd);
+ fprintf(fd, "if(!buffer) continue; /* buffer full */\n\n");
+ //print_tabs(2, fd);
+ // for DEBUG only
+ // fprintf(fd, "goto commit; /* DEBUG : never actually write. */\n\n");
+ print_tabs(2, fd);
+ fprintf(fd, "*to_base = *to = *len = 0;\n");
+ fprintf(fd, "\n");
+
+ /* Write event header */
+ print_tabs(2, fd);
+ fprintf(fd, "ltt_write_event_header(trace, channel, buffer,\n");
+ print_tabs(3, fd);
+ fprintf(fd, "ltt_facility_%s_%X, event_%s_%s,\n", fac->name, fac->checksum,
+ fac->name, event->name);
+ print_tabs(3, fd);
+ fprintf(fd, "reserve_size, before_hdr_pad, tsc);\n");
+ print_tabs(2, fd);
+ fprintf(fd, "*to_base += before_hdr_pad + after_hdr_pad + header_size;\n");
+ fprintf(fd, "\n");
+
+ /* write data. */
+
+ for(unsigned int i=0;i<event->fields.position;i++){
+ field_t *field = (field_t*)(event->fields.array[i]);
+ type_descriptor_t *type = field->type;
+
+ /* Set from */
+ print_tabs(2, fd);
+ switch(type->type) {
+ case SEQUENCE:
+ case UNION:
+ case ARRAY:
+ case STRUCT:
+ case STRING:
+ fprintf(fd, "*from = lttng_param_%s;\n", field->name);
+ break;
+ default:
+ fprintf(fd, "*from = <tng_param_%s;\n", field->name);
+ break;
+ }
+
+
+ if(print_type_write(type,
+ fd, 2, basename, field->name, "lttng_param_", 0)) return 1;
+ fprintf(fd, "\n");
+
+ /* Don't forget to flush pending memcpy */
+ print_tabs(2, fd);
+ fprintf(fd, "/* Flush pending memcpy */\n");
+ print_tabs(2, fd);
+ fprintf(fd, "if(*len != 0) {\n");
+ print_tabs(3, fd);
+ fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
+ print_tabs(3, fd);
+ fprintf(fd, "*to += *len;\n");
+ //print_tabs(3, fd);
+ //fprintf(fd, "from += len;\n");
+ print_tabs(3, fd);
+ fprintf(fd, "*len = 0;\n");
+ print_tabs(2, fd);
+ fprintf(fd, "}\n");
+ fprintf(fd, "\n");
+ }
+
+
+ /* commit */
+ // for DEBUG only.
+ //fprintf(fd, "commit:\n"); /* DEBUG! */
+ print_tabs(2, fd);
+ fprintf(fd, "ltt_commit_slot(relayfs_buf, buffer, slot_size);\n\n");
+
+ print_tabs(1, fd);
+ fprintf(fd, "}\n\n");
+
+ /* Release locks */
+ print_tabs(1, fd);
+ fprintf(fd, "ltt_nesting[smp_processor_id()]--;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "preempt_enable_no_resched();\n");
+
+ fprintf(fd, "}\n");
+ fprintf(fd, "#endif //(!defined(CONFIG_LTT) || !defined(CONFIG_LTT_FACILITY_%s))\n\n",
+ fac->capname);
+ return 0;
+}
+
+/* print_event_logging_function_user_generic
+ * Print the logging function of an event for userspace tracing. This is the
+ * core of genevent */
+int print_event_logging_function_user_generic(char *basename, facility_t *fac,
+ event_t *event, FILE *fd)
+{
+ char *attrib;
+
+ fprintf(fd, "#ifndef LTT_TRACE_FAST\n");
+
+ if(event->no_instrument_function) {
+ attrib = "__attribute__((no_instrument_function)) ";
+ } else {
+ attrib = "";
+ }
+ if(event->param_buffer) {
+ fprintf(fd, "static inline %sint trace_%s_param_buffer(\n", attrib, basename);
+ } else {
+ fprintf(fd, "static inline %sint trace_%s(\n",attrib, basename);
+ }
+ int has_argument = 0;
+ int has_type_fixed = 0;
+
+ if(event->param_buffer) {
+ if(has_argument) {
+ fprintf(fd, ",");
+ fprintf(fd, "\n");
+ }
+ print_tabs(2, fd);
+ fprintf(fd, "void *buffer");
+ has_argument = 1;
+ fprintf(fd, ",");
+ fprintf(fd, "\n");
+ print_tabs(2, fd);
+ fprintf(fd, "size_t reserve_size");
+ } else {
+ for(unsigned int j = 0; j < event->fields.position; j++) {
+ /* For each field, print the function argument */
+ field_t *f = (field_t*)event->fields.array[j];
+ type_descriptor_t *t = f->type;
+ if(has_argument) {
+ fprintf(fd, ",");
+ fprintf(fd, "\n");
+ }
+ if(print_arg(t, fd, 2, basename, f->name)) return 1;
+ has_argument = 1;
+ }
+ }
+ if(!has_argument) {
+ print_tabs(2, fd);
+ fprintf(fd, "void");
+ }
+ fprintf(fd,")\n");
+ fprintf(fd,
+ "#ifndef LTT_TRACE\n");
+ fprintf(fd, "{\n");
+ fprintf(fd, "}\n");
+ fprintf(fd,"#else\n");
+ fprintf(fd, "{\n");
+ /* Print the function variables */
+ print_tabs(1, fd);
+ fprintf(fd, "int ret = 0;\n");
+ if(event->param_buffer) {
+ print_tabs(1, fd);
+ fprintf(fd, "reserve_size = ltt_align(reserve_size, sizeof(void *));\n");
+ print_tabs(1, fd);
+ fprintf(fd, "{\n");
+ goto do_syscall;
+ }
+ print_tabs(1, fd);
+ fprintf(fd, "void *buffer = NULL;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t *to_base = &real_to_base;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t real_to = 0;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t *to = &real_to;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t real_len = 0;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t *len = &real_len;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t reserve_size;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t slot_size;\n");
+ print_tabs(1, fd);
+
+ if(event->fields.position > 0) {
+ for(unsigned int i=0;i<event->fields.position;i++){
+ /* Search for at least one child with fixed size. It means
+ * we need local variables.*/
+ field_t *field = (field_t*)(event->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ has_type_fixed = has_type_local(type);
+ if(has_type_fixed) break;
+ }
+
+ if(has_type_fixed) {
+ fprintf(fd, "size_t align;\n");
+ print_tabs(1, fd);
+ }
+
+ fprintf(fd, "const void *real_from;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "const void **from = &real_from;\n");
+ print_tabs(1, fd);
+ }
+
+ /* Calculate event variable len + event data alignment offset.
+ * Assume that the padding for alignment starts at a void*
+ * address.
+ * This excludes the header size and alignment. */
+
+ print_tabs(1, fd);
+ fprintf(fd, "/* For each field, calculate the field size. */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "/* size = *to_base + *to + *len */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "/* Assume that the padding for alignment starts at a\n");
+ print_tabs(1, fd);
+ fprintf(fd, " * sizeof(void *) address. */\n");
+ fprintf(fd, "\n");
+
+ for(unsigned int i=0;i<event->fields.position;i++){
+ field_t *field = (field_t*)(event->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ /* Set from */
+ print_tabs(1, fd);
+ switch(type->type) {
+ case SEQUENCE:
+ case UNION:
+ case ARRAY:
+ case STRUCT:
+ case STRING:
+ fprintf(fd, "*from = lttng_param_%s;\n", field->name);
+ break;
+ default:
+ fprintf(fd, "*from = <tng_param_%s;\n", field->name);
+ break;
+ }
+
+ if(print_type_write(type,
+ fd, 1, basename, field->name, "lttng_param_", 0)) return 1;
+ fprintf(fd, "\n");
+ }
+ print_tabs(1, fd);
+ fprintf(fd, "reserve_size = *to_base + *to + *len;\n");
+
+ print_tabs(1, fd);
+ fprintf(fd, "{\n");
+ print_tabs(2, fd);
+ fprintf(fd, "char stack_buffer[reserve_size];\n");
+ print_tabs(2, fd);
+ fprintf(fd, "buffer = stack_buffer;\n");
+ fprintf(fd, "\n");
+
+
+ //print_tabs(2, fd);
+ // for DEBUG only
+ // fprintf(fd, "goto commit; /* DEBUG : never actually write. */\n\n");
+ print_tabs(2, fd);
+ fprintf(fd, "*to_base = *to = *len = 0;\n");
+ fprintf(fd, "\n");
+
+ /* write data. */
+
+ for(unsigned int i=0;i<event->fields.position;i++){
+ field_t *field = (field_t*)(event->fields.array[i]);
+ type_descriptor_t *type = field->type;
+
+ /* Set from */
+ print_tabs(2, fd);
+ switch(type->type) {
+ case SEQUENCE:
+ case UNION:
+ case ARRAY:
+ case STRUCT:
+ case STRING:
+ fprintf(fd, "*from = lttng_param_%s;\n", field->name);
+ break;
+ default:
+ fprintf(fd, "*from = <tng_param_%s;\n", field->name);
+ break;
+ }
+
+
+ if(print_type_write(type,
+ fd, 2, basename, field->name, "lttng_param_", 0)) return 1;
+ fprintf(fd, "\n");
+
+ /* Don't forget to flush pending memcpy */
+ print_tabs(2, fd);
+ fprintf(fd, "/* Flush pending memcpy */\n");
+ print_tabs(2, fd);
+ fprintf(fd, "if(*len != 0) {\n");
+ print_tabs(3, fd);
+ fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
+ print_tabs(3, fd);
+ fprintf(fd, "*to += *len;\n");
+ //print_tabs(3, fd);
+ //fprintf(fd, "from += len;\n");
+ print_tabs(3, fd);
+ fprintf(fd, "*len = 0;\n");
+ print_tabs(2, fd);
+ fprintf(fd, "}\n");
+ fprintf(fd, "\n");
+ }
+
+do_syscall:
+ print_tabs(2, fd);
+ fprintf(fd, "ret = ltt_trace_generic(ltt_facility_%s_%X, event_%s_%s, buffer, reserve_size, LTT_BLOCKING);\n", fac->name, fac->checksum, fac->name, event->name);
+
+ print_tabs(1, fd);
+ fprintf(fd, "}\n\n");
+
+ print_tabs(1, fd);
+ fprintf(fd, "return ret;\n\n");
+
+ fprintf(fd, "}\n");
+ fprintf(fd,
+ "#endif //LTT_TRACE\n");
+ fprintf(fd, "#endif //!LTT_TRACE_FAST\n\n");
+
+ return 0;
+}
+
+/* print_event_logging_function_user_fast
+ * Print the logging function of an event for userspace tracing. This is the
+ * core of genevent */
+int print_event_logging_function_user_fast(char *basename, facility_t *fac,
+ event_t *event, FILE *fd)
+{
+ char *attrib;
+
+ fprintf(fd, "#ifdef LTT_TRACE_FAST\n");
+
+ if(event->no_instrument_function) {
+ attrib = "__attribute__((no_instrument_function)) ";
+ } else {
+ attrib = "";
+ }
+ fprintf(fd, "static inline %sint trace_%s(\n",attrib, basename);
+
+ int has_argument = 0;
+ int has_type_fixed = 0;
+
+ for(unsigned int j = 0; j < event->fields.position; j++) {
+ /* For each field, print the function argument */
+ field_t *f = (field_t*)event->fields.array[j];
+ type_descriptor_t *t = f->type;
+ if(has_argument) {
+ fprintf(fd, ",");
+ fprintf(fd, "\n");
+ }
+ if(print_arg(t, fd, 2, basename, f->name)) return 1;
+ has_argument = 1;
+ }
+ if(!has_argument) {
+ print_tabs(2, fd);
+ fprintf(fd, "void");
+ }
+ fprintf(fd,")\n");
+ fprintf(fd,
+ "#ifndef LTT_TRACE\n");
+ fprintf(fd, "{\n");
+ fprintf(fd, "}\n");
+ fprintf(fd,"#else\n");
+ fprintf(fd, "{\n");
+ /* Print the function variables */
+ print_tabs(1, fd);
+ fprintf(fd, "unsigned int index;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "struct ltt_trace_info *trace = thread_trace_info;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "struct ltt_buf *ltt_buf;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "void *buffer = NULL;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t *to_base = &real_to_base;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t real_to = 0;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t *to = &real_to;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t real_len = 0;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t *len = &real_len;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t reserve_size;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t slot_size;\n");
+ print_tabs(1, fd);
+
+ if(event->fields.position > 0) {
+ for(unsigned int i=0;i<event->fields.position;i++){
+ /* Search for at least one child with fixed size. It means
+ * we need local variables.*/
+ field_t *field = (field_t*)(event->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ has_type_fixed = has_type_local(type);
+ if(has_type_fixed) break;
+ }
+
+ if(has_type_fixed) {
+ fprintf(fd, "size_t align;\n");
+ print_tabs(1, fd);
+ }
+
+ fprintf(fd, "const void *real_from;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "const void **from = &real_from;\n");
+ print_tabs(1, fd);
+ }
+ fprintf(fd, "uint64_t tsc;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "size_t before_hdr_pad, after_hdr_pad, header_size;\n");
+ fprintf(fd, "\n");
+
+ print_tabs(1, fd);
+ fprintf(fd, "if(!trace) {\n");
+ print_tabs(2, fd);
+ fprintf(fd, "ltt_thread_init();\n");
+ print_tabs(2, fd);
+ fprintf(fd, "trace = thread_trace_info;\n");
+ print_tabs(1, fd);
+ fprintf(fd, "}\n\n");
+ fprintf(fd, "\n");
+
+ /* Calculate event variable len + event data alignment offset.
+ * Assume that the padding for alignment starts at a void*
+ * address.
+ * This excludes the header size and alignment. */
+
+ print_tabs(1, fd);
+ fprintf(fd, "/* For each field, calculate the field size. */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "/* size = *to_base + *to + *len */\n");
+ print_tabs(1, fd);
+ fprintf(fd, "/* Assume that the padding for alignment starts at a\n");
+ print_tabs(1, fd);
+ fprintf(fd, " * sizeof(void *) address. */\n");
+ fprintf(fd, "\n");
+
+ for(unsigned int i=0;i<event->fields.position;i++){
+ field_t *field = (field_t*)(event->fields.array[i]);
+ type_descriptor_t *type = field->type;
+ /* Set from */
+ print_tabs(1, fd);
+ switch(type->type) {
+ case SEQUENCE:
+ case UNION:
+ case ARRAY:
+ case STRUCT:
+ case STRING:
+ fprintf(fd, "*from = lttng_param_%s;\n", field->name);
+ break;
+ default:
+ fprintf(fd, "*from = <tng_param_%s;\n", field->name);
+ break;
+ }
+
+ if(print_type_write(type,
+ fd, 1, basename, field->name, "lttng_param_", 0)) return 1;
+ fprintf(fd, "\n");
+ }
+ print_tabs(1, fd);
+ fprintf(fd, "reserve_size = *to_base + *to + *len;\n");
+
+ print_tabs(1, fd);
+ fprintf(fd, "trace->nesting++;\n");
+
+ /* Get facility index */
+
+ print_tabs(1, fd);
+ fprintf(fd,
+ "index = ltt_get_index_from_facility(ltt_facility_%s_%X,\n"\
+ "\t\t\t\t\t\tevent_%s_%s);\n",
+ fac->name, fac->checksum, fac->name, event->name);
+ fprintf(fd,"\n");
+
+
+ print_tabs(1, fd);
+ fprintf(fd, "{\n");
+
+ if(event->per_trace) {
+ print_tabs(2, fd);
+ fprintf(fd, "if(dest_trace != trace) continue;\n\n");
+ }
+
+ print_tabs(2, fd);
+ fprintf(fd, "ltt_buf = ltt_get_channel_from_index(trace, index);\n");
+ print_tabs(2, fd);
+
+
+ /* Relay reserve */
+ /* If error, increment event lost counter (done by ltt_reserve_slot) and
+ * return */
+ print_tabs(2, fd);
+ fprintf(fd, "slot_size = 0;\n");
+ print_tabs(2, fd);
+ fprintf(fd, "buffer = ltt_reserve_slot(trace, ltt_buf,\n");
+ print_tabs(3, fd);
+ fprintf(fd, "reserve_size, &slot_size, &tsc,\n");
+ print_tabs(3, fd);
+ fprintf(fd, "&before_hdr_pad, &after_hdr_pad, &header_size);\n");
+ /* If error, return */
+ print_tabs(2, fd);
+ fprintf(fd, "if(!buffer) goto end; /* buffer full */\n\n");
+ //print_tabs(2, fd);
+ // for DEBUG only
+ // fprintf(fd, "goto commit; /* DEBUG : never actually write. */\n\n");
+ print_tabs(2, fd);
+ fprintf(fd, "*to_base = *to = *len = 0;\n");
+ fprintf(fd, "\n");
+
+ /* Write event header */
+ print_tabs(2, fd);
+ fprintf(fd, "ltt_write_event_header(trace, ltt_buf, buffer,\n");
+ print_tabs(3, fd);
+ fprintf(fd, "ltt_facility_%s_%X, event_%s_%s,\n", fac->name, fac->checksum,
+ fac->name, event->name);
+ print_tabs(3, fd);
+ fprintf(fd, "reserve_size, before_hdr_pad, tsc);\n");
+ print_tabs(2, fd);
+ fprintf(fd, "*to_base += before_hdr_pad + after_hdr_pad + header_size;\n");
+ fprintf(fd, "\n");
+
+ /* write data. */
+
+ for(unsigned int i=0;i<event->fields.position;i++){
+ field_t *field = (field_t*)(event->fields.array[i]);
+ type_descriptor_t *type = field->type;
+
+ /* Set from */
+ print_tabs(2, fd);
+ switch(type->type) {
+ case SEQUENCE:
+ case UNION:
+ case ARRAY:
+ case STRUCT:
+ case STRING:
+ fprintf(fd, "*from = lttng_param_%s;\n", field->name);
+ break;
+ default:
+ fprintf(fd, "*from = <tng_param_%s;\n", field->name);
+ break;
+ }
+
+
+ if(print_type_write(type,
+ fd, 2, basename, field->name, "lttng_param_", 0)) return 1;
+ fprintf(fd, "\n");
+
+ /* Don't forget to flush pending memcpy */
+ print_tabs(2, fd);
+ fprintf(fd, "/* Flush pending memcpy */\n");
+ print_tabs(2, fd);
+ fprintf(fd, "if(*len != 0) {\n");
+ print_tabs(3, fd);
+ fprintf(fd, "memcpy(buffer+*to_base+*to, *from, *len);\n");
+ print_tabs(3, fd);
+ fprintf(fd, "*to += *len;\n");
+ //print_tabs(3, fd);
+ //fprintf(fd, "from += len;\n");
+ print_tabs(3, fd);
+ fprintf(fd, "*len = 0;\n");
+ print_tabs(2, fd);
+ fprintf(fd, "}\n");
+ fprintf(fd, "\n");
+ }
+
+
+ /* commit */
+ // for DEBUG only.
+ //fprintf(fd, "commit:\n"); /* DEBUG! */
+ print_tabs(2, fd);
+ fprintf(fd, "ltt_commit_slot(ltt_buf, buffer, slot_size);\n\n");
+
+ fprintf(fd, "}\n\n");
+
+ fprintf(fd, "end:\n");
+ /* Release locks */
+ print_tabs(1, fd);
+ fprintf(fd, "trace->nesting--;\n");
+
+
+ fprintf(fd, "}\n");
+ fprintf(fd,
+ "#endif //LTT_TRACE\n");
+ fprintf(fd, "#endif //LTT_TRACE_FAST\n");
+
+ return 0;
+}
+
+
+
+
+
+
+/* ltt-facility-name.h : main logging header.
+ * log_header */
+
+void print_log_header_head(facility_t *fac, FILE *fd)
+{
+ fprintf(fd, "#ifndef _LTT_FACILITY_%s_H_\n", fac->capname);
+ fprintf(fd, "#define _LTT_FACILITY_%s_H_\n\n", fac->capname);
+ fprintf(fd, "#include <linux/types.h>\n");
+ if(!fac->arch)
+ fprintf(fd, "#include <linux/ltt/ltt-facility-id-%s.h>\n", fac->name);
+ else
+ fprintf(fd, "#include <asm/ltt/ltt-facility-id-%s_%s.h>\n",
+ fac->name,
+ fac->arch);
+ fprintf(fd, "#include <linux/ltt-core.h>\n");
+ fprintf(fd, "\n");
+}
+
+/* ltt-facility-name.h : main logging header.
+ * log_header */
+
+void print_log_header_head_user(facility_t *fac, FILE *fd)
+{
+ fprintf(fd, "#ifndef _LTT_FACILITY_%s_H_\n", fac->capname);
+ fprintf(fd, "#define _LTT_FACILITY_%s_H_\n\n", fac->capname);
+ fprintf(fd, "#include <sys/types.h>\n");
+ if(!fac->arch)
+ fprintf(fd, "#include <ltt/ltt-facility-id-%s.h>\n", fac->name);
+ else
+ fprintf(fd, "#include <asm/ltt/ltt-facility-id-%s_%s.h>\n",
+ fac->name,
+ fac->arch);
+ fprintf(fd, "#include <ltt/ltt-usertrace.h>\n");
+ fprintf(fd, "\n");
+}
+
+
+int print_log_header_types(facility_t *fac, FILE *fd)
+{
+ sequence_t *types = &fac->named_types.values;
+ fprintf(fd, "/* Named types */\n");
+ fprintf(fd, "\n");
+
+ for(unsigned int i = 0; i < types->position; i++) {
+ /* For each named type, print the definition */
+ if(print_type_declaration(types->array[i], fd,
+ 0, "", "")) return 1;
+ /* Print also the align function */
+ if(print_type_alignment_fct(types->array[i], fd,
+ 0, "", "")) return 1;
+ /* Print also the write function */
+ if(print_type_write_fct(types->array[i], fd,
+ 0, "", "")) return 1;
+ }
+ return 0;
+}
+
+int print_log_header_events(facility_t *fac, FILE *fd)
+{
+ sequence_t *events = &fac->events;
+ char basename[PATH_MAX];
+ unsigned int facname_len;
+
+ strncpy(basename, fac->name, PATH_MAX);
+ facname_len = strlen(basename);
+ strncat(basename, "_", PATH_MAX-facname_len);
+ facname_len = strlen(basename);
+
+ for(unsigned int i = 0; i < events->position; i++) {
+ event_t *event = (event_t*)events->array[i];
+ strncpy(&basename[facname_len], event->name, PATH_MAX-facname_len);
+
+ /* For each event, print structure, and then logging function */
+ fprintf(fd, "/* Event %s structures */\n",
+ event->name);
+ for(unsigned int j = 0; j < event->fields.position; j++) {
+ /* For each unnamed type, print the definition */
+ field_t *f = (field_t*)event->fields.array[j];
+ type_descriptor_t *t = f->type;
+ if(t->type_name == NULL) {
+ if((print_type_declaration(t, fd, 0, basename, f->name))) return 1;
+ /* Print also the align function */
+ if((print_type_alignment_fct(t, fd, 0, basename, f->name))) return 1;
+ /* Print also the write function */
+ if((print_type_write_fct(t, fd, 0, basename, f->name))) return 1;
+ }
+ }
+
+ fprintf(fd, "\n");
+
+ fprintf(fd, "/* Event %s logging function */\n",
+ event->name);
+
+ if(!fac->user) {
+ if(print_event_logging_function(basename, fac, event, fd)) return 1;
+ } else {
+ if(print_event_logging_function_user_generic(basename, fac, event, fd))
+ return 1;
+ if(print_event_logging_function_user_fast(basename, fac, event, fd))
+ return 1;
+ }
+
+ fprintf(fd, "\n");
+ }
+
+ return 0;
+}
+
+
+void print_log_header_tail(facility_t *fac, FILE *fd)
+{
+ fprintf(fd, "#endif //_LTT_FACILITY_%s_H_\n",fac->capname);
+}
+
+void print_log_header_tail_user(facility_t *fac, FILE *fd)
+{
+ fprintf(fd, "#endif //_LTT_FACILITY_%s_H_\n",fac->capname);
+}
+
+int print_log_header(facility_t *fac)
+{
+ char filename[PATH_MAX];
+ unsigned int filename_size = 0;
+ FILE *fd;
+ dprintf("%s\n", fac->name);
+
+ strcpy(filename, "ltt-facility-");
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->name, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ if(fac->arch) {
+ strncat(filename, "_", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->arch, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+ }
+
+ strncat(filename, ".h", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+
+ fd = fopen(filename, "w");
+ if(fd == NULL) {
+ printf("Error opening file %s for writing : %s\n",
+ filename, strerror(errno));
+ return errno;
+ }
+
+ /* Print file head */
+ if(!fac->user)
+ print_log_header_head(fac, fd);
+ else
+ print_log_header_head_user(fac, fd);
+
+ /* print named types in declaration order */
+ if(print_log_header_types(fac, fd)) return 1;
+
+ /* Print events */
+ if(print_log_header_events(fac, fd)) return 1;
+
+ /* Print file tail */
+ if(!fac->user)
+ print_log_header_tail(fac, fd);
+ else
+ print_log_header_tail_user(fac, fd);
+
+
+
+ fclose(fd);
+
+ return 0;
+}
+
+
+/* ltt-facility-id-name.h : facility id.
+ * log_id_header */
+int print_id_header(facility_t *fac)
+{
+ char filename[PATH_MAX];
+ unsigned int filename_size = 0;
+ FILE *fd;
+ char basename[PATH_MAX];
+ char basename_len = 0;
+
+ dprintf("%s\n", fac->name);
+
+ strcpy(filename, "ltt-facility-id-");
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->name, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ if(fac->arch) {
+ strncat(filename, "_", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->arch, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+ }
+
+ strncat(filename, ".h", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+
+ fd = fopen(filename, "w");
+ if(fd == NULL) {
+ printf("Error opening file %s for writing : %s\n",
+ filename, strerror(errno));
+ return errno;
+ }
+
+ if(!fac->user) {
+ fprintf(fd, "#ifndef _LTT_FACILITY_ID_%s_H_\n",fac->capname);
+ fprintf(fd, "#define _LTT_FACILITY_ID_%s_H_\n\n",fac->capname);
+ fprintf(fd, "#ifdef CONFIG_LTT\n");
+
+ fprintf(fd,"#include <linux/ltt-facilities.h>\n\n");
+
+ fprintf(fd,"/**** facility handle ****/\n\n");
+ fprintf(fd,"extern ltt_facility_t ltt_facility_%s_%X;\n",
+ fac->name, fac->checksum);
+ fprintf(fd,"extern ltt_facility_t ltt_facility_%s;\n\n\n",fac->name);
+
+ strncpy(basename, fac->name, PATH_MAX);
+ basename_len = strlen(basename);
+ strncat(basename, "_", PATH_MAX - basename_len);
+ basename_len++;
+
+ fprintf(fd,"/**** event index ****/\n\n");
+ fprintf(fd,"enum %s_event {\n",fac->name);
+
+ for(unsigned int i = 0; i < fac->events.position; i++) {
+ event_t *event = (event_t*)fac->events.array[i];
+ strncpy(basename+basename_len, event->name, PATH_MAX-basename_len);
+ print_tabs(1, fd);
+ fprintf(fd, "event_%s,\n", basename);
+ }
+ print_tabs(1, fd);
+ fprintf(fd, "facility_%s_num_events\n", fac->name);
+ fprintf(fd, "};\n");
+ fprintf(fd, "\n");
+
+
+ fprintf(fd, "#endif //CONFIG_LTT\n");
+ fprintf(fd, "#endif //_LTT_FACILITY_ID_%s_H_\n",fac->capname);
+ } else {
+ fprintf(fd, "#ifndef _LTT_FACILITY_ID_%s_H_\n",fac->capname);
+ fprintf(fd, "#define _LTT_FACILITY_ID_%s_H_\n\n",fac->capname);
+ fprintf(fd, "#ifdef LTT_TRACE\n");
+
+ fprintf(fd,"#include <ltt/ltt-usertrace.h>\n\n");
+
+ fprintf(fd,"/**** facility handle ****/\n\n");
+ fprintf(fd,"extern ltt_facility_t ltt_facility_%s_%X;\n",
+ fac->name, fac->checksum);
+ fprintf(fd,"extern ltt_facility_t ltt_facility_%s;\n\n\n",fac->name);
+
+ strncpy(basename, fac->name, PATH_MAX);
+ basename_len = strlen(basename);
+ strncat(basename, "_", PATH_MAX - basename_len);
+ basename_len++;
+
+ fprintf(fd,"/**** event index ****/\n\n");
+ fprintf(fd,"enum %s_event {\n",fac->name);
+
+ for(unsigned int i = 0; i < fac->events.position; i++) {
+ event_t *event = (event_t*)fac->events.array[i];
+ strncpy(basename+basename_len, event->name, PATH_MAX-basename_len);
+ print_tabs(1, fd);
+ fprintf(fd, "event_%s,\n", basename);
+ }
+ print_tabs(1, fd);
+ fprintf(fd, "facility_%s_num_events\n", fac->name);
+ fprintf(fd, "};\n");
+ fprintf(fd, "\n");
+
+
+ fprintf(fd, "#endif //LTT_TRACE\n");
+ fprintf(fd, "#endif //_LTT_FACILITY_ID_%s_H_\n",fac->capname);
+ }
+
+
+ fclose(fd);
+
+ return 0;
+}
+
+
+/* ltt-facility-loader-name.h : facility specific loader info.
+ * loader_header */
+int print_loader_header(facility_t *fac)
+{
+ char filename[PATH_MAX];
+ unsigned int filename_size = 0;
+ FILE *fd;
+ dprintf("%s\n", fac->name);
+
+ strcpy(filename, "ltt-facility-loader-");
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->name, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ if(fac->arch) {
+ strncat(filename, "_", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->arch, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+ }
+
+ strncat(filename, ".h", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+
+ fd = fopen(filename, "w");
+ if(fd == NULL) {
+ printf("Error opening file %s for writing : %s\n",
+ filename, strerror(errno));
+ return errno;
+ }
+
+ fprintf(fd, "#ifndef _LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
+ fprintf(fd, "#define _LTT_FACILITY_LOADER_%s_H_\n\n", fac->capname);
+ fprintf(fd, "#ifdef CONFIG_LTT\n\n");
+ fprintf(fd,"#include <linux/ltt-facilities.h>\n");
+ if(!fac->arch)
+ fprintf(fd,"#include <linux/ltt/ltt-facility-id-%s.h>\n\n",
+ fac->name);
+ else
+ fprintf(fd,"#include <asm/ltt/ltt-facility-id-%s_%s.h>\n\n",
+ fac->name,
+ fac->arch);
+ fprintf(fd,"ltt_facility_t\tltt_facility_%s;\n", fac->name);
+ fprintf(fd,"ltt_facility_t\tltt_facility_%s_%X;\n\n",
+ fac->name, fac->checksum);
+
+ fprintf(fd,"#define LTT_FACILITY_SYMBOL\t\t\t\t\t\t\tltt_facility_%s\n",
+ fac->name);
+ fprintf(fd,"#define LTT_FACILITY_CHECKSUM_SYMBOL\t\tltt_facility_%s_%X\n",
+ fac->name, fac->checksum);
+ fprintf(fd,"#define LTT_FACILITY_CHECKSUM\t\t\t\t\t\t0x%X\n", fac->checksum);
+ fprintf(fd,"#define LTT_FACILITY_NAME\t\t\t\t\t\t\t\t\"%s\"\n", fac->name);
+ fprintf(fd,"#define LTT_FACILITY_NUM_EVENTS\t\t\t\t\tfacility_%s_num_events\n\n",
+ fac->name);
+ fprintf(fd, "#endif //CONFIG_LTT\n\n");
+ fprintf(fd, "#endif //_LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
+
+ fclose(fd);
+
+ return 0;
+}
+
+int print_loader_header_user(facility_t *fac)
+{
+ char filename[PATH_MAX];
+ unsigned int filename_size = 0;
+ FILE *fd;
+ dprintf("%s\n", fac->name);
+
+ strcpy(filename, "ltt-facility-loader-");
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->name, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ if(fac->arch) {
+ strncat(filename, "_", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->arch, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+ }
+
+ strncat(filename, ".h", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+
+ fd = fopen(filename, "w");
+ if(fd == NULL) {
+ printf("Error opening file %s for writing : %s\n",
+ filename, strerror(errno));
+ return errno;
+ }
+
+ fprintf(fd, "#ifndef _LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
+ fprintf(fd, "#define _LTT_FACILITY_LOADER_%s_H_\n\n", fac->capname);
+ fprintf(fd,"#include <ltt/ltt-usertrace.h>\n");
+ if(!fac->arch)
+ fprintf(fd,"#include <ltt/ltt-facility-id-%s.h>\n\n",
+ fac->name);
+ else
+ fprintf(fd,"#include <asm/ltt/ltt-facility-id-%s_%s.h>\n\n",
+ fac->name,
+ fac->arch);
+ fprintf(fd,"ltt_facility_t\tltt_facility_%s;\n", fac->name);
+ fprintf(fd,"ltt_facility_t\tltt_facility_%s_%X;\n\n",
+ fac->name, fac->checksum);
+
+ fprintf(fd,"#define LTT_FACILITY_SYMBOL\t\t\t\t\t\t\tltt_facility_%s\n",
+ fac->name);
+ fprintf(fd,"#define LTT_FACILITY_CHECKSUM_SYMBOL\t\tltt_facility_%s_%X\n",
+ fac->name, fac->checksum);
+ fprintf(fd,"#define LTT_FACILITY_CHECKSUM\t\t\t\t\t\t0x%X\n", fac->checksum);
+ fprintf(fd,"#define LTT_FACILITY_NAME\t\t\t\t\t\t\t\t\"%s\"\n", fac->name);
+ fprintf(fd,"#define LTT_FACILITY_NUM_EVENTS\t\t\t\t\tfacility_%s_num_events\n\n",
+ fac->name);
+ fprintf(fd, "#endif //_LTT_FACILITY_LOADER_%s_H_\n", fac->capname);
+
+ fclose(fd);
+
+ return 0;
+}
+
+
+
+/* ltt-facility-loader-name.c : generic facility loader
+ * loader_c */
+int print_loader_c(facility_t *fac)
+{
+ char filename[PATH_MAX];
+ unsigned int filename_size = 0;
+ FILE *fd;
+ dprintf("%s\n", fac->name);
+
+ strcpy(filename, "ltt-facility-loader-");
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->name, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ if(fac->arch) {
+ strncat(filename, "_", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->arch, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+ }
+
+ strncat(filename, ".c", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+
+ fd = fopen(filename, "w");
+ if(fd == NULL) {
+ printf("Error opening file %s for writing : %s\n",
+ filename, strerror(errno));
+ return errno;
+ }
+
+ fprintf(fd, "/*\n");
+ if(!fac->arch)
+ fprintf(fd, " * ltt-facility-loader-%s.c\n", fac->name);
+ else
+ fprintf(fd, " * ltt-facility-loader-%s_%s.c\n", fac->name, fac->arch);
+ fprintf(fd, " *\n");
+ fprintf(fd, " * (C) Copyright 2005 - \n");
+ fprintf(fd, " * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)\n");
+ fprintf(fd, " *\n");
+ fprintf(fd, " * Contains the LTT facility loader.\n");
+ fprintf(fd, " *\n");
+ fprintf(fd, " */\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "#include <linux/ltt-facilities.h>\n");
+ fprintf(fd, "#include <linux/module.h>\n");
+ fprintf(fd, "#include <linux/init.h>\n");
+ fprintf(fd, "#include <linux/config.h>\n");
+ if(!fac->arch)
+ fprintf(fd, "#include \"ltt-facility-loader-%s.h\"\n", fac->name);
+ else
+ fprintf(fd, "#include \"ltt-facility-loader-%s_%s.h\"\n",
+ fac->name, fac->arch);
+ fprintf(fd, "\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "#ifdef CONFIG_LTT\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "EXPORT_SYMBOL(LTT_FACILITY_SYMBOL);\n");
+ fprintf(fd, "EXPORT_SYMBOL(LTT_FACILITY_CHECKSUM_SYMBOL);\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "static const char ltt_facility_name[] = LTT_FACILITY_NAME;\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "#define SYMBOL_STRING(sym) #sym\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "static struct ltt_facility facility = {\n");
+ fprintf(fd, "\t.name = ltt_facility_name,\n");
+ fprintf(fd, "\t.num_events = LTT_FACILITY_NUM_EVENTS,\n");
+ fprintf(fd, "\t.checksum = LTT_FACILITY_CHECKSUM,\n");
+ fprintf(fd, "\t.symbol = SYMBOL_STRING(LTT_FACILITY_SYMBOL),\n");
+ fprintf(fd, "};\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "static int __init facility_init(void)\n");
+ fprintf(fd, "{\n");
+ fprintf(fd, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init in kernel\\n\");\n", fac->name);
+ fprintf(fd, "\n");
+ fprintf(fd, "\tLTT_FACILITY_SYMBOL = ltt_facility_kernel_register(&facility);\n");
+ fprintf(fd, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
+ fprintf(fd, "\t\n");
+ fprintf(fd, "\treturn LTT_FACILITY_SYMBOL;\n");
+ fprintf(fd, "}\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "#ifndef MODULE\n");
+ fprintf(fd, "__initcall(facility_init);\n");
+ fprintf(fd, "#else\n");
+ fprintf(fd, "module_init(facility_init);\n");
+ fprintf(fd, "static void __exit facility_exit(void)\n");
+ fprintf(fd, "{\n");
+ fprintf(fd, "\tint err;\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "\terr = ltt_facility_unregister(LTT_FACILITY_SYMBOL);\n");
+ fprintf(fd, "\tif(err != 0)\n");
+ fprintf(fd, "\t\tprintk(KERN_ERR \"LTT : Error in unregistering facility.\\n\");\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "}\n");
+ fprintf(fd, "module_exit(facility_exit)\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "MODULE_LICENSE(\"GPL\");\n");
+ fprintf(fd, "MODULE_AUTHOR(\"Mathieu Desnoyers\");\n");
+ fprintf(fd, "MODULE_DESCRIPTION(\"Linux Trace Toolkit Facility\");\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "#endif //MODULE\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "#endif //CONFIG_LTT\n");
+
+ fclose(fd);
+
+ return 0;
+}
+
+int print_loader_c_user(facility_t *fac)
+{
+ char filename[PATH_MAX];
+ unsigned int filename_size = 0;
+ FILE *fd;
+ dprintf("%s\n", fac->name);
+
+ strcpy(filename, "ltt-facility-loader-");
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->name, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ if(fac->arch) {
+ strncat(filename, "_", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+ strncat(filename, fac->arch, PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+ }
+
+ strncat(filename, ".c", PATH_MAX - filename_size);
+ filename_size = strlen(filename);
+
+
+ fd = fopen(filename, "w");
+ if(fd == NULL) {
+ printf("Error opening file %s for writing : %s\n",
+ filename, strerror(errno));
+ return errno;
+ }
+
+ fprintf(fd, "/*\n");
+ if(!fac->arch)
+ fprintf(fd, " * ltt-facility-loader-%s.c\n", fac->name);
+ else
+ fprintf(fd, " * ltt-facility-loader-%s_%s.c\n", fac->name, fac->arch);
+ fprintf(fd, " *\n");
+ fprintf(fd, " * (C) Copyright 2005 - \n");
+ fprintf(fd, " * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)\n");
+ fprintf(fd, " *\n");
+ fprintf(fd, " * Contains the LTT user space facility loader.\n");
+ fprintf(fd, " *\n");
+ fprintf(fd, " */\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "#define LTT_TRACE\n");
+ fprintf(fd, "#include <error.h>\n");
+ fprintf(fd, "#include <stdio.h>\n");
+ fprintf(fd, "#include <ltt/ltt-usertrace.h>\n");
+ if(!fac->arch)
+ fprintf(fd, "#include \"ltt-facility-loader-%s.h\"\n", fac->name);
+ else
+ fprintf(fd, "#include \"ltt-facility-loader-%s_%s.h\"\n",
+ fac->name, fac->arch);
+ fprintf(fd, "\n");
+ fprintf(fd, "static struct user_facility_info facility = {\n");
+ fprintf(fd, "\t.name = LTT_FACILITY_NAME,\n");
+ fprintf(fd, "\t.num_events = LTT_FACILITY_NUM_EVENTS,\n");
+ fprintf(fd, "#ifndef LTT_PACK\n");
+ fprintf(fd, "\t.alignment = sizeof(void*),\n");
+ fprintf(fd, "#else\n");
+ fprintf(fd, "\t.alignment = 0,\n");
+ fprintf(fd, "#endif //LTT_PACK\n");
+ fprintf(fd, "\t.checksum = LTT_FACILITY_CHECKSUM,\n");
+ fprintf(fd, "\t.int_size = sizeof(int),\n");
+ fprintf(fd, "\t.long_size = sizeof(long),\n");
+ fprintf(fd, "\t.pointer_size = sizeof(void*),\n");
+ fprintf(fd, "\t.size_t_size = sizeof(size_t)\n");
+ fprintf(fd, "};\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "static void __attribute__((constructor)) __ltt_user_init(void)\n");
+ fprintf(fd, "{\n");
+ fprintf(fd, "\tint err;\n");
+ fprintf(fd, "#ifdef LTT_SHOW_DEBUG\n");
+ fprintf(fd, "\tprintf(\"LTT : ltt-facility-%s init in userspace\\n\");\n", fac->name);
+ fprintf(fd, "#endif //LTT_SHOW_DEBUG\n");
+ fprintf(fd, "\n");
+ fprintf(fd, "\terr = ltt_register_generic(<T_FACILITY_SYMBOL, &facility);\n");
+ fprintf(fd, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
+ fprintf(fd, "\t\n");
+ fprintf(fd, "\tif(err) {\n");
+ fprintf(fd, "#ifdef LTT_SHOW_DEBUG\n");
+ fprintf(fd, "\t\tperror(\"Error in ltt_register_generic\");\n");
+ fprintf(fd, "#endif //LTT_SHOW_DEBUG\n");
+ fprintf(fd, "\t}\n");
+ fprintf(fd, "}\n");
+ fprintf(fd, "\n");
+
+ fclose(fd);
+
+ return 0;
+}
+
+
+
+/* open facility */
+/* code taken from ltt_facility_open in ltt/facility.c in lttv */
+
+/*****************************************************************************
+ *Function name
+ * ltt_facility_open : open facilities
+ *Input params
+ * pathname : the path name of the facility
+ *
+ * Open the facility corresponding to the right checksum.
+ *
+ *returns the facility on success, NULL on error.
+ ****************************************************************************/
+facility_t *ltt_facility_open(char * pathname)
+{
+ int ret = 0;
+ char *token;
+ parse_file_t in;
+ facility_t * fac = NULL;
+ char buffer[BUFFER_SIZE];
+ int generated = FALSE;
+
+ in.buffer = &(buffer[0]);
+ in.lineno = 0;
+ in.error = error_callback;
+ in.name = pathname;
+ in.unget = 0;
+
+ in.fp = fopen(in.name, "r");
+ if(in.fp == NULL) {
+ ret = 1;
+ goto open_error;
+ }
+
+ while(1){
+ token = getToken(&in);
+ if(in.type == ENDFILE) break;
+
+ if(generated) {
+ printf("More than one facility in the file. Only using the first one.\n");
+ break;
+ }
+
+ if(strcmp(token, "<")) in.error(&in,"not a facility file");
+ token = getName(&in);
+ if(strcmp(token, "?")) in.error(&in,"not a facility file");
+ token = getName(&in);
+ if(strcmp(token, "xml")) in.error(&in,"not a facility file");
+ token = getName(&in);
+ if(strcmp(token, "version")) in.error(&in,"not a facility file");
+ token = getName(&in);
+ if(strcmp(token, "=")) in.error(&in,"not a facility file");
+ token = getQuotedString(&in);
+ if(strcmp(token, "1.0")) in.error(&in,"not a facility file");
+ token = getName(&in);
+ if(strcmp(token, "?")) in.error(&in,"not a facility file");
+ token = getToken(&in);
+ if(strcmp(token, ">")) in.error(&in,"not a facility file");
+
+ token = getName(&in);
+ if(strcmp(token, "<")) in.error(&in,"not a facility file");
+ token = getName(&in);
+ if(strcmp("facility",token) == 0) {
+ fac = malloc(sizeof(facility_t));
+ fac->name = NULL;
+ fac->description = NULL;
+ sequence_init(&(fac->events));
+ table_init(&(fac->named_types));
+ sequence_init(&(fac->unnamed_types));
+
+ parseFacility(&in, fac);
+
+ //check if any namedType is not defined
+ checkNamedTypesImplemented(&fac->named_types);
+
+ generateChecksum(fac->name, &fac->checksum, &fac->events);
+
+ generated = TRUE;
+ }
+ else {
+ printf("facility token was expected in file %s\n", in.name);
+ ret = 1;
+ goto parse_error;
+ }
+ }
+
+ parse_error:
+ fclose(in.fp);
+open_error:
+
+ if(!generated) {
+ printf("Cannot find facility %s\n", pathname);
+ fac = NULL;
+ }
+
+ return fac;
+}
+
+/* Close the facility */
+void ltt_facility_close(facility_t *fac)
+{
+ free(fac->name);
+ free(fac->capname);
+ free(fac->description);
+ freeEvents(&fac->events);
+ sequence_dispose(&fac->events);
+ freeNamedType(&fac->named_types);
+ table_dispose(&fac->named_types);
+ freeTypes(&fac->unnamed_types);
+ sequence_dispose(&fac->unnamed_types);
+ free(fac);
+}
+
+
+/* Show help */
+void show_help(int argc, char ** argv)
+{
+ printf("Genevent help : \n");
+ printf("\n");
+ printf("Use %s name.xml\n", argv[0]);
+ printf("to create :\n");
+ printf("ltt-facility-name.h\n");
+ printf("ltt-facility-id-name.h\n");
+ printf("ltt-facility-loader-name.h\n");
+ printf("ltt-facility-loader-name.c\n");
+ printf("In the current directory.\n");
+ printf("\n");
+}
+
+/* Parse program arguments */
+/* Return values :
+ * 0 : continue program
+ * -1 : stop program, return 0
+ * > 0 : stop program, return value as exit.
+ */
+int check_args(int argc, char **argv)
+{
+ if(argc < 2) {
+ printf("Not enough arguments\n");
+ show_help(argc, argv);
+ return EINVAL;
+ }
+
+ if(strcmp(argv[1], "-h") == 0) {
+ show_help(argc, argv);
+ return -1;
+ }
+
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ int err = 0;
+ facility_t *fac;
+
+ err = check_args(argc, argv);
+ if(err > 0) return err;
+ else if(err < 0) return 0;
+
+ /* open the facility */
+ fac = ltt_facility_open(argv[1]);
+ if(fac == NULL) {
+ printf("Error opening file %s for reading : %s\n",
+ argv[1], strerror(errno));
+ return errno;
+ }
+
+ /* generate the output C files */
+
+
+ /* ltt-facility-name.h : main logging header.
+ * log_header */
+ err = print_log_header(fac);
+ if(err) return err;
+
+ /* ltt-facility-id-name.h : facility id.
+ * log_id_header */
+ err = print_id_header(fac);
+ if(err) return err;
+
+ /* ltt-facility-loader-name.h : facility specific loader info.
+ * loader_header */
+ if(!fac->user)
+ err = print_loader_header(fac);
+ else
+ err = print_loader_header_user(fac);
+ if(err) return err;
+
+ /* ltt-facility-loader-name.c : generic faciilty loader
+ * loader_c */
+ if(!fac->user)
+ err = print_loader_c(fac);
+ else
+ err = print_loader_c_user(fac);
+ if(err) return err;
+
+ /* close the facility */
+ ltt_facility_close(fac);
+
+ return 0;
+}
+
+
--- /dev/null
+/******************************************************************************
+ * Genevent
+ *
+ * Event generator. XML to logging C code converter.
+ *
+ * Supports :
+ * - C Alignment
+ * - C types : struct, union, enum, basic types.
+ * - Architectures : LP32, ILP32, ILP64, LLP64, LP64.
+ *
+ * Additionnal structures supported :
+ * - embedded variable size strings
+ * - embedded variable size arrays
+ * - embedded variable size sequences
+ *
+ * Notes :
+ * (1)
+ * enums are limited to integer type, as this is what is used in C. Note,
+ * however, that ISO/IEC 9899:TC2 specify that the type of enum can be char,
+ * unsigned int or int. This is implementation defined (compiler). That's why we
+ * add a check for sizeof enum.
+ *
+ * (2)
+ * Because of archtecture defined type sizes, we need to ask for ltt_align
+ * (which gives the alignment) by passing basic types, not their actual sizes.
+ * It's up to ltt_align to determine sizes of types.
+ *
+ * Note that, from
+ * http://www.usenix.org/publications/login/standards/10.data.html
+ * (Andrew Josey <a.josey@opengroup.org>) :
+ *
+ * Data Type LP32 ILP32 ILP64 LLP64 LP64
+ * char 8 8 8 8 8
+ * short 16 16 16 16 16
+ * int32 32
+ * int 16 32 64 32 32
+ * long 32 32 64 32 64
+ * long long (int64) 64
+ * pointer 32 32 64 64 64
+ *
+ * With these constraints :
+ * sizeof(char) <= sizeof(short) <= sizeof(int)
+ * <= sizeof(long) = sizeof(size_t)
+ *
+ * and therefore sizeof(long) <= sizeof(pointer) <= sizeof(size_t)
+ *
+ * Which means we only have to remember which is the biggest type in a structure
+ * to know the structure's alignment.
+ */
+
+
+
+/* Code printing */
+
+/* Type size checking */
+int print_check(int fd);
+
+
+/* Print types */
+int print_types(int fd);
+
+/* Print events */
+int print_events(int fd);
+
+
+
--- /dev/null
+
+#define __KERNEL__
+
+#include <assert.h>
+#include <sys/types.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <linux/compiler.h>
+
+#define min(a,b) (((a)<(b))?a:b)
+#define max(a,b) (((a)>(b))?a:b)
+#define BUG_ON(a) assert(!(a))
+
+// Useful outside __KERNEL__. Not used here because inline is already redefined.
+#define force_inline inline __attribute__((always_inline))
+
+/* Calculate the offset needed to align the type */
+static inline unsigned int ltt_align(size_t align_drift,
+ size_t size_of_type)
+{
+ size_t alignment = min(sizeof(void*), size_of_type);
+
+ return ((alignment - align_drift) & (alignment-1));
+}
+
+
+/* TEMPLATE */
+
+enum lttng_tasklet_priority {
+ LTTNG_LOW,
+ LTTNG_HIGH,
+};
+
+enum lttng_irq_mode {
+ LTTNG_user,
+ LTTNG_kernel,
+};
+
+struct lttng_mystruct2 {
+ unsigned int irq_id;
+ enum lttng_irq_mode mode;
+ //struct lttng_mystruct teststr1;
+};
+
+#if 0
+static inline size_t lttng_get_size_mystruct2(
+ struct lttng_mystruct2 * obj)
+{
+ size_t size=0, locsize;
+
+ locsize = sizeof(unsigned int);
+ size += ltt_align(size, locsize) + locsize;
+
+ locsize = sizeof(enum lttng_irq_mode);
+ size += ltt_align(size, locsize) + locsize;
+
+ BUG_ON(sizeof(struct lttng_mystruct2) != size);
+
+ return sizeof(struct lttng_mystruct2);
+}
+#endif //0
+
+static inline size_t lttng_get_alignment_mystruct2(
+ struct lttng_mystruct2 *obj)
+{
+ size_t align=0, localign;
+
+ localign = sizeof(unsigned int);
+ align = max(align, localign);
+
+ localign = sizeof(enum lttng_irq_mode);
+ align = max(align, localign);
+
+ return align;
+}
+
+static inline void lttng_write_mystruct2(
+ void *buffer,
+ size_t *to_base,
+ size_t *to,
+ void **from,
+ size_t *len,
+ struct lttng_mystruct2 *obj)
+{
+ size_t align, size;
+
+ align = lttng_get_alignment_mystruct2(obj);
+ //size = lttng_get_size_mystruct2(obj);
+ size = sizeof(struct lttng_mystruct2);
+
+ if(*len == 0) {
+ *to += ltt_align(*to, align); /* align output */
+ } else {
+ *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
+ }
+
+ *len += size;
+}
+
+
+
+#define LTTNG_ARRAY_SIZE_mystruct_myarray 10
+typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];
+
+#if 0
+static inline size_t lttng_get_size_array_mystruct_myarray(
+ lttng_array_mystruct_myarray obj)
+{
+ size_t size=0, locsize;
+
+ locsize = sizeof(uint64_t);
+ /* ltt_align == 0 always*/
+ //size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
+ BUG_ON(ltt_align(size, locsize) != 0);
+ size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;
+
+ BUG_ON(sizeof(lttng_array_mystruct_myarray) != size);
+
+ return sizeof(lttng_array_mystruct_myarray);
+}
+#endif //0
+
+static inline size_t lttng_get_alignment_array_mystruct_myarray(
+ lttng_array_mystruct_myarray obj)
+{
+ size_t align=0, localign;
+
+ localign = sizeof(uint64_t);
+ align = max(align, localign);
+
+ return align;
+}
+
+
+static inline void lttng_write_array_mystruct_myarray(
+ void *buffer,
+ size_t *to_base,
+ size_t *to,
+ void **from,
+ size_t *len,
+ lttng_array_mystruct_myarray obj)
+{
+ size_t align, size;
+
+ align = lttng_get_alignment_array_mystruct_myarray(obj);
+ //size = lttng_get_size_array_mystruct_myarray(obj);
+ size = sizeof(lttng_array_mystruct_myarray);
+
+ if(*len == 0) {
+ *to += ltt_align(*to, align); /* align output */
+ } else {
+ *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
+ }
+
+ *len += size;
+#if 0
+ /* For varlen child : let the child align itself. */
+ for(unsigned int i=0; i<LTTNG_ARRAY_SIZE_mystruct_myarray; i++) {
+ lttng_write_child(buffer, to_base, to, from, len, obj[i]);
+ }
+#endif //0
+
+}
+
+
+typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence;
+struct lttng_sequence_mystruct_mysequence {
+ unsigned int len;
+ double *array;
+};
+
+#if 0
+static inline size_t lttng_get_size_sequence_mystruct_mysequence(
+ lttng_sequence_mystruct_mysequence *obj)
+{
+ size_t size=0, locsize;
+
+ locsize = sizeof(unsigned int);
+ size += ltt_align(size, locsize) + locsize;
+
+ locsize = sizeof(double);
+ size += ltt_align(size, locsize) + (obj->len * locsize);
+
+ /* Realign on arch size */
+ locsize = sizeof(void *);
+ size += ltt_align(size, locsize);
+
+ return size;
+}
+#endif //0
+
+static inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
+ lttng_sequence_mystruct_mysequence *obj)
+{
+ size_t align=0, localign;
+
+ localign = sizeof(unsigned int);
+ align = max(align, localign);
+
+ localign = sizeof(double);
+ align = max(align, localign);
+
+ return align;
+}
+
+
+static inline void lttng_write_sequence_mystruct_mysequence(
+ void *buffer,
+ size_t *to_base,
+ size_t *to,
+ void **from,
+ size_t *len,
+ lttng_sequence_mystruct_mysequence *obj)
+{
+ size_t align;
+ size_t size;
+
+ /* Flush pending memcpy */
+ if(*len != 0) {
+ if(buffer != NULL)
+ memcpy(buffer+*to_base+*to, *from, *len);
+ }
+ *to += *len;
+ *len = 0;
+
+ align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
+ //no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
+
+ /* Align output */
+ *to += ltt_align(*to, align); /* *len = 0 in this function */
+
+ /* Copy members */
+ size = sizeof(unsigned int);
+ *to += ltt_align(*to, size);
+ if(buffer != NULL)
+ memcpy(buffer+*to_base+*to, &obj->len, size);
+ *to += size;
+
+ size = sizeof(double);
+ *to += ltt_align(*to, size);
+ size = obj->len * sizeof(double);
+ if(buffer != NULL)
+ memcpy(buffer+*to_base+*to, obj->array, size);
+ *to += size;
+#if 0
+ /* If varlen child : let child align itself */
+ for(unsigned int i=0; i<obj->len; i++) {
+ lttng_write_child(buffer, to_base, to, from, len, obj->array[i]);
+ }
+#endif //0
+
+
+ /* Realign the *to_base on arch size, set *to to 0 */
+ *to = ltt_align(*to, sizeof(void *));
+ *to_base = *to_base+*to;
+ *to = 0;
+
+ /* Put source *from just after the C sequence */
+ *from = obj+1;
+}
+
+
+
+union lttng_mystruct_myunion {
+ double myfloat;
+ unsigned long myulong;
+};
+
+#if 0
+static inline size_t lttng_get_size_mystruct_myunion(
+ union lttng_mystruct_myunion *obj)
+{
+ size_t size=0, locsize;
+
+ locsize = sizeof(double);
+ size = max(size, locsize);
+
+ locsize = sizeof(unsigned long);
+ size = max(size, locsize);
+
+ BUG_ON(size != sizeof(union lttng_mystruct_myunion));
+
+ return sizeof(union lttng_mystruct_myunion);
+}
+#endif //0
+
+static inline size_t lttng_get_alignment_mystruct_myunion(
+ union lttng_mystruct_myunion *obj)
+{
+ size_t align=0, localign;
+
+ localign = sizeof(double);
+ align = max(align, localign);
+
+ localign = sizeof(unsigned long);
+ align = max(align, localign);
+
+ return align;
+}
+
+
+static inline void lttng_write_mystruct_myunion(
+ void *buffer,
+ size_t *to_base,
+ size_t *to,
+ void **from,
+ size_t *len,
+ union lttng_mystruct_myunion *obj)
+{
+ size_t align, size;
+
+ align = lttng_get_alignment_mystruct_myunion(obj);
+ //size = lttng_get_size_mystruct_myunion(obj);
+ size = sizeof(union lttng_mystruct_myunion);
+
+ if(*len == 0) {
+ *to += ltt_align(*to, align); /* align output */
+ } else {
+ *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
+ }
+
+ *len += size;
+
+ /* Assert : no varlen child. */
+}
+
+
+struct lttng_mystruct {
+ unsigned int irq_id;
+ enum lttng_irq_mode mode;
+ struct lttng_mystruct2 teststr;
+ lttng_array_mystruct_myarray myarray;
+ lttng_sequence_mystruct_mysequence mysequence;
+ union lttng_mystruct_myunion myunion;
+};
+
+#if 0
+static inline size_t lttng_get_size_mystruct(
+ struct lttng_mystruct *obj)
+{
+ size_t size=0, locsize, localign;
+
+ locsize = sizeof(unsigned int);
+ size += ltt_align(size, locsize) + locsize;
+
+ locsize = sizeof(enum lttng_irq_mode);
+ size += ltt_align(size, locsize) + locsize;
+
+ localign = lttng_get_alignment_mystruct2(&obj->teststr);
+ locsize = lttng_get_size_mystruct2(&obj->teststr);
+ size += ltt_align(size, localign) + locsize;
+
+ localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
+ locsize = lttng_get_size_array_mystruct_myarray(obj->myarray);
+ size += ltt_align(size, localign) + locsize;
+
+ localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
+ locsize = lttng_get_size_sequence_mystruct_mysequence(&obj->mysequence);
+ size += ltt_align(size, localign) + locsize;
+
+ localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
+ locsize = lttng_get_size_mystruct_myunion(&obj->myunion);
+ size += ltt_align(size, localign) + locsize;
+
+ return size;
+}
+#endif //0
+
+static inline size_t lttng_get_alignment_mystruct(
+ struct lttng_mystruct *obj)
+{
+ size_t align=0, localign;
+
+ localign = sizeof(unsigned int);
+ align = max(align, localign);
+
+ localign = sizeof(enum lttng_irq_mode);
+ align = max(align, localign);
+
+ localign = lttng_get_alignment_mystruct2(&obj->teststr);
+ align = max(align, localign);
+
+ localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
+ align = max(align, localign);
+
+ localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
+ align = max(align, localign);
+
+ localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
+ align = max(align, localign);
+
+ return align;
+}
+
+static inline void lttng_write_mystruct(
+ void *buffer,
+ size_t *to_base,
+ size_t *to,
+ void **from,
+ size_t *len,
+ struct lttng_mystruct *obj)
+{
+ size_t align, size;
+
+ align = lttng_get_alignment_mystruct(obj);
+ // no need : contains variable size fields.
+ // locsize = lttng_get_size_mystruct(obj);
+
+ if(*len == 0) {
+ *to += ltt_align(*to, align); /* align output */
+ } else {
+ *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
+ }
+
+ /* Contains variable sized fields : must explode the structure */
+
+ size = sizeof(unsigned int);
+ size += ltt_align(*to+*len, size) + size;
+ *len += size;
+
+ size = sizeof(enum lttng_irq_mode);
+ size += ltt_align(*to+*len, size) + size;
+ *len += size;
+
+ lttng_write_mystruct2(buffer, to_base, to, from, len, &obj->teststr);
+
+ lttng_write_array_mystruct_myarray(buffer, to_base, to, from, len, obj->myarray);
+
+ /* Variable length field */
+ lttng_write_sequence_mystruct_mysequence(buffer, to_base, to, from, len, &obj->mysequence);
+ /* After this previous write, we are sure that *to is 0, *len is 0 and
+ * *to_base is aligned on the architecture size : to rest of alignment will
+ * be calculated statically. */
+
+ lttng_write_mystruct_myunion(buffer, to_base, to, from, len, &obj->myunion);
+
+ /* Don't forget to flush last write..... */
+}
+
+
+
+
+
+
+//void main()
+void test()
+{
+ struct lttng_mystruct test;
+ test.mysequence.len = 20;
+ test.mysequence.array = malloc(20);
+
+ //size_t size = lttng_get_size_mystruct(&test);
+ //size_t align = lttng_get_alignment_mystruct(&test);
+ //
+ size_t to_base = 0; /* the buffer is allocated on arch_size alignment */
+ size_t to = 0;
+ void *from = &test;
+ size_t len = 0;
+
+ /* Get size */
+ lttng_write_mystruct(NULL, &to_base, &to, &from, &len, &test);
+ /* Size = to_base + to + len */
+
+ void *buffer = malloc(to_base + to + len);
+ to_base = 0; /* the buffer is allocated on arch_size alignment */
+ to = 0;
+ from = &test;
+ len = 0;
+
+ lttng_write_mystruct(buffer, &to_base, &to, &from, &len, &test);
+ /* Final flush */
+ /* Flush pending memcpy */
+ if(len != 0) {
+ // Assert buffer != NULL */
+ memcpy(buffer+to_base+to, from, len);
+ to += len;
+ from += len;
+ len = 0;
+ }
+
+ free(test.mysequence.array);
+ free(buffer);
+}
--- /dev/null
+#ifndef _LTT_FACILITY_TEST_H_
+#define _LTT_FACILITY_TEST_H_
+
+
+/* Facility activation at compile time. */
+#ifdef CONFIG_LTT_FACILITY_TEST
+
+/* Named types */
+
+
+enum lttng_tasklet_priority {
+ LTTNG_LOW,
+ LTTNG_HIGH,
+};
+
+enum lttng_irq_mode {
+ LTTNG_user,
+ LTTNG_kernel,
+};
+
+struct lttng_mystruct2 {
+ unsigned int irq_id;
+ enum lttng_irq_mode mode;
+ //struct lttng_mystruct teststr1;
+};
+
+
+size_t lttng_get_size_mystruct2(
+ struct lttng_mystruct2 *obj)
+{
+ size_t size=0, locsize;
+
+ locsize = sizeof(unsigned int);
+ size += ltt_align(size, locsize) + locsize;
+
+ locsize = sizeof(enum lttng_irq_mode);
+ size += ltt_align(size, locsize) + locsize;
+
+ BUG_ON(sizeof(struct lttng_mystruct2) != size);
+
+ return sizeof(struct lttng_mystruct2);
+}
+
+size_t lttng_get_alignment_mystruct2(
+ struct lttng_mystruct2 *obj)
+{
+ size_t align=0, localign;
+
+ localign = sizeof(unsigned int);
+ align = max(align, localign);
+
+ localign = sizeof(enum lttng_irq_mode);
+ align = max(align, localign);
+
+ return align;
+}
+
+void lttng_write_mystruct2(void **to,
+ void **from,
+ size_t *len,
+ struct lttng_mystruct2 *obj)
+{
+ size_t align, size;
+
+ align = lttng_get_alignment_mystruct2(obj);
+ size = lttng_get_size_mystruct2(obj);
+
+ if(*len == 0) {
+ *to += ltt_align((size_t)(*to), align); /* align output */
+ } else {
+ *len += ltt_align((size_t)(*to+*len), align); /* C alignment, ok to do a memcpy of it */
+ }
+
+ *len += size;
+}
+
+
+
+#define LTTNG_ARRAY_SIZE_mystruct_myarray 10
+typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];
+
+size_t lttng_get_size_array_mystruct_myarray(
+ lttng_array_mystruct_myarray obj)
+{
+ size_t size=0, locsize;
+
+ locsize = sizeof(uint64_t);
+ /* ltt_align == 0 always*/
+ //size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
+ BUG_ON(ltt_align(size, locsize) != 0);
+ size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;
+
+ BUG_ON(size != LTTNG_ARRAY_SIZE_mystruct_myarray * sizeof(uint64_t));
+
+ return size;
+}
+
+size_t lttng_get_alignment_array_mystruct_myarray(
+ lttng_array_mystruct_myarray obj)
+{
+ size_t align=0, localign;
+
+ localign = sizeof(uint64_t);
+ align = max(align, localign);
+
+ return align;
+}
+
+
+void lttng_write_array_mystruct_myarray(void **to,
+ void **from,
+ size_t *len,
+ lttng_array_mystruct_myarray obj)
+{
+ size_t align, size;
+
+ align = lttng_get_alignment_array_mystruct_myarray(obj);
+ size = lttng_get_size_array_mystruct_myarray(obj);
+
+ if(*len == 0) {
+ *to += ltt_align((size_t)(*to), align); /* align output */
+ } else {
+ *len += ltt_align((size_t)(*to+*len), align); /* C alignment, ok to do a memcpy of it */
+ }
+
+ *len += size;
+}
+
+
+typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence;
+struct lttng_sequence_mystruct_mysequence {
+ unsigned int len;
+ double *array;
+};
+
+
+size_t lttng_get_size_sequence_mystruct_mysequence(
+ lttng_sequence_mystruct_mysequence *obj)
+{
+ size_t size=0, locsize;
+
+ locsize = sizeof(unsigned int);
+ size += ltt_align(size, locsize) + locsize;
+
+ locsize = sizeof(double);
+ size += ltt_align(size, locsize) + (obj->len * locsize);
+
+ return size;
+}
+
+size_t lttng_get_alignment_sequence_mystruct_mysequence(
+ lttng_sequence_mystruct_mysequence *obj)
+{
+ size_t align=0, localign;
+
+ localign = sizeof(unsigned int);
+ align = max(align, localign);
+
+ localign = sizeof(double);
+ align = max(align, localign);
+
+ return align;
+}
+
+
+void lttng_write_sequence_mystruct_mysequence(void **to,
+ void **from,
+ size_t *len,
+ lttng_sequence_mystruct_mysequence *obj)
+{
+ size_t align, size;
+ void *varfrom;
+ size_t varlen=0;
+
+ /* Flush pending memcpy */
+ if(*len != 0) {
+ memcpy(*to, *from, *len);
+ *to += *len;
+ *len = 0;
+ }
+
+ align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
+ //no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
+
+ /* Align output */
+ *to += ltt_align((size_t)(*to), align);
+
+ /* Copy members */
+ *to += ltt_align((size_t)*to, sizeof(unsigned int));
+ varfrom = &obj->len;
+ varlen += sizeof(unsigned int);
+ memcpy(*to, varfrom, varlen);
+ *to += varlen;
+ varlen = 0;
+
+ *to += ltt_align((size_t)*to, sizeof(double));
+ varfrom = obj->array;
+ varlen += obj->len * sizeof(double);
+ memcpy(*to, varfrom, varlen);
+ *to += varlen;
+ varlen = 0;
+
+ /* Put source *from just after the C sequence */
+ *from = obj+1;
+}
+
+
+
+union lttng_mystruct_myunion {
+ double myfloat;
+ unsigned long myulong;
+};
+
+
+size_t lttng_get_size_mystruct_myunion(
+ union lttng_mystruct_myunion *obj)
+{
+ size_t size=0, locsize;
+
+ locsize = sizeof(double);
+ size = max(size, locsize);
+
+ locsize = sizeof(unsigned long);
+ size = max(size, locsize);
+
+ BUG_ON(size != sizeof(union lttng_mystruct_myunion));
+
+ return size;
+}
+
+
+size_t lttng_get_alignment_mystruct_myunion(
+ union lttng_mystruct_myunion *obj)
+{
+ size_t align=0, localign;
+
+ localign = sizeof(double);
+ align = max(align, localign);
+
+ localign = sizeof(unsigned long);
+ align = max(align, localign);
+
+ return align;
+}
+
+
+void lttng_write_mystruct_myunion(void **to,
+ void **from,
+ size_t *len,
+ union lttng_mystruct_myunion *obj)
+{
+ size_t align, size;
+
+ align = lttng_get_alignment_mystruct_myunion(obj);
+ size = lttng_get_size_mystruct_myunion(obj);
+
+ if(*len == 0) {
+ *to += ltt_align((size_t)(*to), align); /* align output */
+ } else {
+ *len += ltt_align((size_t)(*to+*len), align); /* C alignment, ok to do a memcpy of it */
+ }
+
+ *len += size;
+}
+
+
+struct lttng_mystruct {
+ unsigned int irq_id;
+ enum lttng_irq_mode mode;
+ struct lttng_mystruct2 teststr;
+ lttng_array_mystruct_myarray myarray;
+ lttng_sequence_mystruct_mysequence mysequence;
+ union lttng_mystruct_myunion myunion;
+};
+
+size_t lttng_get_size_mystruct(
+ struct lttng_mystruct *obj)
+{
+ size_t size=0, locsize, localign;
+
+ locsize = sizeof(unsigned int);
+ size += ltt_align(size, locsize) + locsize;
+
+ locsize = sizeof(enum lttng_irq_mode);
+ size += ltt_align(size, locsize) + locsize;
+
+ localign = lttng_get_alignment_mystruct2(&obj->teststr);
+ locsize = lttng_get_size_mystruct2(&obj->teststr);
+ size += ltt_align(size, localign) + locsize;
+
+ localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
+ locsize = lttng_get_size_array_mystruct_myarray(obj->myarray);
+ size += ltt_align(size, localign) + locsize;
+
+ localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
+ locsize = lttng_get_size_sequence_mystruct_mysequence(&obj->mysequence);
+ size += ltt_align(size, localign) + locsize;
+
+ localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
+ locsize = lttng_get_size_mystruct_myunion(&obj->myunion);
+ size += ltt_align(size, localign) + locsize;
+
+ return size;
+}
+
+
+size_t lttng_get_alignment_mystruct(
+ struct lttng_mystruct *obj)
+{
+ size_t align=0, localign;
+
+ localign = sizeof(unsigned int);
+ align = max(align, localign);
+
+ localign = sizeof(enum lttng_irq_mode);
+ align = max(align, localign);
+
+ localign = lttng_get_alignment_mystruct2(&obj->teststr);
+ align = max(align, localign);
+
+ localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
+ align = max(align, localign);
+
+ localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
+ align = max(align, localign);
+
+ localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
+ align = max(align, localign);
+
+ return align;
+}
+
+void lttng_write_mystruct(void **to,
+ void **from,
+ size_t *len,
+ struct lttng_mystruct *obj)
+{
+ size_t align, size;
+
+ align = lttng_get_alignment_mystruct(obj);
+ // no need : contains variable size fields.
+ // locsize = lttng_get_size_mystruct(obj);
+
+ if(*len == 0) {
+ *to += ltt_align((size_t)(*to), align); /* align output */
+ } else {
+ *len += ltt_align((size_t)(*to+*len), align); /* C alignment, ok to do a memcpy of it */
+ }
+
+ /* Contains variable sized fields : must explode the structure */
+
+ size = sizeof(unsigned int);
+ *len += ltt_align((size_t)(*to+*len), size) + size;
+
+ size = sizeof(enum lttng_irq_mode);
+ *len += ltt_align((size_t)(*to+*len), size) + size;
+
+ lttng_write_mystruct2(to, from, len, &obj->teststr);
+
+ lttng_write_array_mystruct_myarray(to, from, len, obj->myarray);
+
+ /* Variable length field */
+ lttng_write_sequence_mystruct_mysequence(to, from, len, &obj->mysequence);
+
+ lttng_write_mystruct_myunion(to, from, len, &obj->myunion);
+
+ /* Don't forget to flush last write..... */
+}
+
+
+
+
+/* Event syscall_entry structures */
+
+/* Event syscall_entry logging function */
+static inline void trace_test_syscall_entry(
+ unsigned int syscall_id,
+ void * address)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+/* Event syscall_exit structures */
+
+/* Event syscall_exit logging function */
+static inline void trace_test_syscall_exit(
+ void)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+/* Event trap_entry structures */
+
+/* Event trap_entry logging function */
+static inline void trace_test_trap_entry(
+ unsigned int trap_id,
+ void * address)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+/* Event trap_exit structures */
+
+/* Event trap_exit logging function */
+static inline void trace_test_trap_exit(
+ void)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+/* Event soft_irq_entry structures */
+
+/* Event soft_irq_entry logging function */
+static inline void trace_test_soft_irq_entry(
+ void * softirq_id)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+/* Event soft_irq_exit structures */
+
+/* Event soft_irq_exit logging function */
+static inline void trace_test_soft_irq_exit(
+ void * softirq_id)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+/* Event tasklet_entry structures */
+
+/* Event tasklet_entry logging function */
+static inline void trace_test_tasklet_entry(
+ enum lttng_tasklet_priority priority,
+ void * address,
+ unsigned long data)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+/* Event tasklet_exit structures */
+
+/* Event tasklet_exit logging function */
+static inline void trace_test_tasklet_exit(
+ enum lttng_tasklet_priority priority,
+ void * address,
+ unsigned long data)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+/* Event irq_entry structures */
+
+/* Event irq_entry logging function */
+static inline void trace_test_irq_entry(
+ unsigned int irq_id,
+ enum lttng_irq_mode mode)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+/* Event irq_exit structures */
+
+/* Event irq_exit logging function */
+static inline void trace_test_irq_exit(
+ void)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+/* Event big_array structures */
+union lttng_test_big_array_myarray_b {
+ void * c;
+};
+
+struct lttng_test_big_array_myarray {
+ void * a;
+ union lttng_test_big_array_myarray_b b;
+};
+
+#define LTTNG_ARRAY_SIZE_test_big_array_myarray 2
+typedef struct lttng_test_big_array_myarray lttng_array_test_big_array_myarray[LTTNG_ARRAY_SIZE_test_big_array_myarray];
+
+#define LTTNG_ARRAY_SIZE_test_big_array_myarray 10000
+typedef lttng_array_test_big_array_myarray lttng_array_test_big_array_myarray[LTTNG_ARRAY_SIZE_test_big_array_myarray];
+
+
+/* Event big_array logging function */
+static inline void trace_test_big_array(
+ lttng_array_test_big_array_myarray myarray)
+#ifndef CONFIG_LTT
+{
+}
+#else
+{
+}
+#endif //CONFIG_LTT
+
+
+#endif //CONFIG_LTT_FACILITY_TEST
+
+#endif //_LTT_FACILITY_TEST_H_
--- /dev/null
+/*
+
+parser.c: Generate helper declarations and functions to trace events
+ from an event description file.
+
+ Copyright (C) 2005, Mathieu Desnoyers
+ Copyright (C) 2002, Xianxiu Yang
+ Copyright (C) 2002, Michel Dagenais
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; version 2 of the License.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+/* This program reads the ".xml" event definitions input files
+ and constructs structure for each event.
+
+ The program uses a very simple tokenizer, called from a hand written
+ recursive descent parser to fill a data structure describing the events.
+ The result is a sequence of events definitions which refer to type
+ definitions.
+
+ A table of named types is maintained to allow refering to types by name
+ when the same type is used at several places. Finally a sequence of
+ all types is maintained to facilitate the freeing of all type
+ information when the processing of an ".xml" file is finished. */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <linux/errno.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "parser.h"
+
+
+char *intOutputTypes[] = {
+ "int8_t", "int16_t", "int32_t", "int64_t" };
+
+char *uintOutputTypes[] = {
+ "uint8_t", "uint16_t", "uint32_t", "uint64_t" };
+
+char *floatOutputTypes[] = {
+ "undef", "undef", "float", "double" };
+
+
+
+
+/* helper function */
+void strupper(char *string)
+{
+ char *ptr = string;
+
+ while(*ptr != '\0') {
+ *ptr = toupper(*ptr);
+ ptr++;
+ }
+}
+
+
+int getSizeindex(unsigned int value)
+{
+ switch(value) {
+ case 1:
+ return 0;
+ case 2:
+ return 1;
+ case 4:
+ return 2;
+ case 8:
+ return 3;
+ default:
+ printf("Error : unknown value size %d\n", value);
+ exit(-1);
+ }
+}
+
+/*****************************************************************************
+ *Function name
+ * getSize : translate from string to integer
+ *Input params
+ * in : input file handle
+ *Return values
+ * size
+ *****************************************************************************/
+
+unsigned long long int getSize(parse_file_t *in)
+{
+ char *token, *token2;
+ unsigned long long int ret;
+
+ token = getToken(in);
+
+
+ if(in->type == QUOTEDSTRING) {
+ in->type = NUMBER;
+ token2 = token;
+ do {
+ if (!isdigit(*token2)) {
+ in->type = QUOTEDSTRING;
+ break;
+ }
+ } while (*(++token2) != '\0');
+ }
+
+ if(in->type == NUMBER) {
+ ret = strtoull(token, NULL, 0);
+ } else {
+ goto error;
+ }
+
+ return ret;
+error:
+ in->error(in,"incorrect size specification");
+ return -1;
+}
+
+/*****************************************************************************
+ *Function name
+ * error_callback : print out error info
+ *Input params
+ * in : input file handle
+ * msg : message to be printed
+ ****************************************************************************/
+
+void error_callback(parse_file_t *in, char *msg)
+{
+ if(in)
+ printf("Error in file %s, line %d: %s\n", in->name, in->lineno, msg);
+ else
+ printf("%s\n",msg);
+ assert(0);
+ exit(1);
+}
+
+/*****************************************************************************
+ *Function name
+ * memAlloc : allocate memory
+ *Input params
+ * size : required memory size
+ *return value
+ * void * : pointer to allocate memory or NULL
+ ****************************************************************************/
+
+void * memAlloc(int size)
+{
+ void * addr;
+ if(size == 0) return NULL;
+ addr = malloc(size);
+ if(!addr){
+ printf("Failed to allocate memory");
+ exit(1);
+ }
+ return addr;
+}
+
+/*****************************************************************************
+ *Function name
+ * allocAndCopy : allocate memory and initialize it
+ *Input params
+ * str : string to be put in memory
+ *return value
+ * char * : pointer to allocate memory or NULL
+ ****************************************************************************/
+
+char *allocAndCopy(char *str)
+{
+ char * addr;
+ if(str == NULL) return NULL;
+ addr = (char *)memAlloc(strlen(str)+1);
+ strcpy(addr,str);
+ return addr;
+}
+
+/**************************************************************************
+ * Function :
+ * getTypeAttributes
+ * Description :
+ * Read the attribute from the input file.
+ *
+ * Parameters :
+ * in , input file handle.
+ * t , the type descriptor to fill.
+ *
+ **************************************************************************/
+
+void getTypeAttributes(parse_file_t *in, type_descriptor_t *t,
+ sequence_t * unnamed_types, table_t * named_types)
+{
+ char * token;
+ char car;
+
+ t->fmt = NULL;
+ t->size = 0;
+ t->custom_write = 0;
+ t->network = 0;
+
+ while(1) {
+ token = getToken(in);
+ if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
+ ungetToken(in);
+ break;
+ }
+
+ if(!strcmp("format",token)) {
+ getEqual(in);
+ t->fmt = allocAndCopy(getQuotedString(in));
+ //} else if(!strcmp("name",token)) {
+ // getEqual(in);
+ // car = seekNextChar(in);
+ // if(car == EOF) in->error(in,"name was expected");
+ // else if(car == '\"') t->type_name = allocAndCopy(getQuotedString(in));
+ // else t->type_name = allocAndCopy(getName(in));
+ } else if(!strcmp("size",token)) {
+ getEqual(in);
+ t->size = getSize(in);
+ } else if(!strcmp("custom_write", token)) {
+ t->custom_write = 1;
+ } else if(!strcmp("byte_order",token)) {
+ getEqual(in);
+ car = seekNextChar(in);
+ if(car == EOF) in->error(in,"byte order was expected (network?)");
+ else if(car == '\"') token = getQuotedString(in);
+ else token = getName(in);
+ if(!strcmp("network", token)) {
+ t->network = 1;
+ }
+ } else if(!strcmp("write",token)) {
+ getEqual(in);
+ car = seekNextChar(in);
+ if(car == EOF) in->error(in,"write type was expected (custom?)");
+ else if(car == '\"') token = getQuotedString(in);
+ else token = getName(in);
+ if(!strcmp("custom", token)) {
+ t->custom_write = 1;
+ }
+ }
+ }
+}
+
+/**************************************************************************
+ * Function :
+ * getEventAttributes
+ * Description :
+ * Read the attribute from the input file.
+ *
+ * Parameters :
+ * in , input file handle.
+ * ev , the event to fill.
+ *
+ **************************************************************************/
+
+void getEventAttributes(parse_file_t *in, event_t *ev)
+{
+ char * token;
+ char car;
+
+ ev->name = NULL;
+ ev->per_trace = 0;
+ ev->per_tracefile = 0;
+ ev->param_buffer = 0;
+ ev->no_instrument_function = 0;
+
+ while(1) {
+ token = getToken(in);
+ if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
+ ungetToken(in);
+ break;
+ }
+
+ if(!strcmp("name",token)) {
+ getEqual(in);
+ car = seekNextChar(in);
+ if(car == EOF) in->error(in,"name was expected");
+ else if(car == '\"') ev->name = allocAndCopy(getQuotedString(in));
+ else ev->name = allocAndCopy(getName(in));
+ } else if(!strcmp("scope", token)) {
+ getEqual(in);
+ car = seekNextChar(in);
+ if(car == EOF) in->error(in,"scope was expected");
+ else if(car == '\"') token = getQuotedString(in);
+ else token = getName(in);
+ if(!strcmp(token, "trace")) ev->per_trace = 1;
+ else if(!strcmp(token, "tracefile")) ev->per_tracefile = 1;
+ } else if(!strcmp("param", token)) {
+ getEqual(in);
+ car = seekNextChar(in);
+ if(car == EOF) in->error(in,"parameter type was expected");
+ else if(car == '\"') token = getQuotedString(in);
+ else token = getName(in);
+ if(!strcmp(token, "buffer")) ev->param_buffer = 1;
+ } else if(!strcmp("attribute", token)) {
+ getEqual(in);
+ car = seekNextChar(in);
+ if(car == EOF) in->error(in,"attribute was expected");
+ else if(car == '\"') token = getQuotedString(in);
+ else token = getName(in);
+ if(!strcmp(token, "no_instrument_function"))
+ ev->no_instrument_function = 1;
+ }
+ }
+}
+
+/**************************************************************************
+ * Function :
+ * getFacilityAttributes
+ * Description :
+ * Read the attribute from the input file.
+ *
+ * Parameters :
+ * in , input file handle.
+ * fac , the facility to fill.
+ *
+ **************************************************************************/
+
+void getFacilityAttributes(parse_file_t *in, facility_t *fac)
+{
+ char * token;
+ char car;
+
+ fac->name = NULL;
+ fac->arch = NULL;
+ fac->user = 0;
+
+ while(1) {
+ token = getToken(in);
+ if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
+ ungetToken(in);
+ break;
+ }
+
+ if(!strcmp("name",token)) {
+ getEqual(in);
+ car = seekNextChar(in);
+ if(car == EOF) in->error(in,"name was expected");
+ else if(car == '\"') fac->name = allocAndCopy(getQuotedString(in));
+ else fac->name = allocAndCopy(getName(in));
+ if(!strncmp(fac->name, "user_", sizeof("user_")-1))
+ fac->user = 1;
+ } else if(!strcmp("arch", token)) {
+ getEqual(in);
+ car = seekNextChar(in);
+ if(car == '\"') fac->arch = allocAndCopy(getQuotedString(in));
+ else fac->arch = allocAndCopy(getName(in));
+ }
+ }
+}
+
+/**************************************************************************
+ * Function :
+ * getFieldAttributes
+ * Description :
+ * Read the attribute from the input file.
+ *
+ * Parameters :
+ * in , input file handle.
+ * f , the field to fill.
+ *
+ **************************************************************************/
+
+void getFieldAttributes(parse_file_t *in, field_t *f)
+{
+ char * token;
+ char car;
+
+ f->name = NULL;
+
+ while(1) {
+ token = getToken(in);
+ if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
+ ungetToken(in);
+ break;
+ }
+
+ if(!strcmp("name",token)) {
+ getEqual(in);
+ car = seekNextChar(in);
+ if(car == EOF) in->error(in,"name was expected");
+ else if(car == '\"') f->name = allocAndCopy(getQuotedString(in));
+ else f->name = allocAndCopy(getName(in));
+ }
+ }
+}
+
+char *getNameAttribute(parse_file_t *in)
+{
+ char * token;
+ char *name = NULL;
+ char car;
+
+ while(1) {
+ token = getToken(in);
+ if(!strcmp("name",token)) {
+ getEqual(in);
+ car = seekNextChar(in);
+ if(car == EOF) in->error(in,"name was expected");
+ else if(car == '\"') name = allocAndCopy(getQuotedString(in));
+ else name = allocAndCopy(getName(in));
+ } else {
+ ungetToken(in);
+ break;
+ }
+
+ }
+ if(name == NULL) in->error(in, "Name was expected");
+ return name;
+}
+
+
+
+//for <label name=label_name value=n format="...">, value is an option
+//Return value : 0 : no value, 1 : has a value
+int getValueAttribute(parse_file_t *in, long long *value)
+{
+ char * token, *token2;
+
+ token = getToken(in);
+
+ if(strcmp("/",token) == 0 || strcmp(">", token) == 0){
+ ungetToken(in);
+ return 0;
+ }
+ if(strcmp("value",token))in->error(in,"value was expected");
+
+ getEqual(in);
+ token = getToken(in);
+
+ if(in->type == QUOTEDSTRING) {
+ in->type = NUMBER;
+ token2 = token;
+ do {
+ if (!isdigit(*token2)) {
+ in->type = QUOTEDSTRING;
+ break;
+ }
+ } while (*(++token2) != '\0');
+ }
+
+ if(in->type == NUMBER)
+ *value = strtoll(token, NULL, 0);
+ else
+ goto error;
+ return 1;
+error:
+ in->error(in,"incorrect size specification");
+ return 0;
+}
+
+char * getDescription(parse_file_t *in)
+{
+ long int pos;
+ char * token, car, *str;
+
+ pos = ftell(in->fp);
+
+ getLAnglebracket(in);
+ token = getName(in);
+ if(strcmp("description",token)){
+ fseek(in->fp, pos, SEEK_SET);
+ return NULL;
+ }
+
+ getRAnglebracket(in);
+
+ pos = 0;
+ while((car = getc(in->fp)) != EOF) {
+ if(car == '<') break;
+ if(car == '\0') continue;
+ in->buffer[pos] = car;
+ pos++;
+ }
+ if(car == EOF)in->error(in,"not a valid description");
+ in->buffer[pos] = '\0';
+
+ str = allocAndCopy(in->buffer);
+
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("description", token))in->error(in,"not a valid description");
+ getRAnglebracket(in);
+
+ return str;
+}
+
+/*****************************************************************************
+ *Function name
+ * parseFacility : generate event list
+ *Input params
+ * in : input file handle
+ * fac : empty facility
+ *Output params
+ * fac : facility filled with event list
+ ****************************************************************************/
+
+void parseFacility(parse_file_t *in, facility_t * fac)
+{
+ char * token;
+ event_t *ev;
+
+ getFacilityAttributes(in, fac);
+ if(fac->name == NULL) in->error(in, "Attribute not named");
+
+ fac->capname = allocAndCopy(fac->name);
+ strupper(fac->capname);
+ getRAnglebracket(in);
+
+ fac->description = getDescription(in);
+
+ while(1){
+ getLAnglebracket(in);
+
+ token = getToken(in);
+ if(in->type == ENDFILE)
+ in->error(in,"the definition of the facility is not finished");
+
+ if(strcmp("event",token) == 0){
+ ev = (event_t*) memAlloc(sizeof(event_t));
+ sequence_push(&(fac->events),ev);
+ parseEvent(in,ev, &(fac->unnamed_types), &(fac->named_types));
+ }else if(strcmp("type",token) == 0){
+ parseTypeDefinition(in, &(fac->unnamed_types), &(fac->named_types));
+ }else if(in->type == FORWARDSLASH){
+ break;
+ }else in->error(in,"event or type token expected\n");
+ }
+
+ token = getName(in);
+ if(strcmp("facility",token)) in->error(in,"not the end of the facility");
+ getRAnglebracket(in); //</facility>
+}
+
+/*****************************************************************************
+ *Function name
+ * parseEvent : generate event from event definition
+ *Input params
+ * in : input file handle
+ * ev : new event
+ * unnamed_types : array of unamed types
+ * named_types : array of named types
+ *Output params
+ * ev : new event (parameters are passed to it)
+ ****************************************************************************/
+
+void parseEvent(parse_file_t *in, event_t * ev, sequence_t * unnamed_types,
+ table_t * named_types)
+{
+ char *token;
+ field_t *f;
+
+ sequence_init(&(ev->fields));
+ //<event name=eventtype_name>
+ getEventAttributes(in, ev);
+ if(ev->name == NULL) in->error(in, "Event not named");
+ getRAnglebracket(in);
+
+ //<description>...</description>
+ ev->description = getDescription(in);
+
+ int got_end = 0;
+ /* Events can have multiple fields. each field form at least a function
+ * parameter of the logging function. */
+ while(!got_end) {
+ getLAnglebracket(in);
+ token = getToken(in);
+
+ switch(in->type) {
+ case FORWARDSLASH: /* </event> */
+ token = getName(in);
+ if(strcmp("event",token))in->error(in,"not an event definition");
+ getRAnglebracket(in); //</event>
+ got_end = 1;
+ break;
+ case NAME: /* a field */
+ if(strcmp("field",token))in->error(in,"expecting a field");
+ f = (field_t *)memAlloc(sizeof(field_t));
+ sequence_push(&(ev->fields),f);
+ parseFields(in, f, unnamed_types, named_types, 1);
+ break;
+ default:
+ in->error(in, "expecting </event> or <field >");
+ break;
+ }
+ }
+#if 0
+ if(in->type == FORWARDSLASH){ //</event> NOTHING
+ ev->type = NULL;
+ }else if(in->type == NAME){
+ if(strcmp("struct",token)==0 || strcmp("typeref",token)==0){
+ ungetToken(in);
+ ev->type = parseType(in,NULL, unnamed_types, named_types);
+ if(ev->type->type != STRUCT && ev->type->type != NONE)
+ in->error(in,"type must be a struct");
+ }else in->error(in, "not a valid type");
+
+ getLAnglebracket(in);
+ getForwardslash(in);
+ }else in->error(in,"not a struct type");
+ getLAnglebracket(in);
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("event",token))in->error(in,"not an event definition");
+ getRAnglebracket(in); //</event>
+#endif //0
+}
+
+/*****************************************************************************
+ *Function name
+ * parseField : get field infomation from buffer
+ *Input params
+ * in : input file handle
+ * f : field
+ * unnamed_types : array of unamed types
+ * named_types : array of named types
+ * tag : is field surrounded by a <field> </field> tag ?
+ ****************************************************************************/
+
+void parseFields(parse_file_t *in, field_t *f,
+ sequence_t * unnamed_types,
+ table_t * named_types,
+ int tag)
+{
+ char * token;
+ if(tag) {
+ //<field name=field_name> <description> <type> </field>
+ getFieldAttributes(in, f);
+ if(f->name == NULL) in->error(in, "Field not named");
+ getRAnglebracket(in);
+
+ f->description = getDescription(in);
+ } else {
+ f->description = NULL;
+ }
+
+ //<int size=...>
+ getLAnglebracket(in);
+ f->type = parseType(in,NULL, unnamed_types, named_types);
+
+ if(tag) {
+ getLAnglebracket(in);
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("field",token))in->error(in,"not a valid field definition");
+ getRAnglebracket(in); //</field>
+ }
+}
+
+
+/*****************************************************************************
+ *Function name
+ * parseType : get type information, type can be :
+ * Primitive:
+ * int(size,fmt); uint(size,fmt); float(size,fmt);
+ * string(fmt); enum(size,fmt,(label1,label2...))
+ * Compound:
+ * array(arraySize, type); sequence(lengthSize,type)
+ * struct(field(name,type,description)...)
+ * type name:
+ * type(name,type)
+ *Input params
+ * in : input file handle
+ * inType : a type descriptor
+ * unnamed_types : array of unamed types
+ * named_types : array of named types
+ *Return values
+ * type_descriptor* : a type descriptor
+ ****************************************************************************/
+
+type_descriptor_t *parseType(parse_file_t *in, type_descriptor_t *inType,
+ sequence_t * unnamed_types, table_t * named_types)
+{
+ char *token;
+ type_descriptor_t *t;
+ field_t *f;
+
+ if(inType == NULL) {
+ t = (type_descriptor_t *) memAlloc(sizeof(type_descriptor_t));
+ t->type_name = NULL;
+ t->type = NONE;
+ t->fmt = NULL;
+ sequence_push(unnamed_types,t);
+ }
+ else t = inType;
+
+ token = getName(in);
+
+ if(strcmp(token,"struct") == 0) {
+ t->type = STRUCT;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getRAnglebracket(in); //<struct>
+ getLAnglebracket(in); //<field name=..>
+ token = getToken(in);
+ sequence_init(&(t->fields));
+ while(strcmp("field",token) == 0){
+ f = (field_t *)memAlloc(sizeof(field_t));
+ sequence_push(&(t->fields),f);
+
+ parseFields(in, f, unnamed_types, named_types, 1);
+
+ //next field
+ getLAnglebracket(in);
+ token = getToken(in);
+ }
+ if(strcmp("/",token))in->error(in,"not a valid structure definition");
+ token = getName(in);
+ if(strcmp("struct",token)!=0)
+ in->error(in,"not a valid structure definition");
+ getRAnglebracket(in); //</struct>
+ }
+ else if(strcmp(token,"union") == 0) {
+ t->type = UNION;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getRAnglebracket(in); //<union>
+
+ getLAnglebracket(in); //<field name=..>
+ token = getToken(in);
+ sequence_init(&(t->fields));
+ while(strcmp("field",token) == 0){
+ f = (field_t *)memAlloc(sizeof(field_t));
+ sequence_push(&(t->fields),f);
+ parseFields(in, f, unnamed_types, named_types, 1);
+
+ //next field
+ getLAnglebracket(in);
+ token = getToken(in);
+ }
+ if(strcmp("/",token))in->error(in,"not a valid union definition");
+ token = getName(in);
+ if(strcmp("union",token)!=0)
+ in->error(in,"not a valid union definition");
+ getRAnglebracket(in); //</union>
+ }
+ else if(strcmp(token,"array") == 0) {
+ t->type = ARRAY;
+ sequence_init(&(t->fields));
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ if(t->size == 0) in->error(in, "Array has empty size");
+ getForwardslash(in);
+ getRAnglebracket(in); //<array size=n>
+
+ //getLAnglebracket(in); //<subtype>
+ /* subfield */
+ f = (field_t *)memAlloc(sizeof(field_t));
+ sequence_push(&(t->fields),f);
+ parseFields(in, f, unnamed_types, named_types, 0);
+
+ //getLAnglebracket(in); //<type struct>
+ //t->nested_type = parseType(in, NULL, unnamed_types, named_types);
+
+ getLAnglebracket(in); //</array>
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("array",token))in->error(in,"not a valid array definition");
+ getRAnglebracket(in); //</array>
+ }
+ else if(strcmp(token,"sequence") == 0) {
+ t->type = SEQUENCE;
+ sequence_init(&(t->fields));
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in); //<sequence>
+
+ //getLAnglebracket(in); //<sequence size type>
+ /* subfield */
+ f = (field_t *)memAlloc(sizeof(field_t));
+ sequence_push(&(t->fields),f);
+ parseFields(in, f, unnamed_types, named_types, 0);
+
+ //getLAnglebracket(in); //<subtype>
+ /* subfield */
+ f = (field_t *)memAlloc(sizeof(field_t));
+ sequence_push(&(t->fields),f);
+ parseFields(in, f, unnamed_types, named_types, 0);
+
+ //getLAnglebracket(in); //<type sequence>
+ //t->length_type = parseType(in, NULL, unnamed_types, named_types);
+
+ //getLAnglebracket(in); //<type sequence>
+
+ //t->nested_type = parseType(in, NULL, unnamed_types, named_types);
+
+ if(t->fields.position < 1) in->error(in, "Sequence has no length type");
+ if(t->fields.position < 2) in->error(in, "Sequence has no subtype");
+ switch(((field_t*)t->fields.array[0])->type->type) {
+ case UINT_FIXED :
+ case UCHAR :
+ case USHORT :
+ case UINT :
+ case ULONG :
+ case SIZE_T :
+ case OFF_T :
+ break;
+ default:
+ in->error(in, "Wrong length type for sequence");
+ }
+
+ getLAnglebracket(in); //</sequence>
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("sequence",token))in->error(in,"not a valid sequence definition");
+ getRAnglebracket(in); //</sequence>
+ }
+ else if(strcmp(token,"enum") == 0) {
+ char * str;
+ long long value = -1;
+
+ t->type = ENUM;
+ sequence_init(&(t->labels));
+ sequence_init(&(t->labels_values));
+ sequence_init(&(t->labels_description));
+ t->already_printed = 0;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ //if(t->size == 0) in->error(in, "Sequence has empty size");
+ //Mathieu : we fix enum size to target int size. GCC is always like this.
+ //fox copy optimisation.
+ if(t->size != 0) in->error(in, "Enum has fixed size of target int.");
+ t->size = 0;
+ getRAnglebracket(in);
+
+ //<label name=label1 value=n/>
+ getLAnglebracket(in);
+ token = getToken(in); //"label" or "/"
+ while(strcmp("label",token) == 0){
+ int *label_value = malloc(sizeof(int));
+ int has_value = 0;
+ long long loc_value;
+
+ str = allocAndCopy(getNameAttribute(in));
+ has_value = getValueAttribute(in, &loc_value);
+
+ sequence_push(&(t->labels),str);
+
+ if(has_value) value = loc_value;
+ else value++;
+
+ *label_value = value;
+ sequence_push(&(t->labels_values), label_value);
+
+ getForwardslash(in);
+ getRAnglebracket(in);
+
+ //read description if any. May be NULL.
+ str = allocAndCopy(getDescription(in));
+ sequence_push(&(t->labels_description),str);
+
+ //next label definition
+ getLAnglebracket(in);
+ token = getToken(in); //"label" or "/"
+ }
+ if(strcmp("/",token))in->error(in, "not a valid enum definition");
+ token = getName(in);
+ if(strcmp("enum",token))in->error(in, "not a valid enum definition");
+ getRAnglebracket(in); //</label>
+ }
+ else if(strcmp(token,"int_fixed") == 0) {
+ t->type = INT_FIXED;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ if(t->size == 0) in->error(in, "int has empty size");
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"uint_fixed") == 0) {
+ t->type = UINT_FIXED;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ if(t->size == 0) in->error(in, "uint has empty size");
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"char") == 0) {
+ t->type = CHAR;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ t->size = 1;
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"uchar") == 0) {
+ t->type = UCHAR;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ t->size = 1;
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"short") == 0) {
+ t->type = SHORT;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ t->size = 2;
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"ushort") == 0) {
+ t->type = USHORT;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ t->size = 2;
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"int") == 0) {
+ t->type = INT;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"uint") == 0) {
+ t->type = UINT;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+
+ else if(strcmp(token,"pointer") == 0) {
+ t->type = POINTER;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"long") == 0) {
+ t->type = LONG;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"ulong") == 0) {
+ t->type = ULONG;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"size_t") == 0) {
+ t->type = SIZE_T;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"ssize_t") == 0) {
+ t->type = SSIZE_T;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"off_t") == 0) {
+ t->type = OFF_T;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"float") == 0) {
+ t->type = FLOAT;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"string") == 0) {
+ t->type = STRING;
+ getTypeAttributes(in, t, unnamed_types, named_types);
+ getForwardslash(in);
+ getRAnglebracket(in);
+ }
+ else if(strcmp(token,"typeref") == 0){
+ // Must be a named type
+ free(t);
+ sequence_pop(unnamed_types);
+ token = getNameAttribute(in);
+ t = find_named_type(token, named_types);
+ if(t == NULL) in->error(in,"Named referred to must be pre-declared.");
+ getForwardslash(in); //<typeref name=type_name/>
+ getRAnglebracket(in);
+ return t;
+ }else in->error(in,"not a valid type");
+
+ return t;
+}
+
+/*****************************************************************************
+ *Function name
+ * find_named_type : find a named type from hash table
+ *Input params
+ * name : type name
+ * named_types : array of named types
+ *Return values
+ * type_descriptor * : a type descriptor
+ *****************************************************************************/
+
+type_descriptor_t * find_named_type(char *name, table_t * named_types)
+{
+ type_descriptor_t *t;
+
+ t = table_find(named_types,name);
+
+ return t;
+}
+
+type_descriptor_t * create_named_type(char *name, table_t * named_types)
+{
+ type_descriptor_t *t;
+
+ t = (type_descriptor_t *)memAlloc(sizeof(type_descriptor_t));
+ t->type_name = allocAndCopy(name);
+ t->type = NONE;
+ t->fmt = NULL;
+ table_insert(named_types,t->type_name,t);
+ // table_insert(named_types,allocAndCopy(name),t);
+ return t;
+}
+
+/*****************************************************************************
+ *Function name
+ * parseTypeDefinition : get type information from type definition
+ *Input params
+ * in : input file handle
+ * unnamed_types : array of unamed types
+ * named_types : array of named types
+ *****************************************************************************/
+
+void parseTypeDefinition(parse_file_t * in, sequence_t * unnamed_types,
+ table_t * named_types)
+{
+ char *token;
+ type_descriptor_t *t;
+
+ token = getNameAttribute(in);
+ if(token == NULL) in->error(in, "Type has empty name");
+ t = create_named_type(token, named_types);
+
+ if(t->type != NONE) in->error(in,"redefinition of named type");
+ getRAnglebracket(in); //<type name=type_name>
+ getLAnglebracket(in); //<
+ token = getName(in);
+ //MD ??if(strcmp("struct",token))in->error(in,"not a valid type definition");
+ ungetToken(in);
+ parseType(in,t, unnamed_types, named_types);
+
+ //</type>
+ getLAnglebracket(in);
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("type",token))in->error(in,"not a valid type definition");
+ getRAnglebracket(in); //</type>
+}
+
+/**************************************************************************
+ * Function :
+ * getComa, getName, getNumber, getEqual
+ * Description :
+ * Read a token from the input file, check its type, return it scontent.
+ *
+ * Parameters :
+ * in , input file handle.
+ *
+ * Return values :
+ * address of token content.
+ *
+ **************************************************************************/
+
+char *getName(parse_file_t * in)
+{
+ char *token;
+
+ token = getToken(in);
+ // Optional descriptions
+ // if(in->type != NAME) in->error(in,"Name token was expected");
+ return token;
+}
+
+int getNumber(parse_file_t * in)
+{
+ char *token;
+
+ token = getToken(in);
+ if(in->type != NUMBER) in->error(in, "Number token was expected");
+ return atoi(token);
+}
+
+char *getForwardslash(parse_file_t * in)
+{
+ char *token;
+
+ token = getToken(in);
+ //if(in->type != FORWARDSLASH) in->error(in, "forward slash token was expected");
+ /* Mathieu : final / is optional now. */
+ if(in->type != FORWARDSLASH) ungetToken(in);
+
+ return token;
+}
+
+char *getLAnglebracket(parse_file_t * in)
+{
+ char *token;
+
+ token = getToken(in);
+ if(in->type != LANGLEBRACKET) in->error(in, "Left angle bracket was expected");
+ return token;
+}
+
+char *getRAnglebracket(parse_file_t * in)
+{
+ char *token;
+
+ token = getToken(in);
+ if(in->type != RANGLEBRACKET) in->error(in, "Right angle bracket was expected");
+ return token;
+}
+
+char *getQuotedString(parse_file_t * in)
+{
+ char *token;
+
+ token = getToken(in);
+ if(in->type != QUOTEDSTRING) in->error(in, "quoted string was expected");
+ return token;
+}
+
+char * getEqual(parse_file_t *in)
+{
+ char *token;
+
+ token = getToken(in);
+ if(in->type != EQUAL) in->error(in, "equal was expected");
+ return token;
+}
+
+char seekNextChar(parse_file_t *in)
+{
+ char car;
+ while((car = getc(in->fp)) != EOF) {
+ if(!isspace(car)){
+ ungetc(car,in->fp);
+ return car;
+ }
+ }
+ return EOF;
+}
+
+/******************************************************************
+ * Function :
+ * getToken, ungetToken
+ * Description :
+ * Read a token from the input file and return its type and content.
+ * Line numbers are accounted for and whitespace/comments are skipped.
+ *
+ * Parameters :
+ * in, input file handle.
+ *
+ * Return values :
+ * address of token content.
+ *
+ ******************************************************************/
+
+void ungetToken(parse_file_t * in)
+{
+ in->unget = 1;
+}
+
+char *getToken(parse_file_t * in)
+{
+ FILE *fp = in->fp;
+ char car, car1;
+ int pos = 0, escaped;
+
+ if(in->unget == 1) {
+ in->unget = 0;
+ return in->buffer;
+ }
+
+ /* skip whitespace and comments */
+
+ while((car = getc(fp)) != EOF) {
+ if(car == '/') {
+ car1 = getc(fp);
+ if(car1 == '*') skipComment(in);
+ else if(car1 == '/') skipEOL(in);
+ else {
+ car1 = ungetc(car1,fp);
+ break;
+ }
+ }
+ else if(car == '\n') in->lineno++;
+ else if(!isspace(car)) break;
+ }
+
+ switch(car) {
+ case EOF:
+ in->type = ENDFILE;
+ break;
+ case '/':
+ in->type = FORWARDSLASH;
+ in->buffer[pos] = car;
+ pos++;
+ break;
+ case '<':
+ in->type = LANGLEBRACKET;
+ in->buffer[pos] = car;
+ pos++;
+ break;
+ case '>':
+ in->type = RANGLEBRACKET;
+ in->buffer[pos] = car;
+ pos++;
+ break;
+ case '=':
+ in->type = EQUAL;
+ in->buffer[pos] = car;
+ pos++;
+ break;
+ case '"':
+ escaped = 0;
+ while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
+ if(car == '\\' && escaped == 0) {
+ in->buffer[pos] = car;
+ pos++;
+ escaped = 1;
+ continue;
+ }
+ if(car == '"' && escaped == 0) break;
+ if(car == '\n' && escaped == 0) {
+ in->error(in, "non escaped newline inside quoted string");
+ }
+ if(car == '\n') in->lineno++;
+ in->buffer[pos] = car;
+ pos++;
+ escaped = 0;
+ }
+ if(car == EOF) in->error(in,"no ending quotemark");
+ if(pos == BUFFER_SIZE) in->error(in, "quoted string token too large");
+ in->type = QUOTEDSTRING;
+ break;
+ default:
+ if(isdigit(car)) {
+ in->buffer[pos] = car;
+ pos++;
+ while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
+ if(!isdigit(car)) {
+ ungetc(car,fp);
+ break;
+ }
+ in->buffer[pos] = car;
+ pos++;
+ }
+ if(car == EOF) ungetc(car,fp);
+ if(pos == BUFFER_SIZE) in->error(in, "number token too large");
+ in->type = NUMBER;
+ }
+ else if(isalnum(car) || car == '_' || car == '-') {
+ in->buffer[0] = car;
+ pos = 1;
+ while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
+ if(!(isalnum(car) || car == '_' || car == '-')) {
+ ungetc(car,fp);
+ break;
+ }
+ in->buffer[pos] = car;
+ pos++;
+ }
+ if(car == EOF) ungetc(car,fp);
+ if(pos == BUFFER_SIZE) in->error(in, "name token too large");
+ in->type = NAME;
+ } else if(car == '?') {
+ in->buffer[0] = car;
+ pos++;
+ }
+ else in->error(in, "invalid character, unrecognized token");
+ }
+ in->buffer[pos] = 0;
+ return in->buffer;
+}
+
+void skipComment(parse_file_t * in)
+{
+ char car;
+ while((car = getc(in->fp)) != EOF) {
+ if(car == '\n') in->lineno++;
+ else if(car == '*') {
+ car = getc(in->fp);
+ if(car ==EOF) break;
+ if(car == '/') return;
+ ungetc(car,in->fp);
+ }
+ }
+ if(car == EOF) in->error(in,"comment begining with '/*' has no ending '*/'");
+}
+
+void skipEOL(parse_file_t * in)
+{
+ char car;
+ while((car = getc(in->fp)) != EOF) {
+ if(car == '\n') {
+ ungetc(car,in->fp);
+ break;
+ }
+ }
+ if(car == EOF)ungetc(car, in->fp);
+}
+
+/*****************************************************************************
+ *Function name
+ * checkNamedTypesImplemented : check if all named types have definition
+ ****************************************************************************/
+
+void checkNamedTypesImplemented(table_t * named_types)
+{
+ type_descriptor_t *t;
+ int pos;
+ char str[256];
+
+ for(pos = 0 ; pos < named_types->values.position; pos++) {
+ t = (type_descriptor_t *) named_types->values.array[pos];
+ if(t->type == NONE){
+ sprintf(str,"named type '%s' has no definition",
+ (char*)named_types->keys.array[pos]);
+ error_callback(NULL,str);
+ }
+ }
+}
+
+
+/*****************************************************************************
+ *Function name
+ * generateChecksum : generate checksum for the facility
+ *Input Params
+ * facName : name of facility
+ *Output Params
+ * checksum : checksum for the facility
+ ****************************************************************************/
+
+void generateChecksum(char* facName,
+ unsigned int * checksum, sequence_t * events)
+{
+ unsigned long crc ;
+ int pos;
+ event_t * ev;
+ unsigned int i;
+
+ crc = crc32(facName);
+ for(pos = 0; pos < events->position; pos++){
+ ev = (event_t *)(events->array[pos]);
+ crc = partial_crc32(ev->name, crc);
+ for(i = 0; i < ev->fields.position; i++) {
+ field_t *f = (field_t*)ev->fields.array[i];
+ crc = partial_crc32(f->name, crc);
+ crc = getTypeChecksum(crc, f->type);
+ }
+ }
+ *checksum = crc;
+}
+
+/*****************************************************************************
+ *Function name
+ * getTypeChecksum : generate checksum by type info
+ *Input Params
+ * crc : checksum generated so far
+ * type : type descriptor containing type info
+ *Return value
+ * unsigned long : checksum
+ *****************************************************************************/
+
+unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor_t * type)
+{
+ unsigned long crc = aCrc;
+ char * str = NULL, buf[16];
+ int flag = 0, pos;
+ field_t * fld;
+
+ switch(type->type){
+ case INT_FIXED:
+ str = intOutputTypes[getSizeindex(type->size)];
+ break;
+ case UINT_FIXED:
+ str = uintOutputTypes[getSizeindex(type->size)];
+ break;
+ case POINTER:
+ str = allocAndCopy("void *");
+ flag = 1;
+ break;
+ case CHAR:
+ str = allocAndCopy("signed char");
+ flag = 1;
+ break;
+ case UCHAR:
+ str = allocAndCopy("unsigned char");
+ flag = 1;
+ break;
+ case SHORT:
+ str = allocAndCopy("short");
+ flag = 1;
+ break;
+ case USHORT:
+ str = allocAndCopy("unsigned short");
+ flag = 1;
+ break;
+ case INT:
+ str = allocAndCopy("int");
+ flag = 1;
+ break;
+ case UINT:
+ str = allocAndCopy("uint");
+ flag = 1;
+ break;
+ case LONG:
+ str = allocAndCopy("long");
+ flag = 1;
+ break;
+ case ULONG:
+ str = allocAndCopy("unsigned long");
+ flag = 1;
+ break;
+ case SIZE_T:
+ str = allocAndCopy("size_t");
+ flag = 1;
+ break;
+ case SSIZE_T:
+ str = allocAndCopy("ssize_t");
+ flag = 1;
+ break;
+ case OFF_T:
+ str = allocAndCopy("off_t");
+ flag = 1;
+ break;
+ case FLOAT:
+ str = floatOutputTypes[getSizeindex(type->size)];
+ break;
+ case STRING:
+ str = allocAndCopy("string");
+ flag = 1;
+ break;
+ case ENUM:
+ //str = appendString("enum ", uintOutputTypes[getSizeindex(type->size)]);
+ str = allocAndCopy("enum");
+ flag = 1;
+ break;
+ case ARRAY:
+ sprintf(buf,"%zu", type->size);
+ str = appendString("array ",buf);
+ flag = 1;
+ break;
+ case SEQUENCE:
+ str = allocAndCopy("sequence ");
+ flag = 1;
+ break;
+ case STRUCT:
+ str = allocAndCopy("struct");
+ flag = 1;
+ break;
+ case UNION:
+ str = allocAndCopy("union");
+ flag = 1;
+ break;
+ default:
+ error_callback(NULL, "named type has no definition");
+ break;
+ }
+
+ crc = partial_crc32(str,crc);
+ if(flag) free(str);
+
+ if(type->fmt) crc = partial_crc32(type->fmt,crc);
+
+ if(type->type == ARRAY){
+ crc = getTypeChecksum(crc,((field_t*)type->fields.array[0])->type);
+ } else if(type->type ==SEQUENCE) {
+ crc = getTypeChecksum(crc,((field_t*)type->fields.array[0])->type);
+ crc = getTypeChecksum(crc,((field_t*)type->fields.array[1])->type);
+ } else if(type->type == STRUCT || type->type == UNION){
+ for(pos =0; pos < type->fields.position; pos++){
+ fld = (field_t *) type->fields.array[pos];
+ crc = partial_crc32(fld->name,crc);
+ crc = getTypeChecksum(crc, fld->type);
+ }
+ }else if(type->type == ENUM){
+ for(pos = 0; pos < type->labels.position; pos++)
+ crc = partial_crc32((char*)type->labels.array[pos],crc);
+ }
+
+ return crc;
+}
+
+
+/* Event type descriptors */
+void freeType(type_descriptor_t * tp)
+{
+ int pos2;
+ field_t *f;
+
+ if(tp->fmt != NULL) free(tp->fmt);
+ if(tp->type == ENUM) {
+ for(pos2 = 0; pos2 < tp->labels.position; pos2++) {
+ free(tp->labels.array[pos2]);
+ }
+ sequence_dispose(&(tp->labels));
+ for(pos2 = 0; pos2 < tp->labels_values.position; pos2++) {
+ free(tp->labels_values.array[pos2]);
+ }
+ sequence_dispose(&(tp->labels_values));
+ }
+ if(tp->type == STRUCT) {
+ for(pos2 = 0; pos2 < tp->fields.position; pos2++) {
+ f = (field_t *) tp->fields.array[pos2];
+ free(f->name);
+ free(f->description);
+ free(f);
+ }
+ sequence_dispose(&(tp->fields));
+ }
+}
+
+void freeNamedType(table_t * t)
+{
+ int pos;
+ type_descriptor_t * td;
+
+ for(pos = 0 ; pos < t->keys.position; pos++) {
+ free((char *)t->keys.array[pos]);
+ td = (type_descriptor_t*)t->values.array[pos];
+ freeType(td);
+ free(td);
+ }
+}
+
+void freeTypes(sequence_t *t)
+{
+ int pos;
+ type_descriptor_t *tp;
+
+ for(pos = 0 ; pos < t->position; pos++) {
+ tp = (type_descriptor_t *)t->array[pos];
+ freeType(tp);
+ free(tp);
+ }
+}
+
+void freeEvents(sequence_t *t)
+{
+ int pos;
+ event_t *ev;
+
+ for(pos = 0 ; pos < t->position; pos++) {
+ ev = (event_t *) t->array[pos];
+ free(ev->name);
+ free(ev->description);
+ sequence_dispose(&ev->fields);
+ free(ev);
+ }
+
+}
+
+
+/* Extensible array */
+
+void sequence_init(sequence_t *t)
+{
+ t->size = 10;
+ t->position = 0;
+ t->array = (void **)memAlloc(t->size * sizeof(void *));
+}
+
+void sequence_dispose(sequence_t *t)
+{
+ t->size = 0;
+ free(t->array);
+ t->array = NULL;
+}
+
+void sequence_push(sequence_t *t, void *elem)
+{
+ void **tmp;
+
+ if(t->position >= t->size) {
+ tmp = t->array;
+ t->array = (void **)memAlloc(t->size * 2 * sizeof(void *));
+ memcpy(t->array, tmp, t->size * sizeof(void *));
+ t->size = t->size * 2;
+ free(tmp);
+ }
+ t->array[t->position] = elem;
+ t->position++;
+}
+
+void *sequence_pop(sequence_t *t)
+{
+ if(t->position == 0) printf("Error : trying to pop an empty sequence");
+ return t->array[--t->position];
+}
+
+
+/* Hash table API, implementation is just linear search for now */
+
+void table_init(table_t *t)
+{
+ sequence_init(&(t->keys));
+ sequence_init(&(t->values));
+}
+
+void table_dispose(table_t *t)
+{
+ sequence_dispose(&(t->keys));
+ sequence_dispose(&(t->values));
+}
+
+void table_insert(table_t *t, char *key, void *value)
+{
+ sequence_push(&(t->keys),key);
+ sequence_push(&(t->values),value);
+}
+
+void *table_find(table_t *t, char *key)
+{
+ int pos;
+ for(pos = 0 ; pos < t->keys.position; pos++) {
+ if(strcmp((char *)key,(char *)t->keys.array[pos]) == 0)
+ return(t->values.array[pos]);
+ }
+ return NULL;
+}
+
+void table_insert_int(table_t *t, int *key, void *value)
+{
+ sequence_push(&(t->keys),key);
+ sequence_push(&(t->values),value);
+}
+
+void *table_find_int(table_t *t, int *key)
+{
+ int pos;
+ for(pos = 0 ; pos < t->keys.position; pos++) {
+ if(*key == *(int *)t->keys.array[pos])
+ return(t->values.array[pos]);
+ }
+ return NULL;
+}
+
+
+/* Concatenate strings */
+
+char *appendString(char *s, char *suffix)
+{
+ char *tmp;
+ if(suffix == NULL) return s;
+
+ tmp = (char *)memAlloc(strlen(s) + strlen(suffix) + 1);
+ strcpy(tmp,s);
+ strcat(tmp,suffix);
+ return tmp;
+}
--- /dev/null
+#ifndef PARSER_H
+#define PARSER_H
+
+/* Extensible array container */
+
+typedef struct _sequence {
+ int size;
+ int position;
+ void **array;
+} sequence_t;
+
+void sequence_init(sequence_t *t);
+void sequence_dispose(sequence_t *t);
+void sequence_push(sequence_t *t, void *elem);
+void *sequence_pop(sequence_t *t);
+
+
+/* Hash table */
+
+typedef struct _table {
+ sequence_t keys;
+ sequence_t values;
+} table_t;
+
+void table_init(table_t *t);
+void table_dispose(table_t *t);
+void table_insert(table_t *t, char *key, void *value);
+void *table_find(table_t *t, char *key);
+void table_insert_int(table_t *t, int *key, void *value);
+void *table_find_int(table_t *t, int *key);
+
+
+/* Token types */
+
+typedef enum _token_type {
+ ENDFILE,
+ FORWARDSLASH,
+ LANGLEBRACKET,
+ RANGLEBRACKET,
+ EQUAL,
+ QUOTEDSTRING,
+ NUMBER,
+ NAME
+} token_type_t;
+
+
+/* State associated with a file being parsed */
+typedef struct _parse_file {
+ char *name;
+ FILE * fp;
+ int lineno;
+ char *buffer;
+ token_type_t type;
+ int unget;
+ void (*error) (struct _parse_file *, char *);
+} parse_file_t;
+
+void ungetToken(parse_file_t * in);
+char *getToken(parse_file_t *in);
+char *getForwardslash(parse_file_t *in);
+char *getLAnglebracket(parse_file_t *in);
+char *getRAnglebracket(parse_file_t *in);
+char *getQuotedString(parse_file_t *in);
+char *getName(parse_file_t *in);
+int getNumber(parse_file_t *in);
+char *getEqual(parse_file_t *in);
+char seekNextChar(parse_file_t *in);
+
+void skipComment(parse_file_t * in);
+void skipEOL(parse_file_t * in);
+
+/* Some constants */
+
+static const int BUFFER_SIZE = 1024;
+
+
+/* Events data types */
+
+typedef enum _data_type {
+ INT_FIXED,
+ UINT_FIXED,
+ POINTER,
+ CHAR,
+ UCHAR,
+ SHORT,
+ USHORT,
+ INT,
+ UINT,
+ LONG,
+ ULONG,
+ SIZE_T,
+ SSIZE_T,
+ OFF_T,
+ FLOAT,
+ STRING,
+ ENUM,
+ ARRAY,
+ SEQUENCE,
+ STRUCT,
+ UNION,
+ NONE
+} data_type_t;
+
+typedef struct _type_descriptor {
+ char * type_name; //used for named type
+ data_type_t type;
+ char *fmt;
+ size_t size;
+ sequence_t labels; // for enumeration
+ sequence_t labels_values; // for enumeration
+ sequence_t labels_description;
+ int already_printed;
+ sequence_t fields; // for structure, array and sequence (field_t type)
+ int custom_write; /* Should we use a custom write function ? */
+ int network; /* Is the type a in network byte order ? */
+} type_descriptor_t;
+
+
+
+/* Fields within types or events */
+typedef struct _field{
+ char *name;
+ char *description;
+ type_descriptor_t *type;
+} field_t;
+
+
+/* Events definitions */
+
+typedef struct _event {
+ char *name;
+ char *description;
+ //type_descriptor_t *type;
+ sequence_t fields; /* event fields */
+ int per_trace; /* Is the event able to be logged to a specific trace ? */
+ int per_tracefile; /* Must we log this event in a specific tracefile ? */
+ int param_buffer; /* For userspace tracing : takes a buffer as parameter? */
+ int no_instrument_function;
+} event_t;
+
+typedef struct _facility {
+ char * name;
+ char * capname;
+ char * arch;
+ char * description;
+ sequence_t events;
+ sequence_t unnamed_types; //FIXME : remove
+ table_t named_types;
+ unsigned int checksum;
+ int user; /* Is this a userspace facility ? */
+} facility_t;
+
+int getSizeindex(unsigned int value);
+unsigned long long int getSize(parse_file_t *in);
+unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor_t * type);
+
+void parseFacility(parse_file_t *in, facility_t * fac);
+void parseEvent(parse_file_t *in, event_t *ev, sequence_t * unnamed_types,
+ table_t * named_types);
+void parseTypeDefinition(parse_file_t *in,
+ sequence_t * unnamed_types, table_t * named_types);
+type_descriptor_t *parseType(parse_file_t *in,
+ type_descriptor_t *t, sequence_t * unnamed_types, table_t * named_types);
+void parseFields(parse_file_t *in, field_t *f,
+ sequence_t * unnamed_types,
+ table_t * named_types,
+ int tag);
+void checkNamedTypesImplemented(table_t * namedTypes);
+type_descriptor_t * find_named_type(char *name, table_t * named_types);
+void generateChecksum(char * facName,
+ unsigned int * checksum, sequence_t * events);
+
+
+/* get attributes */
+char * getNameAttribute(parse_file_t *in);
+char * getFormatAttribute(parse_file_t *in);
+int getSizeAttribute(parse_file_t *in);
+int getValueAttribute(parse_file_t *in, long long *value);
+
+char * getDescription(parse_file_t *in);
+
+
+/* Dynamic memory allocation and freeing */
+
+void * memAlloc(int size);
+char *allocAndCopy(char * str);
+char *appendString(char *s, char *suffix);
+void freeTypes(sequence_t *t);
+void freeType(type_descriptor_t * td);
+void freeEvents(sequence_t *t);
+void freeNamedType(table_t * t);
+void error_callback(parse_file_t *in, char *msg);
+
+
+//checksum part
+static const unsigned int crctab32[] =
+{
+#include "crc32.tab"
+};
+
+static inline unsigned long
+partial_crc32_one(unsigned char c, unsigned long crc)
+{
+ return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
+}
+
+static inline unsigned long
+partial_crc32(const char *s, unsigned long crc)
+{
+ while (*s)
+ crc = partial_crc32_one(*s++, crc);
+ return crc;
+}
+
+static inline unsigned long
+crc32(const char *s)
+{
+ return partial_crc32(s, 0xffffffff) ^ 0xffffffff;
+}
+
+
+extern char *intOutputTypes[];
+
+extern char *uintOutputTypes[];
+
+extern char *floatOutputTypes[];
+
+
+
+
+#endif // PARSER_H
--- /dev/null
+<?xml version="1.0"?>
+<facility name="test">
+ <description>The kernel facility has events related to kernel execution status.</description>
+
+
+ <type name="tasklet_priority">
+ <enum>
+ <label name="LOW" value="0"> <description>Low priority tasklet</description>
+ <label name="HIGH" value="1"> <description>High priority tasklet</description>
+ </enum>
+ </type>
+
+ <type name="irq_mode">
+ <enum>
+ <label name="user" value="0"> <description>User context</description>
+ <label name="kernel" value="1"> <description>Kernel context</description>
+ </enum>
+ </type>
+
+ <type name="mystruct2">
+ <struct>
+ <field name="irq_id"> <description>IRQ number</description> <uint size="4"> </field>
+ <field name="mode"> <description>Are we executing kernel code</description> <typeref name="irq_mode"> </field>
+ </struct>
+ </type>
+
+ <type name="mystruct">
+ <struct>
+ <field name="irq_id"> <description>IRQ number</description> <uint size="4"> </field>
+ <field name="mode"> <description>Are we executing kernel code</description> <typeref name="irq_mode"> </field>
+
+ <field name="teststr"><typeref name="mystruct2"></field>
+ <field name="myarray">
+ <array size="10">
+ <uint_fixed size="8">
+ </array>
+ </field>
+ <field name="mysequence">
+ <sequence>
+ <uint>
+ <float size="8">
+ </sequence>
+ </field>
+ <field name="myunion">
+ <union>
+ <field name="myfloat"><float size="8"></field>
+ <field name="myulong"><ulong></field>
+ </union>
+ </field>
+ </struct>
+ </type>
+
+
+
+
+ <event name="syscall_entry">
+ <description>System call entry</description>
+ <field name="syscall_id"> <description>Syscall entry number in entry.S</description> <uint size="1"> </field>
+ <field name="address"> <description>Address from which call was made</description> <pointer> </field>
+ </event>
+
+ <event name="syscall_exit">
+ <description>System call exit</description>
+ </event>
+
+ <event name="trap_entry">
+ <description>Entry in a trap</description>
+ <field name="trap_id"> <description>Trap number</description> <uint size="2"> </field>
+ <field name="address"> <description>Address where trap occured</description> <pointer> </field>
+ </event>
+
+ <event name="trap_exit">
+ <description>Exit from a trap</description>
+ </event>
+
+ <event name="soft_irq_entry">
+ <description>Soft IRQ entry</description>
+ <field name="softirq_id"> <description>Soft IRQ number</description> <pointer> </field>
+ </event>
+
+ <event name="soft_irq_exit">
+ <description>Soft IRQ exit</description>
+ <field name="softirq_id"> <description>Soft IRQ number</description> <pointer> </field>
+ </event>
+
+ <event name="tasklet_entry">
+ <description>Tasklet entry</description>
+ <field name="priority"> <description>Tasklet priority</description> <typeref name="tasklet_priority"> </field>
+ <field name="address"> <description>Tasklet function address</description> <pointer> </field>
+ <field name="data"> <description>Tasklet data address</description> <ulong> </field>
+ </event>
+
+ <event name="tasklet_exit">
+ <description>Tasklet exit</description>
+ <field name="priority"> <description>Tasklet priority</description> <typeref name="tasklet_priority"> </field>
+ <field name="address"> <description>Tasklet function address</description> <pointer> </field>
+ <field name="data"> <description>Tasklet data address</description> <ulong> </field>
+ </event>
+
+ <event name="irq_entry">
+ <description>Entry in an irq</description>
+ <field name="irq_id"> <description>IRQ number</description> <uint size="4"> </field>
+ <field name="mode"> <description>Are we executing kernel code</description><typeref name=""irq_mode""> </field>
+ </event>
+
+ <event name="irq_exit">
+ <description>Exit from an IRQ</description>
+ </event>
+
+ <event name="big_array">
+ <field name="myarray">
+ <array size="10000">
+ <array size="2">
+ <struct>
+ <field name="a"><pointer></field>
+ <field name="b"><union>
+ <field name="c"><pointer></field>
+ </union>
+ </field>
+ </struct>
+ </array>
+ </array>
+ </field>
+ </event>
+
+</facility>
projects / lttv.git / commitdiff
