genevent/genevent.c

   1 /*
   2
   3 genevent.c: Generate helper declarations and functions to trace events
   4   from an event description file.
   5
   6 Copyright (C) 2002, Xianxiu Yang
   7 Copyright (C) 2002, Michel Dagenais
   8
   9 This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; version 2 of the License.
  12
  13 This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21 */
  22
  23 /* This program reads the ".event" event definitions input files
  24    specified as command line arguments and generates corresponding
  25    ".c" and ".h" files required to trace such events in the kernel.
  26
  27    The program uses a very simple tokenizer, called from a hand written
  28    recursive descent parser to fill a data structure describing the events.
  29    The result is a sequence of events definitions which refer to type
  30    definitions.
  31
  32    A table of named types is maintained to allow refering to types by name
  33    when the same type is used at several places. Finally a sequence of
  34    all types is maintained to facilitate the freeing of all type
  35    information when the processing of an ".event" file is finished. */
  36
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <ctype.h>
  40 #include <stdio.h>
  41 #include <stdarg.h>
  42 #include <linux/errno.h>
  43 #include <assert.h>
  44
  45 #include "parser.h"
  46 #include "genevent.h"
  47
  48 /* Named types may be referenced from anywhere */
  49
  50 facility * fac;
  51
  52 int main(int argc, char** argv)
  53 {
  54   char *token;
  55   parse_file in;
  56   char buffer[BUFFER_SIZE];
  57   int i;
  58
  59   if(argc < 2){
  60     printf("At least one event definition file is needed\n");
  61     exit(1);
  62   }
  63
  64   in.buffer = buffer;
  65   in.error = error_callback;
  66
  67   for(i = 1 ; i < argc ; i++) {
  68     in.lineno = 0;
  69     in.name = allocAndCopy(argv[i]);
  70
  71     in.fp = fopen(in.name, "r");
  72     if(!in.fp ){
  73       in.error(&in,"cannot open facility input file");
  74     }
  75
  76     while(1){
  77       token = getToken(&in);
  78       if(in.type == ENDFILE) break;
  79
  80       if(strcmp(token, "<")) in.error(&in,"not a facility file");
  81       token = getName(&in);
  82
  83       if(strcmp("facility",token) == 0) {
  84         fac = memAlloc(sizeof(facility));
  85         fac->name = NULL;
  86         fac->description = NULL;
  87         sequence_init(&(fac->events));
  88         table_init(&(fac->named_types));
  89         sequence_init(&(fac->unnamed_types));
  90
  91         parseFacility(&in, fac);
  92
  93         //check if any namedType is not defined
  94         checkNamedTypesImplemented(&fac->named_types);
  95       }
  96       else in.error(&in,"facility token was expected");
  97
  98       generateFile(argv[i]);
  99
 100       free(fac->name);
 101       free(fac->description);
 102       freeEvents(&fac->events);
 103       sequence_dispose(&fac->events);
 104       freeNamedType(&fac->named_types);
 105       table_dispose(&fac->named_types);
 106       freeTypes(&fac->unnamed_types);
 107       sequence_dispose(&fac->unnamed_types);
 108       free(fac);
 109     }
 110
 111     free(in.name);
 112     fclose(in.fp);
 113
 114   }
 115   return 0;
 116 }
 117
 118
 119 /*****************************************************************************
 120  *Function name
 121  *    generateFile : generate .c and .h file
 122  *Input Params
 123  *    name         : name of event definition file
 124  ****************************************************************************/
 125 void generateFile(char *name){
 126   char *loadName, *hName, *hIdName, *cName, *tmp, *tmp2;
 127   FILE * lFp, *hFp, *iFp, *cFp;
 128   int nbEvent;
 129   unsigned long checksum=0;
 130
 131   //remove .xml if it exists
 132   tmp = &name[strlen(name)-4];
 133   if(strcmp(tmp, ".xml") == 0){
 134     *tmp = '\0';
 135   }
 136
 137   tmp = strrchr(name,'/');
 138   if(tmp){
 139     tmp++;
 140   }else{
 141     tmp = name;
 142   }
 143
 144   loadName = appendString("ltt-facility-loader-", tmp);
 145   tmp2 = appendString(loadName,".h");
 146   free(loadName);
 147   loadName = tmp2;
 148   hName = appendString("ltt-facility-", tmp);
 149   tmp2 = appendString(hName,".h");
 150   free(hName);
 151   hName = tmp2;
 152   hIdName = appendString("ltt-facility-id-", tmp);
 153   tmp2 = appendString(hIdName,".h");
 154   free(hIdName);
 155   hIdName = tmp2;
 156   cName = appendString("ltt-facility-loader-", tmp);
 157   tmp2 = appendString(cName,".c");
 158   free(cName);
 159   cName = tmp2;
 160   lFp = fopen(loadName,"w");
 161   if(!lFp){
 162     printf("Cannot open the file : %s\n",loadName);
 163     exit(1);
 164   }
 165
 166   hFp = fopen(hName,"w");
 167   if(!hFp){
 168      printf("Cannot open the file : %s\n",hName);
 169      exit(1);
 170   }
 171
 172   iFp = fopen(hIdName,"w");
 173   if(!iFp){
 174      printf("Cannot open the file : %s\n",hIdName);
 175      exit(1);
 176   }
 177
 178   cFp = fopen(cName,"w");
 179   if(!cFp){
 180      printf("Cannot open the file : %s\n",cName);
 181      exit(1);
 182   }
 183
 184   free(loadName);
 185   free(hName);
 186   free(hIdName);
 187   free(cName);
 188
 189   generateChecksum(fac->name, &checksum, &(fac->events));
 190
 191   /* generate .h file, event enumeration then structures and functions */
 192   fprintf(iFp, "#ifndef _LTT_FACILITY_ID_%s_H_\n",fac->capname);
 193   fprintf(iFp, "#define _LTT_FACILITY_ID_%s_H_\n\n",fac->capname);
 194   fprintf(iFp, "#ifdef CONFIG_LTT\n");
 195   generateEnumEvent(iFp, fac->name, &nbEvent, checksum);
 196   fprintf(iFp, "#endif //CONFIG_LTT\n");
 197   fprintf(iFp, "#endif //_LTT_FACILITY_ID_%s_H_\n",fac->capname);
 198
 199
 200   fprintf(hFp, "#ifndef _LTT_FACILITY_%s_H_\n",fac->capname);
 201   fprintf(hFp, "#define _LTT_FACILITY_%s_H_\n\n",fac->capname);
 202   //fprintf(hFp, "#ifdef CONFIG_LTT\n");
 203   generateTypeDefs(hFp, fac->name);
 204   generateStructFunc(hFp, fac->name,checksum);
 205   //fprintf(hFp, "#endif //CONFIG_LTT\n");
 206   fprintf(hFp, "#endif //_LTT_FACILITY_%s_H_\n",fac->capname);
 207
 208   /* generate .h file, calls to register the facility at init time */
 209   generateLoaderfile(lFp,fac->name,nbEvent,checksum,fac->capname);
 210
 211   // create ltt-facility-loader-facname.c
 212   generateCfile(cFp, tmp);
 213
 214   fclose(hFp);
 215   fclose(iFp);
 216   fclose(lFp);
 217   fclose(cFp);
 218
 219 }
 220
 221
 222 /*****************************************************************************
 223  *Function name
 224  *    generateEnumEvent : output event enum to .h file
 225  *Input Params
 226  *    fp                : file to be written to
 227  *    facName           : name of facility
 228  *Output Params
 229  *    nbEvent           : number of events in the facility
 230  ****************************************************************************/
 231 void generateEnumEvent(FILE *fp, char *facName, int * nbEvent, unsigned long checksum) {
 232   int pos = 0;
 233
 234   fprintf(fp,"#include <linux/ltt-facilities.h>\n\n");
 235
 236   fprintf(fp,"/****  facility handle  ****/\n\n");
 237   fprintf(fp,"extern ltt_facility_t ltt_facility_%s_%X;\n",facName, checksum);
 238   fprintf(fp,"extern ltt_facility_t ltt_facility_%s;\n\n\n",facName, checksum);
 239
 240   fprintf(fp,"/****  event type  ****/\n\n");
 241   fprintf(fp,"enum %s_event {\n",facName);
 242
 243   for(pos = 0; pos < fac->events.position;pos++) {
 244     fprintf(fp,"\tevent_%s", ((event *)(fac->events.array[pos]))->name);
 245     if(pos != fac->events.position-1) fprintf(fp,",\n");
 246   }
 247   fprintf(fp,"\n};\n\n\n");
 248
 249   //  fprintf(fp,"/****  number of events in the facility  ****/\n\n");
 250   //  fprintf(fp,"int nbEvents_%s = %d;\n\n\n",facName, fac->events.position);
 251   *nbEvent = fac->events.position;
 252 }
 253
 254
 255 /*****************************************************************************
 256  *Function name
 257  *    printStruct       : Generic struct printing function
 258  *Input Params
 259  *    fp                : file to be written to
 260  *    len               : number of fields
 261  *    array             : array of field info
 262  *    name              : basic struct name
 263  *    facName           : name of facility
 264  *    whichTypeFirst    : struct or array/sequence first
 265  *    hasStrSeq         : string or sequence present?
 266  *    structCount       : struct postfix
 267  ****************************************************************************/
 268
 269 static void
 270 printStruct(FILE * fp, int len, void ** array, char * name, char * facName,
 271        int * whichTypeFirst, int * hasStrSeq, int * structCount,
 272        type_descriptor *type)
 273 {
 274   int flag = 0;
 275   int pos;
 276   field * fld;
 277   type_descriptor * td;
 278
 279   for (pos = 0; pos < len; pos++) {
 280     fld  = (field *)array[pos];
 281     td = fld->type;
 282     if( td->type == STRING || td->type == SEQUENCE ||
 283         td->type == ARRAY) {
 284         (*hasStrSeq)++;
 285                 }
 286 //      if (*whichTypeFirst == 0) {
 287 //        *whichTypeFirst = 1; //struct first
 288 //      }
 289       if (flag == 0) {
 290         flag = 1;
 291
 292         fprintf(fp,"struct %s_%s",name, facName);
 293         if (structCount) {
 294           fprintf(fp, "_%d {\n",++*structCount);
 295         } else {
 296           fprintf(fp, " {\n");
 297         }
 298       }
 299       fprintf(fp, "\t%s %s; /* %s */\n",
 300           getTypeStr(td),fld->name,fld->description );
 301 #if 0
 302     } else {
 303         if (*whichTypeFirst == 0) {
 304         //string or sequence or array first
 305           *whichTypeFirst = 2;
 306         }
 307         (*hasStrSeq)++;
 308         if(flag) {
 309           fprintf(fp,"} __attribute__ ((packed));\n\n");
 310         }
 311         flag = 0;
 312     }
 313 #endif //0
 314   }
 315
 316   if(flag) {
 317     if(type->alignment == 0)
 318       fprintf(fp,"} __attribute__ ((packed));\n\n");
 319     else {
 320       if(type->alignment != 1 && type->alignment != 2
 321           && type->alignment != 4 && type->alignment != 8) {
 322         printf("Wrong alignment %i, using packed.\n", type->alignment);
 323         fprintf(fp,"} __attribute__ ((packed));\n\n");
 324       } else
 325         fprintf(fp,"} __attribute__ ((aligned(%i)));\n\n", type->alignment);
 326     }
 327   }
 328 }
 329
 330
 331 /*****************************************************************************
 332  *Function name
 333  *    generateHfile     : Create the typedefs
 334  *Input Params
 335  *    fp                : file to be written to
 336  ****************************************************************************/
 337 void
 338 generateTypeDefs(FILE * fp, char *facName)
 339 {
 340   int pos, tmp = 1;
 341
 342   fprintf(fp,"#include <linux/types.h>\n");
 343   fprintf(fp,"#include <linux/spinlock.h>\n");
 344   fprintf(fp,"#include <linux/ltt/ltt-facility-id-%s.h>\n\n", facName);
 345   fprintf(fp,"#include <linux/ltt-core.h>\n");
 346
 347 #if 0 //broken
 348   fprintf(fp, "/****  Basic Type Definitions  ****/\n\n");
 349
 350   for (pos = 0; pos < fac->named_types.values.position; pos++) {
 351     type_descriptor * type =
 352       (type_descriptor*)fac->named_types.values.array[pos];
 353     printStruct(fp, type->fields.position, type->fields.array,
 354                 "", type->type_name, &tmp, &tmp, NULL);
 355     fprintf(fp, "typedef struct _%s %s;\n\n",
 356             type->type_name, type->type_name);
 357   }
 358 #endif //0
 359 }
 360
 361
 362 /*****************************************************************************
 363  *Function name
 364  *    generateEnumDefinition: generate enum definition if it exists
 365  *Input Params
 366  *    fp                    : file to be written to
 367  *    fHead                 : enum type
 368  ****************************************************************************/
 369 void generateEnumDefinition(FILE * fp, type_descriptor * type){
 370   int pos;
 371
 372   if(type->already_printed) return;
 373
 374   fprintf(fp,"enum {\n");
 375   for(pos = 0; pos < type->labels.position; pos++){
 376     fprintf(fp,"\tLTT_ENUM_%s", type->labels.array[pos]);
 377     if (pos != type->labels.position - 1) fprintf(fp,",");
 378     if(type->labels_description.array[pos] != NULL)
 379       fprintf(fp,"\t/* %s */\n",type->labels_description.array[pos]);
 380     else
 381       fprintf(fp,"\n");
 382   }
 383   fprintf(fp,"};\n\n\n");
 384
 385   type->already_printed = 1;
 386 }
 387
 388 /*****************************************************************************
 389  *Function name
 390  *    generateStrucTFunc: output structure and function to .h file
 391  *Input Params
 392  *    fp                : file to be written to
 393  *    facName           : name of facility
 394  ****************************************************************************/
 395 void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
 396   event * ev;
 397   field * fld;
 398   type_descriptor * td;
 399   int pos, pos1;
 400   int hasStrSeq, flag, structCount, seqCount,strCount, whichTypeFirst=0;
 401
 402   for(pos = 0; pos < fac->events.position; pos++){
 403     ev = (event *) fac->events.array[pos];
 404     //yxx    if(ev->nested)continue;
 405     fprintf(fp,"/****  structure and trace function for event: %s  ****/\n\n",
 406         ev->name);
 407     //if(ev->type == 0){ // event without type
 408     //  fprintf(fp,"static inline void trace_%s_%s(void){\n",facName,ev->name);
 409     //  fprintf(fp,"\tltt_log_event(ltt_facility_%s_%X, event_%s, 0, NULL);\n",
 410     //      facName,checksum,ev->name);
 411     //  fprintf(fp,"};\n\n\n");
 412     //  continue;
 413     //}
 414
 415     //if fields contain enum, print out enum definition
 416     //MD : fixed in generateEnumDefinition to do not print the same enum
 417     //twice.
 418     if(ev->type != 0)
 419       for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
 420         fld = (field *)ev->type->fields.array[pos1];
 421         if(fld->type->type == ENUM) generateEnumDefinition(fp, fld->type);
 422       }
 423
 424     //default: no string, array or sequence in the event
 425     hasStrSeq = 0;
 426     whichTypeFirst = 0;
 427     structCount = 0;
 428
 429     //structure for kernel
 430     if(ev->type != 0)
 431       printStruct(fp, ev->type->fields.position, ev->type->fields.array,
 432         ev->name, facName, &whichTypeFirst, &hasStrSeq, &structCount,
 433         ev->type);
 434
 435
 436     //trace function : function name and parameters : stub function.
 437     seqCount = 0;
 438     strCount = 0;
 439                 fprintf(fp, "#ifndef CONFIG_LTT\n");
 440     fprintf(fp,"static inline void trace_%s_%s(",facName,ev->name);
 441     if(ev->type == 0)
 442       fprintf(fp, "void");
 443     else
 444       for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
 445         fld  = (field *)ev->type->fields.array[pos1];
 446         td = fld->type;
 447         if(td->type == ARRAY ){
 448           fprintf(fp,"%s * %s",getTypeStr(td), fld->name);
 449         }else if(td->type == STRING){
 450           fprintf(fp,"short int strlength_%d, %s * %s",
 451               ++strCount, getTypeStr(td), fld->name);
 452        }else if(td->type == SEQUENCE){
 453           fprintf(fp,"%s seqlength_%d, %s * %s",
 454               uintOutputTypes[td->size], ++seqCount,getTypeStr(td), fld->name);
 455        }else fprintf(fp,"%s %s",getTypeStr(td), fld->name);
 456        if(pos1 != ev->type->fields.position - 1) fprintf(fp,", ");
 457       }
 458     fprintf(fp,")\n{\n");
 459     fprintf(fp,"}\n");
 460                 fprintf(fp,"#else\n");
 461
 462     //trace function : function name and parameters
 463     seqCount = 0;
 464     strCount = 0;
 465     fprintf(fp,"static inline void trace_%s_%s(",facName,ev->name);
 466     if(ev->type == 0)
 467       fprintf(fp, "void");
 468     else
 469       for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
 470         fld  = (field *)ev->type->fields.array[pos1];
 471         td = fld->type;
 472         if(td->type == ARRAY ){
 473           fprintf(fp,"%s * %s",getTypeStr(td), fld->name);
 474         }else if(td->type == STRING){
 475           fprintf(fp,"short int strlength_%d, %s * %s",
 476               ++strCount, getTypeStr(td), fld->name);
 477        }else if(td->type == SEQUENCE){
 478           fprintf(fp,"%s seqlength_%d, %s * %s",
 479               uintOutputTypes[td->size], ++seqCount,getTypeStr(td), fld->name);
 480        }else fprintf(fp,"%s %s",getTypeStr(td), fld->name);
 481        if(pos1 != ev->type->fields.position - 1) fprintf(fp,", ");
 482       }
 483     fprintf(fp,")\n{\n");
 484
 485
 486
 487     //allocate buffer
 488     // MD no more need. fprintf(fp,"\tchar buff[buflength];\n");
 489     // write directly to the channel
 490     fprintf(fp, "\tunsigned int index;\n");
 491     fprintf(fp, "\tstruct ltt_channel_struct *channel;\n");
 492     fprintf(fp, "\tstruct ltt_trace_struct *trace;\n");
 493     fprintf(fp, "\tunsigned long _flags;\n");
 494     fprintf(fp, "\tvoid *buff;\n");
 495     fprintf(fp, "\tvoid *old_address;\n");
 496     fprintf(fp, "\tunsigned int header_length;\n");
 497     fprintf(fp, "\tunsigned int event_length;\n");      // total size (incl hdr)
 498                 fprintf(fp, "\tunsigned int length;\n");        // Size of the event var data.
 499     fprintf(fp, "\tunsigned char _offset;\n");
 500                 fprintf(fp, "\tstruct rchan_buf *buf;\n");
 501                 fprintf(fp, "\tstruct timeval delta;\n");
 502                 fprintf(fp, "\tu64 tsc;\n");
 503
 504                 if(ev->type != 0)
 505       fprintf(fp, "\tstruct %s_%s_1* __1;\n\n", ev->name, facName);
 506
 507                 /* Warning : this is done prior to taking locks :
 508                  * setting this value must be done at the end of the trace activation.
 509                  * (we don't care for trace removal, as the list of traces is protected : it
 510                  * just won't iterate on any trace). */
 511     fprintf(fp,
 512         "\tif(ltt_traces.num_active_traces == 0) return;\n\n");
 513
 514     fprintf(fp, "\t/* Disable interrupts. */\n");
 515     fprintf(fp, "\tlocal_irq_save(_flags);\n");
 516     fprintf(fp, "\tpreempt_disable();\n\n");
 517
 518                 fprintf(fp, "\tltt_nesting[smp_processor_id()]++;\n");
 519                 fprintf(fp, "\tbarrier();\n");
 520                 fprintf(fp, "\tif(ltt_nesting[smp_processor_id()] > 1) goto unlock;\n");
 521     fprintf(fp, "\tspin_lock(&ltt_traces.locks[smp_processor_id()]);\n\n");
 522
 523     fprintf(fp,
 524         "\tindex = ltt_get_index_from_facility(ltt_facility_%s_%X,\n"\
 525             "\t\t\t\tevent_%s);\n",
 526         facName, checksum, ev->name);
 527     fprintf(fp,"\n");
 528
 529     /* For each trace */
 530     fprintf(fp, "\tlist_for_each_entry(trace, &ltt_traces.head, list) {\n");
 531     fprintf(fp, "\t\tif(!trace->active) continue;\n\n");
 532
 533      //length of buffer : length of all structures
 534  //   if(ev->type == 0) fprintf(fp, "0");
 535
 536     fprintf(fp, "\t\tchannel = ltt_get_channel_from_index(trace, index);\n");
 537                 fprintf(fp, "\t\tbuf = channel->rchan->buf[smp_processor_id()];\n");
 538                 fprintf(fp, "\n");
 539                 /* Warning : not atomic reservation : event size depends on the current
 540                  * address for alignment */
 541                 /* NOTE : using cmpxchg in reserve with repeat for atomicity */
 542     // Replaces _offset
 543                 fprintf(fp, "\t\tdo {\n");
 544                 fprintf(fp, "\t\t\told_address = buf->data + buf->offset;\n");
 545     fprintf(fp, "\t\t\tchar *ptr = (char*)old_address;\n");
 546
 547
 548     fprintf(fp, "\t\t\theader_length = ltt_get_event_header_data(trace, "
 549                                                                                                                                                                                                                                                                 "channel,\n"
 550                                                                 "\t\t\t\t\t\t\t\t\t\told_address, &_offset, &delta, &tsc);\n");
 551
 552     fprintf(fp, "\t\t\tptr += _offset + header_length;\n");
 553
 554     for(pos1=0;pos1<structCount;pos1++){
 555
 556       if(ev->type->alignment > 1) {
 557         fprintf(fp,"\t\t\tptr += (%u - ((unsigned int)ptr&(%u-1)))&(%u-1) ;\n",
 558             ev->type->alignment, ev->type->alignment, ev->type->alignment);
 559       }
 560       fprintf(fp,"\t\t\tptr += sizeof(struct %s_%s_%d);\n",ev->name,
 561           facName,pos1+1);
 562 //      if(pos1 != structCount-1) fprintf(fp," + ");
 563     }
 564
 565     //length of buffer : length of all arrays, sequences and strings
 566     seqCount = 0;
 567     strCount = 0;
 568     flag = 0;
 569                 if(ev->type != 0)
 570                         for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
 571                                 fld  = (field *)ev->type->fields.array[pos1];
 572                                 td = fld->type;
 573                                 if(td->type == SEQUENCE || td->type==STRING || td->type==ARRAY){
 574                                         if(td->type == SEQUENCE) {
 575             if(td->alignment > 1) {
 576               fprintf(fp,"\t\t\tptr += (%u - ((unsigned int)ptr&(%u-1)))&(%u-1)) ;\n",
 577                       td->alignment, td->alignment, td->alignment);
 578             }
 579                                                 fprintf(fp,
 580                 "\t\t\tptr += sizeof(%s) + (sizeof(%s) * seqlength_%d);\n",
 581                                                                 uintOutputTypes[td->size], getTypeStr(td), ++seqCount);
 582           } else if(td->type==STRING) {
 583             if(td->alignment > 1) {
 584               fprintf(fp,"\t\t\tptr += (%u - ((unsigned int)ptr&(%u-1)))&(%u-1)) ;\n",
 585                  td->alignment, td->alignment, td->alignment);
 586             }
 587             fprintf(fp,"ptr += strlength_%d + 1;\n",
 588                                                 ++strCount);
 589           }
 590                                         else if(td->type==ARRAY) {
 591             if(td->alignment > 1) {
 592               fprintf(fp,"\t\t\tptr += (%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
 593                  td->alignment, td->alignment, td->alignment);
 594             }
 595                                                 fprintf(fp,"\t\t\tptr += sizeof(%s) * %d;\n",
 596                 getTypeStr(td),td->size);
 597                                         if(structCount == 0) flag = 1;
 598           }
 599                                 }
 600                         }
 601     fprintf(fp,";\n");
 602
 603     fprintf(fp, "\t\t\tevent_length = (unsigned long)ptr -"
 604                                 "(unsigned long)old_address;\n");
 605
 606                 fprintf(fp, "\t\t\tbuff = relay_reserve(channel->rchan, event_length, "
 607                                                                                                 "old_address);\n");
 608                 fprintf(fp, "\n");
 609                 fprintf(fp, "\t\t} while(PTR_ERR(buff) == -EAGAIN);\n");
 610                 fprintf(fp, "\n");
 611
 612
 613     /* Reserve the channel */
 614     //fprintf(fp, "\t\tbuff = relay_reserve(channel->rchan, event_length);\n");
 615     fprintf(fp, "\t\tif(buff == NULL) {\n");
 616     fprintf(fp, "\t\t\t/* Buffer is full*/\n");
 617     fprintf(fp, "\t\t\t/* for debug BUG(); */\n"); // DEBUG!
 618     fprintf(fp, "\t\t\tchannel->events_lost[smp_processor_id()]++;\n");
 619     fprintf(fp, "\t\t\tbreak;\n");       /* don't commit a NULL reservation! */
 620     fprintf(fp, "\t\t}\n");
 621
 622                 /* DEBUG */
 623     //fprintf(fp, "\t\tif(resret == 1) {\n");
 624                 //fprintf(fp, "printk(\"f%%lu e\%%u \", ltt_facility_%s_%X, event_%s);",
 625                 //              facName, checksum, ev->name);
 626     //fprintf(fp, "\t\t}\n");
 627
 628     /* Write the header */
 629     fprintf(fp, "\n");
 630                 fprintf(fp,"\t\tlength = event_length - header_length;\n");
 631     fprintf(fp, "\n");
 632     fprintf(fp, "\t\tltt_write_event_header(trace, channel, buff, \n"
 633                 "\t\t\t\tltt_facility_%s_%X, event_%s, length, _offset,\n"
 634                                                                 "\t\t\t\t&delta, &tsc);\n",
 635                 facName, checksum, ev->name);
 636     fprintf(fp, "\n");
 637
 638     if(ev->type != 0)
 639       fprintf(fp, "\t\tchar *ptr = (char*)buff + _offset + header_length;\n");
 640
 641
 642     //declare a char pointer if needed : starts at the end of the structs.
 643     //if(structCount + hasStrSeq > 1) {
 644     //  fprintf(fp,"\t\tchar * ptr = (char*)buff + header_length");
 645     //  for(pos1=0;pos1<structCount;pos1++){
 646     //    fprintf(fp," + sizeof(struct %s_%s_%d)",ev->name, facName,pos1+1);
 647     //  }
 648     //  if(structCount + hasStrSeq > 1) fprintf(fp,";\n");
 649     //}
 650
 651     // Declare an alias pointer of the struct type to the beginning
 652     // of the reserved area, just after the event header.
 653     if(ev->type != 0) {
 654       if(ev->type->alignment > 1) {
 655         fprintf(fp,"\t\tptr+=(%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
 656               ev->type->alignment, ev->type->alignment, ev->type->alignment);
 657       }
 658
 659       fprintf(fp, "\t\t__1 = (struct %s_%s_1 *)(ptr);\n",
 660           ev->name, facName);
 661     }
 662     //allocate memory for new struct and initialize it
 663     //if(whichTypeFirst == 1){ //struct first
 664       //for(pos1=0;pos1<structCount;pos1++){
 665       //  if(pos1==0) fprintf(fp,
 666       //      "\tstruct %s_%s_1 * __1 = (struct %s_%s_1 *)buff;\n",
 667       //      ev->name, facName,ev->name, facName);
 668   //MD disabled      else fprintf(fp,
 669   //          "\tstruct %s_%s_%d  __%d;\n",
 670   //          ev->name, facName,pos1+1,pos1+1);
 671       //}
 672     //}else if(whichTypeFirst == 2){
 673      // for(pos1=0;pos1<structCount;pos1++)
 674      //   fprintf(fp,"\tstruct %s_%s_%d  __%d;\n",
 675      //       ev->name, facName,pos1+1,pos1+1);
 676     //}
 677     fprintf(fp,"\n");
 678
 679     if(structCount) fprintf(fp,"\t\t//initialize structs\n");
 680     //flag = 0;
 681     //structCount = 0;
 682                 if(ev->type != 0)
 683                         for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
 684                                 fld  = (field *)ev->type->fields.array[pos1];
 685                                 td = fld->type;
 686                                 if(td->type != ARRAY && td->type != SEQUENCE && td->type != STRING){
 687                                         //if(flag == 0){
 688                                         //  flag = 1;
 689                                         //  structCount++;
 690                                         //  if(structCount > 1) fprintf(fp,"\n");
 691                                         //}
 692                                         fprintf(fp, "\t\t__1->%s = %s;\n", fld->name, fld->name );
 693
 694                                 //if(structCount == 1 && whichTypeFirst == 1)
 695                                 //  fprintf(fp, "\t__1->%s =  %s;\n",fld->name,fld->name );
 696                                 //else
 697                                 //  fprintf(fp, "\t__%d.%s =  %s;\n",structCount ,fld->name,fld->name);
 698                                 }
 699                                 //else flag = 0;
 700                         }
 701     if(structCount) fprintf(fp,"\n");
 702     //set ptr to the end of first struct if needed;
 703     //if(structCount + hasStrSeq > 1){
 704     //  fprintf(fp,"\n\t\t//set ptr to the end of the first struct\n");
 705     //  fprintf(fp,"\t\tptr +=  sizeof(struct %s_%s_1);\n\n",ev->name, facName);
 706     //}
 707
 708     //copy struct, sequence and string to buffer
 709     seqCount = 0;
 710     strCount = 0;
 711     flag = 0;
 712     structCount = 0;
 713                 if(ev->type != 0)
 714                         for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
 715                                 fld  = (field *)ev->type->fields.array[pos1];
 716                                 td = fld->type;
 717         //      if(td->type != STRING && td->type != SEQUENCE && td->type != ARRAY){
 718         //        if(flag == 0) structCount++;
 719         //        flag++;
 720         //        if((structCount > 1 || whichTypeFirst == 2) && flag == 1){
 721         //          assert(0); // MD : disabled !
 722         //          fprintf(fp,"\t//copy struct to buffer\n");
 723         //          fprintf(fp,"\tmemcpy(ptr, &__%d, sizeof(struct %s_%s_%d));\n",
 724         //              structCount, ev->name, facName,structCount);
 725         //          fprintf(fp,"\tptr +=  sizeof(struct %s_%s_%d);\n\n",
 726         //              ev->name, facName,structCount);
 727         //        }
 728          //     }
 729                                 //else if(td->type == SEQUENCE){
 730                                 if(td->type == SEQUENCE){
 731                                         flag = 0;
 732                                         fprintf(fp,"\t\t//copy sequence length and sequence to buffer\n");
 733
 734           if(td->alignment > 1) {
 735             fprintf(fp,"\t\tptr+=(%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
 736                     td->alignment, td->alignment, td->alignment);
 737           }
 738                                         fprintf(fp,"\t\t*ptr = seqlength_%d;\n",++seqCount);
 739                                         fprintf(fp,"\t\tptr += sizeof(%s);\n",uintOutputTypes[td->size]);
 740           if(td->alignment > 1) {
 741             fprintf(fp,"\t\tptr+=(%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
 742                     td->alignment, td->alignment, td->alignment);
 743           }
 744                                         fprintf(fp,"\t\tmemcpy(ptr, %s, sizeof(%s) * seqlength_%d);\n",
 745                                                 fld->name, getTypeStr(td), seqCount);
 746                                         fprintf(fp,"\t\tptr += sizeof(%s) * seqlength_%d;\n\n",
 747                                                 getTypeStr(td), seqCount);
 748                                 }
 749                                 else if(td->type==STRING){
 750                                         flag = 0;
 751                                         fprintf(fp,"\t\t//copy string to buffer\n");
 752                                         fprintf(fp,"\t\tif(strlength_%d > 0){\n",++strCount);
 753           if(td->alignment > 1) {
 754             fprintf(fp,"\t\tptr+=(%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
 755                     td->alignment, td->alignment, td->alignment);
 756           }
 757                                         fprintf(fp,"\t\t\tmemcpy(ptr, %s, strlength_%d + 1);\n",
 758                                                         fld->name, strCount);
 759                                         fprintf(fp,"\t\t\tptr += strlength_%d + 1;\n",strCount);
 760                                         fprintf(fp,"\t\t}else{\n");
 761                                         fprintf(fp,"\t\t\t*ptr = '\\0';\n");
 762                                         fprintf(fp,"\t\t\tptr += 1;\n");
 763                                         fprintf(fp,"\t\t}\n\n");
 764                                 }else if(td->type==ARRAY){
 765                                         flag = 0;
 766                                         fprintf(fp,"\t//copy array to buffer\n");
 767           if(td->alignment > 1) {
 768             fprintf(fp,"\t\tptr+=(%u - ((unsigned int)ptr&(%u-1)))&(%u-1);\n",
 769                     td->alignment, td->alignment, td->alignment);
 770           }
 771                                         fprintf(fp,"\tmemcpy(ptr, %s, sizeof(%s) * %d);\n",
 772                                                         fld->name, getTypeStr(td), td->size);
 773                                         fprintf(fp,"\tptr += sizeof(%s) * %d;\n\n", getTypeStr(td), td->size);
 774                                 }
 775                         }
 776     if(structCount + seqCount > 1) fprintf(fp,"\n");
 777
 778     fprintf(fp,"\n");
 779     fprintf(fp, "\t\t/* Commit the work */\n");
 780     fprintf(fp, "\t\trelay_commit(channel->rchan->buf[smp_processor_id()],\n"
 781         "\t\t\t\tbuff, event_length);\n");
 782     fprintf(fp, "\t\tltt_write_commit_counter("
 783                                 "channel->rchan->buf[smp_processor_id()],\n"
 784         "\t\t\t\tbuff);\n");
 785
 786    /* End of traces iteration */
 787     fprintf(fp, "\t}\n\n");
 788
 789     fprintf(fp, "\n");
 790                 // The generated preempt_check_resched is not dangerous because
 791                 // interrupts are disabled.
 792     fprintf(fp, "\tspin_unlock(&ltt_traces.locks[smp_processor_id()]);\n");
 793
 794     fprintf(fp, "unlock:\n");
 795                 fprintf(fp, "\tbarrier();\n");
 796                 fprintf(fp, "\tltt_nesting[smp_processor_id()]--;\n");
 797     fprintf(fp, "\t/* Re-enable interrupts */\n");
 798     fprintf(fp, "\tlocal_irq_restore(_flags);\n");
 799     fprintf(fp, "\tpreempt_enable_no_resched();\n");
 800     //fprintf(fp, "\tpreempt_check_resched();\n");
 801
 802     //call trace function
 803     //fprintf(fp,"\n\t//call trace function\n");
 804     //fprintf(fp,"\tltt_log_event(ltt_facility_%s_%X, %s, bufLength, buff);\n",facName,checksum,ev->name);
 805     fprintf(fp,"}\n");
 806                 fprintf(fp, "#endif //CONFIG_LTT\n\n");
 807   }
 808
 809 }
 810
 811 /*****************************************************************************
 812  *Function name
 813  *    getTypeStr        : generate type string
 814  *Input Params
 815  *    td                : a type descriptor
 816  *Return Values
 817  *    char *            : type string
 818  ****************************************************************************/
 819 char * getTypeStr(type_descriptor * td){
 820   type_descriptor * t ;
 821
 822   switch(td->type){
 823     case INT:
 824       return intOutputTypes[td->size];
 825     case UINT:
 826       return uintOutputTypes[td->size];
 827     case POINTER:
 828       return "void *";
 829     case LONG:
 830       return "long";
 831     case ULONG:
 832       return "unsigned long";
 833     case SIZE_T:
 834       return "size_t";
 835     case SSIZE_T:
 836       return "ssize_t";
 837     case OFF_T:
 838       return "off_t";
 839     case FLOAT:
 840       return floatOutputTypes[td->size];
 841     case STRING:
 842       return "const char";
 843     case ENUM:
 844       return uintOutputTypes[td->size];
 845     case ARRAY:
 846     case SEQUENCE:
 847       t = td->nested_type;
 848       switch(t->type){
 849         case INT:
 850           return intOutputTypes[t->size];
 851         case UINT:
 852           return uintOutputTypes[t->size];
 853         case POINTER:
 854           return "void *";
 855         case LONG:
 856           return "long";
 857         case ULONG:
 858           return "unsigned long";
 859         case SIZE_T:
 860           return "size_t";
 861         case SSIZE_T:
 862           return "ssize_t";
 863         case OFF_T:
 864           return "off_t";
 865         case FLOAT:
 866           return floatOutputTypes[t->size];
 867         case STRING:
 868           return "const char";
 869         case ENUM:
 870           return uintOutputTypes[t->size];
 871         default :
 872           error_callback(NULL,"Nested struct is not supportted");
 873           break;
 874       }
 875       break;
 876     case STRUCT: //for now we do not support nested struct
 877       error_callback(NULL,"Nested struct is not supportted");
 878       break;
 879     default:
 880       error_callback(NULL,"No type information");
 881       break;
 882   }
 883   return NULL;
 884 }
 885
 886 /*****************************************************************************
 887  *Function name
 888  *    generateLoaderfile: generate a facility loaded .h file
 889  *Input Params
 890  *    fp                : file to be written to
 891  *    facName           : name of facility
 892  *    nbEvent           : number of events in the facility
 893  *    checksum          : checksum for the facility
 894  ****************************************************************************/
 895 void generateLoaderfile(FILE * fp, char * facName, int nbEvent, unsigned long checksum, char *capname){
 896   fprintf(fp, "#ifndef _LTT_FACILITY_LOADER_%s_H_\n",capname);
 897   fprintf(fp, "#define _LTT_FACILITY_LOADER_%s_H_\n\n",capname);
 898   fprintf(fp,"#include <linux/ltt-facilities.h>\n", facName, checksum);
 899   fprintf(fp,"ltt_facility_t\tltt_facility_%s;\n", facName, checksum);
 900   fprintf(fp,"ltt_facility_t\tltt_facility_%s_%X;\n\n", facName, checksum);
 901
 902   fprintf(fp,"#define LTT_FACILITY_SYMBOL\t\t\t\t\t\t\tltt_facility_%s\n",
 903       facName);
 904   fprintf(fp,"#define LTT_FACILITY_CHECKSUM_SYMBOL\t\tltt_facility_%s_%X\n",
 905       facName, checksum);
 906   fprintf(fp,"#define LTT_FACILITY_CHECKSUM\t\t\t\t\t\t0x%X\n", checksum);
 907   fprintf(fp,"#define LTT_FACILITY_NAME\t\t\t\t\t\t\t\t\"%s\"\n", facName);
 908   fprintf(fp,"#define LTT_FACILITY_NUM_EVENTS\t\t\t\t\t%d\n\n", nbEvent);
 909   fprintf(fp, "#endif //_LTT_FACILITY_LOADER_%s_H_\n",capname);
 910 }
 911
 912 void generateCfile(FILE * fp, char * filefacname){
 913
 914   fprintf(fp, "/*\n");
 915   fprintf(fp, " * ltt-facility-loader-%s.c\n", filefacname);
 916   fprintf(fp, " *\n");
 917   fprintf(fp, " * (C) Copyright  2005 - \n");
 918   fprintf(fp, " *          Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)\n");
 919   fprintf(fp, " *\n");
 920   fprintf(fp, " * Contains the LTT facility loader.\n");
 921   fprintf(fp, " *\n");
 922   fprintf(fp, " */\n");
 923   fprintf(fp, "\n");
 924   fprintf(fp, "\n");
 925   fprintf(fp, "#include <linux/ltt-facilities.h>\n");
 926   fprintf(fp, "#include <linux/module.h>\n");
 927   fprintf(fp, "#include <linux/init.h>\n");
 928   fprintf(fp, "#include <linux/config.h>\n");
 929   fprintf(fp, "#include \"ltt-facility-loader-%s.h\"\n", filefacname);
 930   fprintf(fp, "\n");
 931   fprintf(fp, "\n");
 932   fprintf(fp, "#ifdef CONFIG_LTT\n");
 933   fprintf(fp, "\n");
 934   fprintf(fp, "EXPORT_SYMBOL(LTT_FACILITY_SYMBOL);\n");
 935   fprintf(fp, "EXPORT_SYMBOL(LTT_FACILITY_CHECKSUM_SYMBOL);\n");
 936   fprintf(fp, "\n");
 937   fprintf(fp, "static const char ltt_facility_name[] = LTT_FACILITY_NAME;\n");
 938   fprintf(fp, "\n");
 939   fprintf(fp, "#define SYMBOL_STRING(sym) #sym\n");
 940   fprintf(fp, "\n");
 941   fprintf(fp, "static struct ltt_facility facility = {\n");
 942   fprintf(fp, "\t.name = ltt_facility_name,\n");
 943   fprintf(fp, "\t.num_events = LTT_FACILITY_NUM_EVENTS,\n");
 944   fprintf(fp, "\t.checksum = LTT_FACILITY_CHECKSUM,\n");
 945   fprintf(fp, "\t.symbol = SYMBOL_STRING(LTT_FACILITY_SYMBOL)\n");
 946   fprintf(fp, "};\n");
 947   fprintf(fp, "\n");
 948   fprintf(fp, "#ifndef MODULE\n");
 949   fprintf(fp, "\n");
 950   fprintf(fp, "/* Built-in facility. */\n");
 951   fprintf(fp, "\n");
 952   fprintf(fp, "static int __init facility_init(void)\n");
 953   fprintf(fp, "{\n");
 954   fprintf(fp, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init in kernel\\n\");\n", filefacname);
 955   fprintf(fp, "\n");
 956   fprintf(fp, "\tLTT_FACILITY_SYMBOL = ltt_facility_builtin_register(&facility);\n");
 957   fprintf(fp, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
 958   fprintf(fp, "\t\n");
 959   fprintf(fp, "\treturn LTT_FACILITY_SYMBOL;\n");
 960   fprintf(fp, "}\n");
 961   fprintf(fp, "__initcall(facility_init);\n");
 962   fprintf(fp, "\n");
 963   fprintf(fp, "\n");
 964   fprintf(fp, "\n");
 965   fprintf(fp, "#else \n");
 966   fprintf(fp, "\n");
 967   fprintf(fp, "/* Dynamic facility. */\n");
 968   fprintf(fp, "\n");
 969   fprintf(fp, "static int __init facility_init(void)\n");
 970   fprintf(fp, "{\n");
 971   fprintf(fp, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init dynamic\\n\");\n", filefacname);
 972   fprintf(fp, "\n");
 973   fprintf(fp, "\tLTT_FACILITY_SYMBOL = ltt_facility_dynamic_register(&facility);\n");
 974   fprintf(fp, "\tLTT_FACILITY_SYMBOL_CHECKSUM = LTT_FACILITY_SYMBOL;\n");
 975   fprintf(fp, "\n");
 976   fprintf(fp, "\treturn LTT_FACILITY_SYMBOL;\n");
 977   fprintf(fp, "}\n");
 978   fprintf(fp, "\n");
 979   fprintf(fp, "static void __exit facility_exit(void)\n");
 980   fprintf(fp, "{\n");
 981   fprintf(fp, "\tint err;\n");
 982   fprintf(fp, "\n");
 983   fprintf(fp, "\terr = ltt_facility_dynamic_unregister(LTT_FACILITY_SYMBOL);\n");
 984   fprintf(fp, "\tif(err != 0)\n");
 985   fprintf(fp, "\t\tprintk(KERN_ERR \"LTT : Error in unregistering facility.\\n\");\n");
 986   fprintf(fp, "\n");
 987   fprintf(fp, "}\n");
 988   fprintf(fp, "\n");
 989   fprintf(fp, "module_init(facility_init)\n");
 990   fprintf(fp, "module_exit(facility_exit)\n");
 991   fprintf(fp, "\n");
 992   fprintf(fp, "\n");
 993   fprintf(fp, "MODULE_LICENSE(\"GPL\");\n");
 994   fprintf(fp, "MODULE_AUTHOR(\"Mathieu Desnoyers\");\n");
 995   fprintf(fp, "MODULE_DESCRIPTION(\"Linux Trace Toolkit Facility\");\n");
 996   fprintf(fp, "\n");
 997   fprintf(fp, "#endif //MODULE\n");
 998   fprintf(fp, "\n");
 999   fprintf(fp, "#endif //CONFIG_LTT\n");
1000 }
1001
1002