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