+++ /dev/null
-SHELL = /bin/sh
-
-CC = gcc
-
-CFLAGS = -g -o
-
-all: genevent
-
-install: genevent
- cp -f genevent /usr/local/bin
-
-genevent:genevent.o parser.o
- $(CC) $(CFLAGS) $@ genevent.o parser.o
-
-genevent.o: genevent.c genevent.h parser.h
- $(CC) -g -c genevent.c
-
-parser.o: parser.c parser.h
- $(CC) -g -c parser.c
-
-.PHONY: clean
-
-clean:
- rm -rf *.o *~ *# genevent
-
-
+++ /dev/null
-
-Mathieu Desnoyers -- September 2005
-
-The 'genevent' program parses event descriptions and generates
-the inline functions to record events in the kernel.
-
-Right now, the program can only parse simple structure, if a
-structure has a nested structure, it will not work.
-
-Genevent will soon go through a rewrite, but for now, the strings should be put
-*** AT THE END *** of a structure : they will be put there anyways.
-
-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.
-
-'core.xml' is an example event description file.
-
-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
-
-
+++ /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.c: Generate helper declarations and functions to trace events
- from an event description file.
-
-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 ".event" event definitions input files
- specified as command line arguments and generates corresponding
- ".c" and ".h" files required to trace such events in the kernel.
-
- 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 ".event" file is finished. */
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <linux/errno.h>
-#include <assert.h>
-
-#include "parser.h"
-#include "genevent.h"
-
-#define max(a,b) ((a)<(b))?(b):(a)
-
-/* Named types may be referenced from anywhere */
-
-facility_t * fac;
-
-unsigned alignment = 0;
-
-int main(int argc, char** argv)
-{
- char *token;
- parse_file_t in;
- char buffer[BUFFER_SIZE];
- int i;
-
- if(argc < 2){
- printf("At least one event definition file is needed\n");
- printf("You may specify the default alignment for a facility with\n");
- printf(" -a x , where x is the desired alignment in bytes.\n");
- printf("The alignment value will affect all the following xml files.\n");
- printf("i.e. genevent -a 8 core.xml -a 4 kernel.xml is valid.\n");
- exit(1);
- }
-
- in.buffer = buffer;
- in.error = error_callback;
-
- for(i = 1 ; i < argc ; i++) {
-
- if(strcmp("-a", argv[i])==0) {
- if(i >= argc-1) {
- printf("Error : missing argument to -a\n");
- exit(1);
- } else i++;
- alignment = atoi(argv[i]);
- } else {
-
- in.lineno = 0;
- in.name = allocAndCopy(argv[i]);
-
- in.fp = fopen(in.name, "r");
- if(!in.fp ){
- in.error(&in,"cannot open facility input file");
- }
-
- while(1){
- token = getToken(&in);
- if(in.type == ENDFILE) break;
-
- if(strcmp(token, "<")) in.error(&in,"not a facility file");
- token = getName(&in);
-
- if(strcmp("facility",token) == 0) {
- fac = memAlloc(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);
- }
- else in.error(&in,"facility token was expected");
-
- generateFile(argv[i]);
-
- free(fac->name);
- 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);
- }
-
- free(in.name);
- fclose(in.fp);
- }
- }
- return 0;
-}
-
-
-/*****************************************************************************
- *Function name
- * generateFile : generate .c and .h file
- *Input Params
- * name : name of event definition file
- ****************************************************************************/
-void generateFile(char *name)
-{
- char *loadName, *hName, *hIdName, *cName, *tmp, *tmp2;
- FILE * lFp, *hFp, *iFp, *cFp;
- int nbEvent;
- unsigned long checksum=0;
-
- //remove .xml if it exists
- tmp = &name[strlen(name)-4];
- if(strcmp(tmp, ".xml") == 0){
- *tmp = '\0';
- }
-
- tmp = strrchr(name,'/');
- if(tmp){
- tmp++;
- }else{
- tmp = name;
- }
-
- loadName = appendString("ltt-facility-loader-", tmp);
- tmp2 = appendString(loadName,".h");
- free(loadName);
- loadName = tmp2;
- hName = appendString("ltt-facility-", tmp);
- tmp2 = appendString(hName,".h");
- free(hName);
- hName = tmp2;
- hIdName = appendString("ltt-facility-id-", tmp);
- tmp2 = appendString(hIdName,".h");
- free(hIdName);
- hIdName = tmp2;
- cName = appendString("ltt-facility-loader-", tmp);
- tmp2 = appendString(cName,".c");
- free(cName);
- cName = tmp2;
- lFp = fopen(loadName,"w");
- if(!lFp){
- printf("Cannot open the file : %s\n",loadName);
- exit(1);
- }
-
- hFp = fopen(hName,"w");
- if(!hFp){
- printf("Cannot open the file : %s\n",hName);
- exit(1);
- }
-
- iFp = fopen(hIdName,"w");
- if(!iFp){
- printf("Cannot open the file : %s\n",hIdName);
- exit(1);
- }
-
- cFp = fopen(cName,"w");
- if(!cFp){
- printf("Cannot open the file : %s\n",cName);
- exit(1);
- }
-
- free(loadName);
- free(hName);
- free(hIdName);
- free(cName);
-
- generateChecksum(fac->name, &checksum, &(fac->events));
-
- /* generate .h file, event enumeration then structures and functions */
- fprintf(iFp, "#ifndef _LTT_FACILITY_ID_%s_H_\n",fac->capname);
- fprintf(iFp, "#define _LTT_FACILITY_ID_%s_H_\n\n",fac->capname);
- fprintf(iFp, "#ifdef CONFIG_LTT\n");
- generateEnumEvent(iFp, fac->name, &nbEvent, checksum);
- fprintf(iFp, "#endif //CONFIG_LTT\n");
- fprintf(iFp, "#endif //_LTT_FACILITY_ID_%s_H_\n",fac->capname);
-
-
- fprintf(hFp, "#ifndef _LTT_FACILITY_%s_H_\n",fac->capname);
- fprintf(hFp, "#define _LTT_FACILITY_%s_H_\n\n",fac->capname);
- //fprintf(hFp, "#ifdef CONFIG_LTT\n");
- generateTypeDefs(hFp, fac->name);
- generateStructFunc(hFp, fac->name,checksum);
- //fprintf(hFp, "#endif //CONFIG_LTT\n");
- fprintf(hFp, "#endif //_LTT_FACILITY_%s_H_\n",fac->capname);
-
- /* generate .h file, calls to register the facility at init time */
- generateLoaderfile(lFp,fac->name,nbEvent,checksum,fac->capname);
-
- // create ltt-facility-loader-facname.c
- generateCfile(cFp, tmp);
-
- fclose(hFp);
- fclose(iFp);
- fclose(lFp);
- fclose(cFp);
-
-}
-
-
-/*****************************************************************************
- *Function name
- * generateEnumEvent : output event enum to .h file
- *Input Params
- * fp : file to be written to
- * facName : name of facility
- *Output Params
- * nbEvent : number of events in the facility
- ****************************************************************************/
-void generateEnumEvent(FILE *fp, char *facName, int * nbEvent,
- unsigned long checksum) {
- int pos = 0;
-
- fprintf(fp,"#include <linux/ltt-facilities.h>\n\n");
-
- fprintf(fp,"/**** facility handle ****/\n\n");
- fprintf(fp,"extern ltt_facility_t ltt_facility_%s_%X;\n",facName, checksum);
- fprintf(fp,"extern ltt_facility_t ltt_facility_%s;\n\n\n",facName, checksum);
-
- fprintf(fp,"/**** event type ****/\n\n");
- fprintf(fp,"enum %s_event {\n",facName);
-
- for(pos = 0; pos < fac->events.position;pos++) {
- fprintf(fp,"\tevent_%s", ((event_t *)(fac->events.array[pos]))->name);
- if(pos != fac->events.position-1) fprintf(fp,",\n");
- }
- fprintf(fp,"\n};\n\n\n");
-
- // fprintf(fp,"/**** number of events in the facility ****/\n\n");
- // fprintf(fp,"int nbEvents_%s = %d;\n\n\n",facName, fac->events.position);
- *nbEvent = fac->events.position;
-}
-
-
-/*****************************************************************************
- *Function name
- * printStruct : Generic struct printing function
- *Input Params
- * fp : file to be written to
- * len : number of fields
- * array : array of field info
- * name : basic struct name
- * facName : name of facility
- * whichTypeFirst : struct or array/sequence first
- * hasStrSeq : string or sequence present?
- * structCount : struct postfix
- ****************************************************************************/
-
-static void
-printStruct(FILE * fp, int len, void ** array, char * name, char * facName,
- int * whichTypeFirst, int * hasStrSeq, int * structCount,
- type_descriptor_t *type)
-{
- int flag = 0;
- int pos;
- field_t * fld;
- type_descriptor_t * td;
-
- for (pos = 0; pos < len; pos++) {
- fld = (field_t *)array[pos];
- td = fld->type;
- if( td->type == STRING || td->type == SEQUENCE ||
- td->type == ARRAY) {
- (*hasStrSeq)++;
- } else {
- if (flag == 0) {
- flag = 1;
- fprintf(fp,"struct %s_%s",name, facName);
- if (structCount) {
- fprintf(fp, "_%d {\n",++*structCount);
- } else {
- fprintf(fp, " {\n");
- }
- }
- fprintf(fp, "\t%s %s; /* %s */\n",
- getTypeStr(td),fld->name,fld->description );
- }
- }
-
- if(flag) {
- unsigned align = max(alignment, type->alignment);
-
- if(align == 0)
- fprintf(fp,"} __attribute__ ((packed));\n\n");
- else {
- if(align != 1 && align != 2
- && align != 4 && align != 8) {
- printf("Wrong alignment %i, using packed.\n", align);
- fprintf(fp,"} __attribute__ ((packed));\n\n");
- } else
- fprintf(fp,"} __attribute__ ((aligned(%i)));\n\n", align);
- }
- }
-}
-
-
-/*****************************************************************************
- *Function name
- * generateHfile : Create the typedefs
- *Input Params
- * fp : file to be written to
- ****************************************************************************/
-void
-generateTypeDefs(FILE * fp, char *facName)
-{
- int pos, tmp = 1;
-
- fprintf(fp,"#include <linux/types.h>\n");
- fprintf(fp,"#include <linux/spinlock.h>\n");
- fprintf(fp,"#include <linux/ltt/ltt-facility-id-%s.h>\n\n", facName);
- fprintf(fp,"#include <linux/ltt-core.h>\n");
-
-#if 0 //broken
- fprintf(fp, "/**** Basic Type Definitions ****/\n\n");
-
- for (pos = 0; pos < fac->named_types.values.position; pos++) {
- type_descriptor * type =
- (type_descriptor*)fac->named_types.values.array[pos];
- printStruct(fp, type->fields.position, type->fields.array,
- "", type->type_name, &tmp, &tmp, NULL);
- fprintf(fp, "typedef struct _%s %s;\n\n",
- type->type_name, type->type_name);
- }
-#endif //0
-}
-
-
-/*****************************************************************************
- *Function name
- * generateEnumDefinition: generate enum definition if it exists
- *Input Params
- * fp : file to be written to
- * fHead : enum type
- ****************************************************************************/
-void generateEnumDefinition(FILE * fp, type_descriptor_t * type){
- int pos;
-
- if(type->already_printed) return;
-
- fprintf(fp,"enum {\n");
- for(pos = 0; pos < type->labels.position; pos++){
- fprintf(fp,"\tLTT_ENUM_%s", type->labels.array[pos]);
- if (pos != type->labels.position - 1) fprintf(fp,",");
- if(type->labels_description.array[pos] != NULL)
- fprintf(fp,"\t/* %s */\n",type->labels_description.array[pos]);
- else
- fprintf(fp,"\n");
- }
- fprintf(fp,"};\n\n\n");
-
- type->already_printed = 1;
-}
-
-/*****************************************************************************
- *Function name
- * generateStrucTFunc: output structure and function to .h file
- *Input Params
- * fp : file to be written to
- * facName : name of facility
- ****************************************************************************/
-void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
- event_t * ev;
- field_t * fld;
- type_descriptor_t * td;
- int pos, pos1;
- int hasStrSeq, flag, structCount, seqCount,strCount, whichTypeFirst=0;
- int args_empty;
-
- for(pos = 0; pos < fac->events.position; pos++){
- ev = (event_t *) fac->events.array[pos];
- //yxx if(ev->nested)continue;
- fprintf(fp,"/**** structure and trace function for event: %s ****/\n\n",
- ev->name);
- //if(ev->type == 0){ // event without type
- // fprintf(fp,"static inline void trace_%s_%s(void){\n",facName,ev->name);
- // fprintf(fp,"\tltt_log_event(ltt_facility_%s_%X, event_%s, 0, NULL);\n",
- // facName,checksum,ev->name);
- // fprintf(fp,"};\n\n\n");
- // continue;
- //}
-
- //if fields contain enum, print out enum definition
- //MD : fixed in generateEnumDefinition to do not print the same enum
- //twice.
- if(ev->type != 0)
- for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
- fld = (field_t *)ev->type->fields.array[pos1];
- if(fld->type->type == ENUM) generateEnumDefinition(fp, fld->type);
- }
-
- //default: no string, array or sequence in the event
- hasStrSeq = 0;
- whichTypeFirst = 0;
- structCount = 0;
-
- //structure for kernel
- if(ev->type != 0)
- printStruct(fp, ev->type->fields.position, ev->type->fields.array,
- ev->name, facName, &whichTypeFirst, &hasStrSeq, &structCount,
- ev->type);
-
-
- //trace function : function name and parameters : stub function.
- seqCount = 0;
- strCount = 0;
- fprintf(fp, "#ifndef CONFIG_LTT\n");
- fprintf(fp,"static inline void trace_%s_%s(",facName,ev->name);
-
- args_empty = 1;
-
- /* Does it support per trace tracing ? */
- if(ev->per_trace) {
- fprintf(fp, "struct ltt_trace_struct *dest_trace");
- args_empty = 0;
- }
-
- /* Does it support per tracefile tracing ? */
- if(ev->per_tracefile) {
- if(!args_empty) fprintf(fp, ", ");
- fprintf(fp, "unsigned int tracefile_index");
- args_empty = 0;
- }
-
- if(ev->type != 0) {
- for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
- fld = (field_t *)ev->type->fields.array[pos1];
- td = fld->type;
- if(!args_empty) fprintf(fp, ", ");
- if(td->type == ARRAY ){
- fprintf(fp,"%s * %s",getTypeStr(td), fld->name);
- args_empty = 0;
- }else if(td->type == STRING){
- fprintf(fp,"short int strlength_%d, %s * %s",
- ++strCount, getTypeStr(td), fld->name);
- args_empty = 0;
- }else if(td->type == SEQUENCE){
- fprintf(fp,"%s seqlength_%d, %s * %s",
- uintOutputTypes[td->size], ++seqCount,getTypeStr(td), fld->name);
- args_empty = 0;
- }else {
- fprintf(fp,"%s %s",getTypeStr(td), fld->name);
- args_empty = 0;
- }
- }
- }
- if(args_empty) fprintf(fp, "void");
-
- fprintf(fp,")\n{\n");
- fprintf(fp,"}\n");
- fprintf(fp,"#else\n");
-
- //trace function : function name and parameters
- seqCount = 0;
- strCount = 0;
- fprintf(fp,"static inline void trace_%s_%s(",facName,ev->name);
-
- args_empty = 1;
-
- /* Does it support per trace tracing ? */
- if(ev->per_trace) {
- fprintf(fp, "struct ltt_trace_struct *dest_trace");
- args_empty = 0;
- }
-
- /* Does it support per tracefile tracing ? */
- if(ev->per_tracefile) {
- if(!args_empty) fprintf(fp, ", ");
- fprintf(fp, "unsigned int tracefile_index");
- args_empty = 0;
- }
-
- if(ev->type != 0) {
- for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
- fld = (field_t *)ev->type->fields.array[pos1];
- td = fld->type;
- if(!args_empty) fprintf(fp, ", ");
- if(td->type == ARRAY ){
- fprintf(fp,"%s * %s",getTypeStr(td), fld->name);
- args_empty = 0;
- }else if(td->type == STRING){
- fprintf(fp,"short int strlength_%d, %s * %s",
- ++strCount, getTypeStr(td), fld->name);
- args_empty = 0;
- }else if(td->type == SEQUENCE){
- fprintf(fp,"%s seqlength_%d, %s * %s",
- uintOutputTypes[td->size], ++seqCount,getTypeStr(td), fld->name);
- args_empty = 0;
- }else {
- fprintf(fp,"%s %s",getTypeStr(td), fld->name);
- args_empty = 0;
- }
- }
- }
- if(args_empty) fprintf(fp, "void");
-
- fprintf(fp,")\n{\n");
-
- //allocate buffer
- // MD no more need. fprintf(fp,"\tchar buff[buflength];\n");
- // write directly to the channel
- fprintf(fp, "\tunsigned int index;\n");
- fprintf(fp, "\tstruct ltt_channel_struct *channel;\n");
- fprintf(fp, "\tstruct ltt_trace_struct *trace;\n");
- fprintf(fp, "\tvoid *buff;\n");
- fprintf(fp, "\tunsigned int slot_size;\n"); // total size (incl hdr)
- fprintf(fp, "\tunsigned int data_size;\n"); // Size of the event var data.
- fprintf(fp, "\tunsigned int before_hdr_pad;\n");// Dynamic padding before event header
- fprintf(fp, "\tunsigned int after_hdr_pad;\n"); // Dynamic padding after event header
- fprintf(fp, "\tstruct rchan_buf *buf;\n");
- fprintf(fp, "\tstruct timeval delta;\n");
- fprintf(fp, "\tu64 tsc;\n");
- fprintf(fp, "\tchar *ptr;\n");
-
- if(ev->type != 0)
- fprintf(fp, "\tstruct %s_%s_1* __1;\n\n", ev->name, facName);
-
- /* Warning : this is done prior to taking locks :
- * setting this value must be done at the end of the trace activation.
- * (we don't care for trace removal, as the list of traces is protected : it
- * just won't iterate on any trace). */
- fprintf(fp,
- "\tif(ltt_traces.num_active_traces == 0) return;\n\n");
-
- /* Calculate event variable len + event alignment offset.
- * Assume that the padding for alignment starts at a void*
- * address. */
- fprintf(fp, "\t\tdata_size = 0;\n");
-
- for(pos1=0;pos1<structCount;pos1++){
- if(ev->type->alignment > 1) {
- fprintf(fp,"\t\t\tdata_size += ltt_align(data_size, %u);\n",
- ev->type->alignment);
- }
- fprintf(fp,"\t\t\tdata_size += sizeof(struct %s_%s_%d);\n",
- ev->name,facName,pos1+1);
-// if(pos1 != structCount-1) fprintf(fp," + ");
- }
-
- //length of buffer : length of all arrays, sequences and strings
- seqCount = 0;
- strCount = 0;
- flag = 0;
- if(ev->type != 0)
- for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
- fld = (field_t *)ev->type->fields.array[pos1];
- td = fld->type;
- if(td->type == SEQUENCE || td->type==STRING || td->type==ARRAY){
- if(td->type == SEQUENCE) {
-
- if(td->alignment > 1) {
- fprintf(fp,"\t\t\tdata_size += ltt_align(data_size, %u);\n",
- td->alignment);
- }
- fprintf(fp,"\t\t\tdata_size += sizeof(%s);\n",
- uintOutputTypes[td->size]);
-
- if(td->alignment > 1) {
- fprintf(fp,"\t\tdata_size += ltt_align(data_size, %u);\n",
- td->alignment);
- }
- fprintf(fp,"\t\tdata_size += sizeof(%s) * seqlength_%d;\n",
- getTypeStr(td), seqCount);
-
- } else if(td->type==STRING) {
- if(td->alignment > 1) {
- fprintf(fp,"\t\tdata_size += ltt_align(data_size, %u);\n",
- td->alignment);
- }
- strCount++;
- fprintf(fp,"\t\tdata_size += strlength_%d + 1;\n",
- strCount);
- }
- else if(td->type==ARRAY) {
- if(td->alignment > 1) {
- fprintf(fp,"\t\tdata_size += ltt_align(data_size, %u);\n",
- td->alignment);
- }
- fprintf(fp,"\t\tdata_size += sizeof(%s) * %d;\n",
- getTypeStr(td), td->size);
-
- if(structCount == 0) flag = 1;
- }
- }
- }
-
- /* We use preempt_disable instead of rcu_read_lock because we want to
- * use preempt_enable_no_resched : the only way to be called from the
- * scheduler code safely! */
- fprintf(fp, "\tpreempt_disable();\n\n");
- fprintf(fp, "\tltt_nesting[smp_processor_id()]++;\n");
- fprintf(fp, "\tif(ltt_nesting[smp_processor_id()] > 1) goto unlock;\n");
-
- if(ev->per_tracefile) {
- fprintf(fp, "\tindex = tracefile_index;\n");
- } else {
- fprintf(fp,
- "\tindex = ltt_get_index_from_facility(ltt_facility_%s_%X,\n"\
- "\t\t\t\tevent_%s);\n",
- facName, checksum, ev->name);
- }
- fprintf(fp,"\n");
-
- /* For each trace */
- fprintf(fp, "\tlist_for_each_entry_rcu(trace, <t_traces.head, list) {\n");
- fprintf(fp, "\t\tif(!trace->active) continue;\n\n");
-
- if(ev->per_trace) {
- fprintf(fp, "\t\tif(dest_trace != trace) continue;\n\n");
- }
- //length of buffer : length of all structures
- // if(ev->type == 0) fprintf(fp, "0");
-
- fprintf(fp, "\t\tchannel = ltt_get_channel_from_index(trace, index);\n");
- fprintf(fp, "\t\tbuf = channel->rchan->buf[smp_processor_id()];\n");
- fprintf(fp, "\n");
-
-
- /* Relay reserve */
- fprintf(fp, "\t\tslot_size = 0;\n");
- fprintf(fp, "\t\tbuff = ltt_reserve_slot(trace, buf, event_length, &slot_size, &tsc,\n"
- "\t\t&before_hdr_pad, &after_hdr_pad);\n");
- /* If error, return */
- fprintf(fp, "if(!buff) return;\n");
-
- /* write data */
-
- /* Write the header */
- /* FIXME : delta is not set ! */
- fprintf(fp, "\n");
- fprintf(fp, "\t\tltt_write_event_header(trace, channel, buff, \n"
- "\t\t\t\tltt_facility_%s_%X, event_%s, data_size, before_hdr_pad,\n"
- "\t\t\t\t&delta, &tsc);\n",
- facName, checksum, ev->name);
- fprintf(fp, "\n");
-
- if(ev->type != 0) {
- fprintf(fp,"\t\tptr = (char*)buff + before_hdr_pad + header_length + after_hdr_pad;\n");
-
- /* Write structures */
- for(pos1=0;pos1<structCount;pos1++){
- if(ev->type->alignment > 1) {
- fprintf(fp,"\t\tptr += ltt_align((unsigned long)ptr, %u);\n",
- ev->type->alignment);
- }
- fprintf(fp,"\t\t__%d = (struct %s_%s_%d *)(ptr);\n",
- pos1+1, ev->name,facName,pos1+1);
-
- fprintf(fp,"\t\t/* initialize structs */\n");
-
- for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
- fld = (field_t *)ev->type->fields.array[pos1];
- td = fld->type;
- if(td->type != ARRAY && td->type != SEQUENCE && td->type != STRING){
- fprintf(fp, "\t\t__%d->%s = %s;\n", pos1+1, fld->name, fld->name);
- }
- }
- if(structCount) fprintf(fp,"\n");
- }
-
- }
-
-
- //declare a char pointer if needed : starts at the end of the structs.
- //if(structCount + hasStrSeq > 1) {
- // fprintf(fp,"\t\tchar * ptr = (char*)buff + header_length");
- // for(pos1=0;pos1<structCount;pos1++){
- // fprintf(fp," + sizeof(struct %s_%s_%d)",ev->name, facName,pos1+1);
- // }
- // if(structCount + hasStrSeq > 1) fprintf(fp,";\n");
- //}
-
- // Declare an alias pointer of the struct type to the beginning
- // of the reserved area, just after the event header.
- if(ev->type != 0) {
-
- unsigned align = max(alignment, td->alignment);
- if(align > 1) {
- fprintf(fp,"\t\tptr+=(%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
- align, align, align);
- }
-
- fprintf(fp, "\t\t__1 = (struct %s_%s_1 *)(ptr);\n",
- ev->name, facName);
- }
- //allocate memory for new struct and initialize it
- //if(whichTypeFirst == 1){ //struct first
- //for(pos1=0;pos1<structCount;pos1++){
- // if(pos1==0) fprintf(fp,
- // "\tstruct %s_%s_1 * __1 = (struct %s_%s_1 *)buff;\n",
- // ev->name, facName,ev->name, facName);
- //MD disabled else fprintf(fp,
- // "\tstruct %s_%s_%d __%d;\n",
- // ev->name, facName,pos1+1,pos1+1);
- //}
- //}else if(whichTypeFirst == 2){
- // for(pos1=0;pos1<structCount;pos1++)
- // fprintf(fp,"\tstruct %s_%s_%d __%d;\n",
- // ev->name, facName,pos1+1,pos1+1);
- //}
- fprintf(fp,"\n");
-
- if(structCount) fprintf(fp,"\t\t//initialize structs\n");
- //flag = 0;
- //structCount = 0;
- if(ev->type != 0)
- for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
- fld = (field_t *)ev->type->fields.array[pos1];
- td = fld->type;
- if(td->type != ARRAY && td->type != SEQUENCE && td->type != STRING){
- //if(flag == 0){
- // flag = 1;
- // structCount++;
- // if(structCount > 1) fprintf(fp,"\n");
- //}
- fprintf(fp, "\t\t__1->%s = %s;\n", fld->name, fld->name );
-
- //if(structCount == 1 && whichTypeFirst == 1)
- // fprintf(fp, "\t__1->%s = %s;\n",fld->name,fld->name );
- //else
- // fprintf(fp, "\t__%d.%s = %s;\n",structCount ,fld->name,fld->name);
- }
- //else flag = 0;
- }
- if(structCount) fprintf(fp,"\n");
-
-
- //copy sequence and string to buffer
- seqCount = 0;
- strCount = 0;
- flag = 0;
- structCount = 0;
- if(ev->type != 0)
- for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
- fld = (field_t *)ev->type->fields.array[pos1];
- td = fld->type;
- // if(td->type != STRING && td->type != SEQUENCE && td->type != ARRAY){
- // if(flag == 0) structCount++;
- // flag++;
- // if((structCount > 1 || whichTypeFirst == 2) && flag == 1){
- // assert(0); // MD : disabled !
- // fprintf(fp,"\t//copy struct to buffer\n");
- // fprintf(fp,"\tmemcpy(ptr, &__%d, sizeof(struct %s_%s_%d));\n",
- // structCount, ev->name, facName,structCount);
- // fprintf(fp,"\tptr += sizeof(struct %s_%s_%d);\n\n",
- // ev->name, facName,structCount);
- // }
- // }
- //else if(td->type == SEQUENCE){
- if(td->type == SEQUENCE){
- flag = 0;
- fprintf(fp,"\t\t//copy sequence length and sequence to buffer\n");
-
- unsigned align = max(alignment, td->alignment);
- if(align > 1) {
- fprintf(fp,"\t\tptr+=(%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
- align, align, align);
- }
- fprintf(fp,"\t\t*ptr = seqlength_%d;\n",++seqCount);
- fprintf(fp,"\t\tptr += sizeof(%s);\n",uintOutputTypes[td->size]);
- if(align > 1) {
- fprintf(fp,"\t\tptr+=(%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
- align, align, align);
- }
- fprintf(fp,"\t\tmemcpy(ptr, %s, sizeof(%s) * seqlength_%d);\n",
- fld->name, getTypeStr(td), seqCount);
- fprintf(fp,"\t\tptr += sizeof(%s) * seqlength_%d;\n\n",
- getTypeStr(td), seqCount);
- }
- else if(td->type==STRING){
- flag = 0;
- fprintf(fp,"\t\t//copy string to buffer\n");
- fprintf(fp,"\t\tif(strlength_%d > 0){\n",++strCount);
- unsigned align = max(alignment, td->alignment);
- if(align > 1) {
- fprintf(fp,"\t\tptr+=(%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
- align, align, align);
- }
- fprintf(fp,"\t\t\tmemcpy(ptr, %s, strlength_%d + 1);\n",
- fld->name, strCount);
- fprintf(fp,"\t\t\tptr += strlength_%d + 1;\n",strCount);
- fprintf(fp,"\t\t}else{\n");
- fprintf(fp,"\t\t\t*ptr = '\\0';\n");
- fprintf(fp,"\t\t\tptr += 1;\n");
- fprintf(fp,"\t\t}\n\n");
- }else if(td->type==ARRAY){
- flag = 0;
- fprintf(fp,"\t//copy array to buffer\n");
- unsigned align = max(alignment, td->alignment);
- if(align > 1) {
- fprintf(fp,"\t\tptr+=(%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
- align, align, align);
- }
- fprintf(fp,"\tmemcpy(ptr, %s, sizeof(%s) * %d);\n",
- fld->name, getTypeStr(td), td->size);
- fprintf(fp,"\tptr += sizeof(%s) * %d;\n\n", getTypeStr(td), td->size);
- }
- }
- if(structCount + seqCount > 1) fprintf(fp,"\n");
-
-
-
-
- /* commit */
- ltt_commit_slot(buf, buff, slot_size);
-
-
-
-
-#if 0
- fprintf(fp, "\t\tdo {\n");
- fprintf(fp, "\t\t\told_offset = buf->offset;\n");
- fprintf(fp, "\t\t\tptr = (char*)buf->data + old_offset;\n");
-
-
- fprintf(fp, "\t\t\theader_length = ltt_get_event_header_data(trace, "
- "channel,\n"
- "\t\t\t\t\t\t\t\t\t\tptr, &_offset, &delta, &tsc);\n");
-
- fprintf(fp, "\t\t\tptr += _offset + header_length;\n");
-
- fprintf(fp, "\t\t\tbuff = relay_reserve(channel->rchan, event_length, "
- "old_offset);\n");
- fprintf(fp, "\n");
- fprintf(fp, "\t\t} while(PTR_ERR(buff) == -EAGAIN);\n");
- fprintf(fp, "\n");
-
-
- /* Reserve the channel */
- //fprintf(fp, "\t\tbuff = relay_reserve(channel->rchan, event_length);\n");
- fprintf(fp, "\t\tif(buff == NULL) {\n");
- fprintf(fp, "\t\t\t/* Buffer is full*/\n");
- fprintf(fp, "\t\t\t/* for debug BUG(); */\n"); // DEBUG!
- fprintf(fp, "\t\t\tchannel->events_lost[smp_processor_id()]++;\n");
- fprintf(fp, "\t\t\tbreak;\n"); /* don't commit a NULL reservation! */
- fprintf(fp, "\t\t}\n");
-
- /* DEBUG */
- //fprintf(fp, "\t\tif(resret == 1) {\n");
- //fprintf(fp, "printk(\"f%%lu e\%%u \", ltt_facility_%s_%X, event_%s);",
- // facName, checksum, ev->name);
- //fprintf(fp, "\t\t}\n");
-
- //set ptr to the end of first struct if needed;
- //if(structCount + hasStrSeq > 1){
- // fprintf(fp,"\n\t\t//set ptr to the end of the first struct\n");
- // fprintf(fp,"\t\tptr += sizeof(struct %s_%s_1);\n\n",ev->name, facName);
- //}
-
- fprintf(fp,"\n");
- fprintf(fp, "\t\t/* Commit the work */\n");
- fprintf(fp, "\t\trelay_commit(channel->rchan->buf[smp_processor_id()],\n"
- "\t\t\t\tbuff, event_length);\n");
- fprintf(fp, "\t\tltt_write_commit_counter("
- "channel->rchan->buf[smp_processor_id()],\n"
- "\t\t\t\tbuff);\n");
-#endif //0
-
- /* End of traces iteration */
- fprintf(fp, "\t}\n\n");
-
- fprintf(fp, "\n");
-
- fprintf(fp, "unlock:\n");
- fprintf(fp, "\tltt_nesting[smp_processor_id()]--;\n");
- fprintf(fp, "\tpreempt_enable_no_resched();\n");
- //fprintf(fp, "\tpreempt_check_resched();\n");
-
- //call trace function
- //fprintf(fp,"\n\t//call trace function\n");
- //fprintf(fp,"\tltt_log_event(ltt_facility_%s_%X, %s, bufLength, buff);\n",facName,checksum,ev->name);
- fprintf(fp,"}\n");
- fprintf(fp, "#endif //CONFIG_LTT\n\n");
- }
-
-}
-
-/*****************************************************************************
- *Function name
- * getTypeStr : generate type string
- *Input Params
- * td : a type descriptor
- *Return Values
- * char * : type string
- ****************************************************************************/
-char * getTypeStr(type_descriptor_t * td){
- type_descriptor_t * t ;
-
- switch(td->type){
- case INT:
- return intOutputTypes[td->size];
- case UINT:
- return uintOutputTypes[td->size];
- case POINTER:
- return "void *";
- case LONG:
- return "long";
- case ULONG:
- return "unsigned long";
- case SIZE_T:
- return "size_t";
- case SSIZE_T:
- return "ssize_t";
- case OFF_T:
- return "off_t";
- case FLOAT:
- return floatOutputTypes[td->size];
- case STRING:
- return "const char";
- case ENUM:
- return uintOutputTypes[td->size];
- case ARRAY:
- case SEQUENCE:
- t = td->nested_type;
- switch(t->type){
- case INT:
- return intOutputTypes[t->size];
- case UINT:
- return uintOutputTypes[t->size];
- case POINTER:
- return "void *";
- case LONG:
- return "long";
- case ULONG:
- return "unsigned long";
- case SIZE_T:
- return "size_t";
- case SSIZE_T:
- return "ssize_t";
- case OFF_T:
- return "off_t";
- case FLOAT:
- return floatOutputTypes[t->size];
- case STRING:
- return "const char";
- case ENUM:
- return uintOutputTypes[t->size];
- default :
- error_callback(NULL,"Nested struct is not supportted");
- break;
- }
- break;
- case STRUCT: //for now we do not support nested struct
- error_callback(NULL,"Nested struct is not supportted");
- break;
- default:
- error_callback(NULL,"No type information");
- break;
- }
- return NULL;
-}
-
-/*****************************************************************************
- *Function name
- * generateLoaderfile: generate a facility loaded .h file
- *Input Params
- * fp : file to be written to
- * facName : name of facility
- * nbEvent : number of events in the facility
- * checksum : checksum for the facility
- ****************************************************************************/
-void generateLoaderfile(FILE * fp, char * facName, int nbEvent, unsigned long checksum, char *capname){
- fprintf(fp, "#ifndef _LTT_FACILITY_LOADER_%s_H_\n",capname);
- fprintf(fp, "#define _LTT_FACILITY_LOADER_%s_H_\n\n",capname);
- fprintf(fp,"#include <linux/ltt-facilities.h>\n", facName, checksum);
- fprintf(fp,"ltt_facility_t\tltt_facility_%s;\n", facName, checksum);
- fprintf(fp,"ltt_facility_t\tltt_facility_%s_%X;\n\n", facName, checksum);
-
- fprintf(fp,"#define LTT_FACILITY_SYMBOL\t\t\t\t\t\t\tltt_facility_%s\n",
- facName);
- fprintf(fp,"#define LTT_FACILITY_CHECKSUM_SYMBOL\t\tltt_facility_%s_%X\n",
- facName, checksum);
- fprintf(fp,"#define LTT_FACILITY_CHECKSUM\t\t\t\t\t\t0x%X\n", checksum);
- fprintf(fp,"#define LTT_FACILITY_NAME\t\t\t\t\t\t\t\t\"%s\"\n", facName);
- fprintf(fp,"#define LTT_FACILITY_NUM_EVENTS\t\t\t\t\t%d\n\n", nbEvent);
- fprintf(fp, "#endif //_LTT_FACILITY_LOADER_%s_H_\n",capname);
-}
-
-void generateCfile(FILE * fp, char * filefacname){
-
- fprintf(fp, "/*\n");
- fprintf(fp, " * ltt-facility-loader-%s.c\n", filefacname);
- fprintf(fp, " *\n");
- fprintf(fp, " * (C) Copyright 2005 - \n");
- fprintf(fp, " * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)\n");
- fprintf(fp, " *\n");
- fprintf(fp, " * Contains the LTT facility loader.\n");
- fprintf(fp, " *\n");
- fprintf(fp, " */\n");
- fprintf(fp, "\n");
- fprintf(fp, "\n");
- fprintf(fp, "#include <linux/ltt-facilities.h>\n");
- fprintf(fp, "#include <linux/module.h>\n");
- fprintf(fp, "#include <linux/init.h>\n");
- fprintf(fp, "#include <linux/config.h>\n");
- fprintf(fp, "#include \"ltt-facility-loader-%s.h\"\n", filefacname);
- fprintf(fp, "\n");
- fprintf(fp, "\n");
- fprintf(fp, "#ifdef CONFIG_LTT\n");
- fprintf(fp, "\n");
- fprintf(fp, "EXPORT_SYMBOL(LTT_FACILITY_SYMBOL);\n");
- fprintf(fp, "EXPORT_SYMBOL(LTT_FACILITY_CHECKSUM_SYMBOL);\n");
- fprintf(fp, "\n");
- fprintf(fp, "static const char ltt_facility_name[] = LTT_FACILITY_NAME;\n");
- fprintf(fp, "\n");
- fprintf(fp, "#define SYMBOL_STRING(sym) #sym\n");
- fprintf(fp, "\n");
- fprintf(fp, "static struct ltt_facility facility = {\n");
- fprintf(fp, "\t.name = ltt_facility_name,\n");
- fprintf(fp, "\t.num_events = LTT_FACILITY_NUM_EVENTS,\n");
- fprintf(fp, "\t.checksum = LTT_FACILITY_CHECKSUM,\n");
- fprintf(fp, "\t.symbol = SYMBOL_STRING(LTT_FACILITY_SYMBOL),\n");
- fprintf(fp, "\t.alignment = %u\n", alignment); /* default alignment */
- fprintf(fp, "};\n");
- fprintf(fp, "\n");
- fprintf(fp, "#ifndef MODULE\n");
- fprintf(fp, "\n");
- fprintf(fp, "/* Built-in facility. */\n");
- fprintf(fp, "\n");
- fprintf(fp, "static int __init facility_init(void)\n");
- fprintf(fp, "{\n");
- fprintf(fp, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init in kernel\\n\");\n", filefacname);
- fprintf(fp, "\n");
- fprintf(fp, "\tLTT_FACILITY_SYMBOL = ltt_facility_builtin_register(&facility);\n");
- fprintf(fp, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
- fprintf(fp, "\t\n");
- fprintf(fp, "\treturn LTT_FACILITY_SYMBOL;\n");
- fprintf(fp, "}\n");
- fprintf(fp, "__initcall(facility_init);\n");
- fprintf(fp, "\n");
- fprintf(fp, "\n");
- fprintf(fp, "\n");
- fprintf(fp, "#else \n");
- fprintf(fp, "\n");
- fprintf(fp, "/* Dynamic facility. */\n");
- fprintf(fp, "\n");
- fprintf(fp, "static int __init facility_init(void)\n");
- fprintf(fp, "{\n");
- fprintf(fp, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init dynamic\\n\");\n", filefacname);
- fprintf(fp, "\n");
- fprintf(fp, "\tLTT_FACILITY_SYMBOL = ltt_facility_dynamic_register(&facility);\n");
- fprintf(fp, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
- fprintf(fp, "\n");
- fprintf(fp, "\treturn LTT_FACILITY_SYMBOL;\n");
- fprintf(fp, "}\n");
- fprintf(fp, "\n");
- fprintf(fp, "static void __exit facility_exit(void)\n");
- fprintf(fp, "{\n");
- fprintf(fp, "\tint err;\n");
- fprintf(fp, "\n");
- fprintf(fp, "\terr = ltt_facility_dynamic_unregister(LTT_FACILITY_SYMBOL);\n");
- fprintf(fp, "\tif(err != 0)\n");
- fprintf(fp, "\t\tprintk(KERN_ERR \"LTT : Error in unregistering facility.\\n\");\n");
- fprintf(fp, "\n");
- fprintf(fp, "}\n");
- fprintf(fp, "\n");
- fprintf(fp, "module_init(facility_init)\n");
- fprintf(fp, "module_exit(facility_exit)\n");
- fprintf(fp, "\n");
- fprintf(fp, "\n");
- fprintf(fp, "MODULE_LICENSE(\"GPL\");\n");
- fprintf(fp, "MODULE_AUTHOR(\"Mathieu Desnoyers\");\n");
- fprintf(fp, "MODULE_DESCRIPTION(\"Linux Trace Toolkit Facility\");\n");
- fprintf(fp, "\n");
- fprintf(fp, "#endif //MODULE\n");
- fprintf(fp, "\n");
- fprintf(fp, "#endif //CONFIG_LTT\n");
-}
-
-
+++ /dev/null
-
-void generateFile(char * file);
-void generateHfile(FILE *);
-void generateCfile(FILE * fp, char * facName);
-void generateTypeDefs(FILE *, char *facName);
-void generateEnumEvent(FILE * fp,char * facName, int * nbEvent, unsigned long checksum);
-void generateStructFunc(FILE * fp, char * facName, unsigned long checksum);
-void generateLoaderfile(FILE * fp, char * facName, int nbEvent, unsigned long checksum, char *capname);
-void generateEnumDefinition(FILE * fp, type_descriptor_t * fHead);
-char * getTypeStr(type_descriptor_t * td);
-
-
+++ /dev/null
-/*
-
-parser.c: Generate helper declarations and functions to trace events
- from an event description file.
-
-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 "parser.h"
-
-
-/* helper function */
-void strupper(char *string)
-{
- char *ptr = string;
-
- while(*ptr != '\0') {
- *ptr = toupper(*ptr);
- ptr++;
- }
-}
-
-
-int getSizeindex(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
- *****************************************************************************/
-
-int getSize(parse_file_t *in)
-{
- char *token;
-
- token = getToken(in);
- if(in->type == NUMBER) {
- if(strcmp(token,"1") == 0) return 0;
- else if(strcmp(token,"2") == 0) return 1;
- else if(strcmp(token,"4") == 0) return 2;
- else if(strcmp(token,"8") == 0) return 3;
- }
- else if(in->type == NAME) {
- if(strcmp(token,"short") == 0) return 4;
- else if(strcmp(token,"medium") == 0) return 5;
- else if(strcmp(token,"long") == 0) return 6;
- }
- 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)
-{
- char * token;
- char car;
-
- t->fmt = NULL;
- t->size = -1;
- t->alignment = 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("align",token)) {
- getEqual(in);
- t->alignment = getNumber(in);
- }
- }
-}
-
-/**************************************************************************
- * 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;
-
- 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("per_trace", token)) {
- ev->per_trace = 1;
- } else if(!strcmp("per_tracefile", token)) {
- ev->per_tracefile = 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;
-
- 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));
- }
- }
-}
-
-/**************************************************************************
- * 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("/",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 == '\"') name = allocAndCopy(getQuotedString(in));
- else name = allocAndCopy(getName(in));
- }
- }
- if(name == NULL) in->error(in, "Name was expected");
- return name;
-
-}
-
-
-
-//for <label name=label_name value=n format="..."/>, value is an option
-char * getValueStrAttribute(parse_file_t *in)
-{
- char * token;
-
- token = getToken(in);
- if(strcmp("/",token) == 0){
- ungetToken(in);
- return NULL;
- }
-
- if(strcmp("value",token))in->error(in,"value was expected");
- getEqual(in);
- token = getToken(in);
- if(in->type != NUMBER) in->error(in,"number was expected");
- return token;
-}
-
-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;
- type_descriptor_t *t;
-
- //<event name=eventtype_name>
- getEventAttributes(in, ev);
- if(ev->name == NULL) in->error(in, "Event not named");
- getRAnglebracket(in);
-
- //<description>...</descriptio>
- ev->description = getDescription(in);
-
- //event can have STRUCT, TYPEREF or NOTHING
- getLAnglebracket(in);
-
- token = getToken(in);
- 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");
-
- token = getName(in);
- if(strcmp("event",token))in->error(in,"not an event definition");
- getRAnglebracket(in); //</event>
-}
-
-/*****************************************************************************
- *Function name
- * parseField : get field infomation from buffer
- *Input params
- * in : input file handle
- * t : type descriptor
- * unnamed_types : array of unamed types
- * named_types : array of named types
- ****************************************************************************/
-
-void parseFields(parse_file_t *in, type_descriptor_t *t,
- sequence_t * unnamed_types,
- table_t * named_types)
-{
- char * token;
- field_t *f;
-
- f = (field_t *)memAlloc(sizeof(field_t));
- sequence_push(&(t->fields),f);
-
- //<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);
-
- //<int size=...>
- getLAnglebracket(in);
- f->type = parseType(in,NULL, unnamed_types, named_types);
-
- 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;
-
- 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);
- getRAnglebracket(in); //<struct>
- getLAnglebracket(in); //<field name=..>
- token = getToken(in);
- sequence_init(&(t->fields));
- while(strcmp("field",token) == 0){
- parseFields(in,t, unnamed_types, named_types);
-
- //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);
- if(t->size == -1) in->error(in, "Union has empty size");
- getRAnglebracket(in); //<union typecodesize=isize>
-
- getLAnglebracket(in); //<field name=..>
- token = getToken(in);
- sequence_init(&(t->fields));
- while(strcmp("field",token) == 0){
- parseFields(in,t, unnamed_types, named_types);
-
- //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;
- getTypeAttributes(in, t);
- if(t->size == -1) in->error(in, "Array has empty size");
- getRAnglebracket(in); //<array size=n>
-
- 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;
- getTypeAttributes(in, t);
- if(t->size == -1) in->error(in, "Sequence has empty size");
- getRAnglebracket(in); //<array lengthsize=isize>
-
- getLAnglebracket(in); //<type struct>
- t->nested_type = parseType(in,NULL, unnamed_types, named_types);
-
- 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, *str1;
- t->type = ENUM;
- sequence_init(&(t->labels));
- sequence_init(&(t->labels_description));
- t->already_printed = 0;
- getTypeAttributes(in, t);
- if(t->size == -1) in->error(in, "Sequence has empty size");
- getRAnglebracket(in);
-
- //<label name=label1 value=n/>
- getLAnglebracket(in);
- token = getToken(in); //"label" or "/"
- while(strcmp("label",token) == 0){
- str = allocAndCopy(getNameAttribute(in));
- token = getValueStrAttribute(in);
- if(token){
- str1 = appendString(str,"=");
- free(str);
- str = appendString(str1,token);
- free(str1);
- sequence_push(&(t->labels),str);
- }
- else
- sequence_push(&(t->labels),str);
-
- 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") == 0) {
- t->type = INT;
- getTypeAttributes(in, t);
- if(t->size == -1) in->error(in, "int has empty size");
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"uint") == 0) {
- t->type = UINT;
- getTypeAttributes(in, t);
- if(t->size == -1) in->error(in, "uint has empty size");
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"pointer") == 0) {
- t->type = POINTER;
- getTypeAttributes(in, t);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"long") == 0) {
- t->type = LONG;
- getTypeAttributes(in, t);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"ulong") == 0) {
- t->type = ULONG;
- getTypeAttributes(in, t);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"size_t") == 0) {
- t->type = SIZE_T;
- getTypeAttributes(in, t);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"ssize_t") == 0) {
- t->type = SSIZE_T;
- getTypeAttributes(in, t);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"off_t") == 0) {
- t->type = OFF_T;
- getTypeAttributes(in, t);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"float") == 0) {
- t->type = FLOAT;
- getTypeAttributes(in, t);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"string") == 0) {
- t->type = STRING;
- getTypeAttributes(in, t);
- getForwardslash(in);
- getRAnglebracket(in);
- }
- else if(strcmp(token,"typeref") == 0){
- // Must be a named type
- if(inType != NULL)
- in->error(in,"Named type cannot refer to a named type");
- else {
- free(t);
- sequence_pop(unnamed_types);
- token = getNameAttribute(in);
- t = find_named_type(token, named_types);
- 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);
- if(t == NULL) {
- 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 = find_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);
- 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");
- 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(isalpha(car)) {
- in->buffer[0] = car;
- pos = 1;
- while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
- if(!(isalnum(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 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 long * checksum, sequence_t * events)
-{
- unsigned long crc ;
- int pos;
- event_t * ev;
- char str[256];
-
- crc = crc32(facName);
- for(pos = 0; pos < events->position; pos++){
- ev = (event_t *)(events->array[pos]);
- crc = partial_crc32(ev->name,crc);
- if(!ev->type) continue; //event without type
- if(ev->type->type != STRUCT){
- sprintf(str,"event '%s' has a type other than STRUCT",ev->name);
- error_callback(NULL, str);
- }
- crc = getTypeChecksum(crc, ev->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:
- str = intOutputTypes[type->size];
- break;
- case UINT:
- str = uintOutputTypes[type->size];
- break;
- case POINTER:
- str = allocAndCopy("void *");
- 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[type->size];
- break;
- case STRING:
- str = allocAndCopy("string");
- flag = 1;
- break;
- case ENUM:
- str = appendString("enum ", uintOutputTypes[type->size]);
- flag = 1;
- break;
- case ARRAY:
- sprintf(buf,"%d",type->size);
- str = appendString("array ",buf);
- flag = 1;
- break;
- case SEQUENCE:
- sprintf(buf,"%d",type->size);
- str = appendString("sequence ",buf);
- 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 || type->type == SEQUENCE){
- crc = getTypeChecksum(crc,type->nested_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));
- }
- 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, pos2;
- type_descriptor_t *tp;
- field_t *f;
-
- 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);
- 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)
-{
- 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,
- UINT,
- POINTER,
- LONG,
- ULONG,
- SIZE_T,
- SSIZE_T,
- OFF_T,
- FLOAT,
- STRING,
- ENUM,
- ARRAY,
- SEQUENCE,
- STRUCT,
- UNION,
- NONE
-} data_type_t;
-
-/* Event type descriptors */
-
-typedef struct _type_descriptor {
- char * type_name; //used for named type
- data_type_t type;
- char *fmt;
- int size;
- sequence_t labels; // for enumeration
- sequence_t labels_description;
- int already_printed;
- sequence_t fields; // for structure
- struct _type_descriptor *nested_type; // for array and sequence
- int alignment;
-} type_descriptor_t;
-
-
-/* Fields within types */
-
-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;
- 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 ? */
-} event_t;
-
-typedef struct _facility {
- char * name;
- char * capname;
- char * description;
- sequence_t events;
- sequence_t unnamed_types;
- table_t named_types;
-} facility_t;
-
-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, type_descriptor_t *t,
- sequence_t * unnamed_types, table_t * named_types);
-void checkNamedTypesImplemented(table_t * namedTypes);
-type_descriptor_t * find_named_type(char *name, table_t * named_types);
-void generateChecksum(char * facName,
- unsigned long * 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);
-char * getValueStrAttribute(parse_file_t *in);
-
-char * getDescription(parse_file_t *in);
-
-
-static char *intOutputTypes[] = {
- "int8_t", "int16_t", "int32_t", "int64_t", "short int", "int", "long int" };
-
-static char *uintOutputTypes[] = {
- "uint8_t", "uint16_t", "uint32_t", "uint64_t", "unsigned short int",
- "unsigned int", "unsigned long int" };
-
-static char *floatOutputTypes[] = {
- "undef", "undef", "float", "double", "undef", "float", "double" };
-
-
-/* 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;
-}
-
-
-#endif // PARSER_H
projects / lttv.git / commitdiff
