X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=genevent%2Fgenevent.c;h=b809a8301197e63b03ecd03dc30a7ae6d8a07f16;hb=caabcb432b5b0a4a4955562cfc0bebb0d32ca5df;hp=3add689828d32a7599f64f645335348640fe0848;hpb=a8f6f123bde50bc59b1146ef99a287baa1cb1730;p=lttv.git

diff --git a/genevent/genevent.c b/genevent/genevent.c
index 3add6898..b809a830 100644
--- a/genevent/genevent.c
+++ b/genevent/genevent.c
@@ -45,19 +45,27 @@ This program is distributed in the hope that it will be useful,
 #include "parser.h"
 #include "genevent.h"
 
+#define max(a,b) ((a)<(b))?(b):(a)
+
 /* Named types may be referenced from anywhere */
 
-facility * fac;
+facility_t * fac;
+
+unsigned alignment = 0;
 
 int main(int argc, char** argv)
 {
   char *token;
-  parse_file in;
+  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);
   }
 
@@ -65,52 +73,61 @@ int main(int argc, char** argv)
   in.error = error_callback;
 
   for(i = 1 ; i < argc ; i++) {
-    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("-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]);
 
-      if(strcmp(token, "<")) in.error(&in,"not a facility file");
-      token = getName(&in);
-    
-      if(strcmp("facility",token) == 0) {
-        fac = memAlloc(sizeof(facility));
-        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);      
-    }
+			in.fp = fopen(in.name, "r");
+			if(!in.fp ){
+				in.error(&in,"cannot open facility input file");
+			}
 
-    free(in.name);
-    fclose(in.fp);
+			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;
 }
@@ -122,7 +139,8 @@ int main(int argc, char** argv)
  *Input Params
  *    name         : name of event definition file
  ****************************************************************************/
-void generateFile(char *name){
+void generateFile(char *name)
+{
   char *loadName, *hName, *hIdName, *cName, *tmp, *tmp2;
   FILE * lFp, *hFp, *iFp, *cFp;
   int nbEvent;
@@ -191,14 +209,18 @@ void generateFile(char *name){
   /* 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 */
@@ -224,7 +246,8 @@ void generateFile(char *name){
  *Output Params
  *    nbEvent           : number of events in the facility
  ****************************************************************************/
-void generateEnumEvent(FILE *fp, char *facName, int * nbEvent, unsigned long checksum) {
+void generateEnumEvent(FILE *fp, char *facName, int * nbEvent,
+                       unsigned long checksum) {
   int pos = 0;
 
   fprintf(fp,"#include <linux/ltt-facilities.h>\n\n");
@@ -237,7 +260,7 @@ void generateEnumEvent(FILE *fp, char *facName, int * nbEvent, unsigned long che
   fprintf(fp,"enum %s_event {\n",facName);
 
   for(pos = 0; pos < fac->events.position;pos++) {
-    fprintf(fp,"\tevent_%s", ((event *)(fac->events.array[pos]))->name);
+    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");
@@ -264,26 +287,23 @@ void generateEnumEvent(FILE *fp, char *facName, int * nbEvent, unsigned long che
 
 static void
 printStruct(FILE * fp, int len, void ** array, char * name, char * facName,
-       int * whichTypeFirst, int * hasStrSeq, int * structCount)
+       int * whichTypeFirst, int * hasStrSeq, int * structCount,
+       type_descriptor_t *type)
 {
   int flag = 0;
   int pos;
-  field * fld;
-  type_descriptor * td;
+  field_t * fld;
+  type_descriptor_t * td;
 
   for (pos = 0; pos < len; pos++) {
-    fld  = (field *)array[pos];
+    fld  = (field_t *)array[pos];
     td = fld->type;
     if( td->type == STRING || td->type == SEQUENCE ||
         td->type == ARRAY) {
         (*hasStrSeq)++;
-		}
-//      if (*whichTypeFirst == 0) {
-//        *whichTypeFirst = 1; //struct first
-//      }
+		} else {
       if (flag == 0) {
         flag = 1;
-
         fprintf(fp,"struct %s_%s",name, facName);
         if (structCount) {
           fprintf(fp, "_%d {\n",++*structCount);
@@ -293,23 +313,22 @@ printStruct(FILE * fp, int len, void ** array, char * name, char * facName,
       }
       fprintf(fp, "\t%s %s; /* %s */\n", 
           getTypeStr(td),fld->name,fld->description );
-#if 0
-    } else {
-        if (*whichTypeFirst == 0) {
-        //string or sequence or array first
-          *whichTypeFirst = 2;
-        }
-        (*hasStrSeq)++;
-        if(flag) {
-          fprintf(fp,"} __attribute__ ((packed));\n\n");
-        }
-        flag = 0;
     }
-#endif //0
   }
 
   if(flag) {
-    fprintf(fp,"} __attribute__ ((packed));\n\n");
+		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);
+    }
   }
 }
 
@@ -330,6 +349,7 @@ generateTypeDefs(FILE * fp, char *facName)
   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++) {
@@ -340,6 +360,7 @@ generateTypeDefs(FILE * fp, char *facName)
     fprintf(fp, "typedef struct _%s %s;\n\n",
             type->type_name, type->type_name);
   }
+#endif //0
 }
 
 
@@ -350,7 +371,7 @@ generateTypeDefs(FILE * fp, char *facName)
  *    fp                    : file to be written to
  *    fHead                 : enum type
  ****************************************************************************/
-void generateEnumDefinition(FILE * fp, type_descriptor * type){
+void generateEnumDefinition(FILE * fp, type_descriptor_t * type){
   int pos;
 
   if(type->already_printed) return;
@@ -377,14 +398,15 @@ void generateEnumDefinition(FILE * fp, type_descriptor * type){
  *    facName           : name of facility
  ****************************************************************************/
 void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
-  event * ev;
-  field * fld;
-  type_descriptor * td;
+  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 *) fac->events.array[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);
@@ -401,7 +423,7 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
     //twice.
     if(ev->type != 0)
       for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
-        fld = (field *)ev->type->fields.array[pos1];
+        fld = (field_t *)ev->type->fields.array[pos1];
         if(fld->type->type == ENUM) generateEnumDefinition(fp, fld->type);      
       }
       
@@ -413,38 +435,144 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
     //structure for kernel
     if(ev->type != 0)
       printStruct(fp, ev->type->fields.position, ev->type->fields.array,
-        ev->name, facName, &whichTypeFirst, &hasStrSeq, &structCount);
+        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);
-    if(ev->type == 0)
-      fprintf(fp, "void");
-    else
+
+    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 *)ev->type->fields.array[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);
-       }else if(td->type == SEQUENCE){
+          args_empty = 0;
+        }else if(td->type == SEQUENCE){
           fprintf(fp,"%s seqlength_%d, %s * %s",
               uintOutputTypes[td->size], ++seqCount,getTypeStr(td), fld->name);
-       }else fprintf(fp,"%s %s",getTypeStr(td), fld->name);     
-       if(pos1 != ev->type->fields.position - 1) fprintf(fp,", ");
+          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");
 
-    //length of buffer : length of all structures
-		fprintf(fp,"\tint length = ");
-    if(ev->type == 0) fprintf(fp, "0");
+		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++){
-      fprintf(fp,"sizeof(struct %s_%s_%d)",ev->name, facName,pos1+1);
-      if(pos1 != structCount-1) fprintf(fp," + ");
+			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
@@ -453,88 +581,146 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
     flag = 0;
 		if(ev->type != 0)
 			for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
-				fld  = (field *)ev->type->fields.array[pos1];
+				fld  = (field_t *)ev->type->fields.array[pos1];
 				td = fld->type;
 				if(td->type == SEQUENCE || td->type==STRING || td->type==ARRAY){
-					if(structCount || flag > 0) fprintf(fp," + ");    
-					if(td->type == SEQUENCE) 
-						fprintf(fp,"sizeof(%s) + sizeof(%s) * seqlength_%d",
-								uintOutputTypes[td->size], getTypeStr(td), ++seqCount);
-					else if(td->type==STRING) fprintf(fp,"strlength_%d + 1", ++strCount);
-					else if(td->type==ARRAY) 
-						fprintf(fp,"sizeof(%s) * %d", getTypeStr(td),td->size);
+					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;
+          }
 				}
 			}
-    fprintf(fp,";\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, "\tunsigned long _flags;\n");
-		if(ev->type != 0)
-      fprintf(fp, "\tstruct %s_%s_1* __1;\n\n", ev->name, facName);
-
-    fprintf(fp, "\tread_lock(&ltt_traces.traces_rwlock);\n\n");
-    fprintf(fp,
-        "\tif(ltt_traces.num_active_traces == 0) goto unlock_traces;\n\n");
-
-    fprintf(fp, 
+		
+		/* 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");
 
-    fprintf(fp, "\t/* Disable interrupts. */\n");
-    fprintf(fp, "\tlocal_irq_save(_flags);\n\n");
-
     /* For each trace */
-    fprintf(fp, "\tlist_for_each_entry(trace, &ltt_traces.head, list) {\n");
+    fprintf(fp, "\tlist_for_each_entry_rcu(trace, &ltt_traces.head, list) {\n");
     fprintf(fp, "\t\tif(!trace->active) continue;\n\n");
-    
-    fprintf(fp, "\t\tunsigned int header_length = "
-                "ltt_get_event_header_size(trace);\n");
-    fprintf(fp, "\t\tunsigned int event_length = header_length + length;\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");
    
-    /* Reserve the channel */
     fprintf(fp, "\t\tchannel = ltt_get_channel_from_index(trace, index);\n");
-    fprintf(fp,
-        "\t\tvoid *buff = 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\tgoto commit_work;\n");
-    fprintf(fp, "\t\t}\n");
-		
-		/* DEBUG */
-		fprintf(fp, "/* for debug printk(\"f%%lu e\%%u \", ltt_facility_%s_%X, event_%s); */",
-				facName, checksum, ev->name);
+		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, length);\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");
-    }
+    //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)
-      fprintf(fp, "\t\t__1 = (struct %s_%s_1 *)(buff + header_length);\n",
+    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++){  
@@ -557,7 +743,7 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
     //structCount = 0;
 		if(ev->type != 0)
 			for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
-				fld  = (field *)ev->type->fields.array[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){
@@ -575,20 +761,16 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
 				//else flag = 0;
 			}
     if(structCount) fprintf(fp,"\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);
-    }
 
-    //copy struct, sequence and string to buffer
+
+    //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 *)ev->type->fields.array[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++;  
@@ -606,17 +788,32 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
 				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",
+					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);
@@ -627,6 +824,11 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
 				}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);
@@ -634,27 +836,79 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
 			}
     if(structCount + seqCount > 1) fprintf(fp,"\n");
 
-    fprintf(fp,"\n");
-    fprintf(fp,"commit_work:\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, "\t/* Re-enable interrupts */\n");
-    fprintf(fp, "\tlocal_irq_restore(_flags);\n");
-    fprintf(fp, "\tpreempt_check_resched();\n");
-    
     fprintf(fp, "\n");
-    fprintf(fp, "unlock_traces:\n");
-    fprintf(fp, "\tread_unlock(&ltt_traces.traces_rwlock);\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\n\n");
+    fprintf(fp,"}\n");
+		fprintf(fp, "#endif //CONFIG_LTT\n\n");
   }
 
 }
@@ -667,8 +921,8 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
  *Return Values
  *    char *            : type string
  ****************************************************************************/
-char * getTypeStr(type_descriptor * td){
-  type_descriptor * t ;
+char * getTypeStr(type_descriptor_t * td){
+  type_descriptor_t * t ;
 
   switch(td->type){
     case INT:
@@ -793,7 +1047,8 @@ void generateCfile(FILE * fp, char * filefacname){
   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.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");
@@ -822,7 +1077,7 @@ void generateCfile(FILE * fp, char * filefacname){
   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_SYMBOL_CHECKSUM = LTT_FACILITY_SYMBOL;\n");
+  fprintf(fp, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
   fprintf(fp, "\n");
   fprintf(fp, "\treturn LTT_FACILITY_SYMBOL;\n");
   fprintf(fp, "}\n");