3 genevent.c: Generate helper declarations and functions to trace events
4 from an event description file.
6 Copyright (C) 2002, Xianxiu Yang
7 Copyright (C) 2002, Michel Dagenais
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.
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.
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
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.
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
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. */
42 #include <linux/errno.h>
48 /* Named types may be referenced from anywhere */
52 int main(int argc
, char** argv
)
56 char buffer
[BUFFER_SIZE
];
60 printf("At least one event definition file is needed\n");
65 in
.error
= error_callback
;
67 for(i
= 1 ; i
< argc
; i
++) {
69 in
.name
= allocAndCopy(argv
[i
]);
71 in
.fp
= fopen(in
.name
, "r");
73 in
.error(&in
,"cannot open facility input file");
77 token
= getToken(&in
);
78 if(in
.type
== ENDFILE
) break;
80 if(strcmp(token
, "<")) in
.error(&in
,"not a facility file");
83 if(strcmp("facility",token
) == 0) {
84 fac
= memAlloc(sizeof(facility
));
86 fac
->description
= NULL
;
87 sequence_init(&(fac
->events
));
88 table_init(&(fac
->named_types
));
89 sequence_init(&(fac
->unnamed_types
));
91 parseFacility(&in
, fac
);
93 //check if any namedType is not defined
94 checkNamedTypesImplemented(&fac
->named_types
);
96 else in
.error(&in
,"facility token was expected");
98 generateFile(argv
[i
]);
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
);
119 /*****************************************************************************
121 * generateFile : generate .c and .h file
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
;
129 unsigned long checksum
=0;
131 //remove .xml if it exists
132 tmp
= &name
[strlen(name
)-4];
133 if(strcmp(tmp
, ".xml") == 0){
137 tmp
= strrchr(name
,'/');
144 loadName
= appendString("ltt-facility-loader-", tmp
);
145 tmp2
= appendString(loadName
,".h");
148 hName
= appendString("ltt-facility-", tmp
);
149 tmp2
= appendString(hName
,".h");
152 hIdName
= appendString("ltt-facility-id-", tmp
);
153 tmp2
= appendString(hIdName
,".h");
156 cName
= appendString("ltt-facility-loader-", tmp
);
157 tmp2
= appendString(cName
,".c");
160 lFp
= fopen(loadName
,"w");
162 printf("Cannot open the file : %s\n",loadName
);
166 hFp
= fopen(hName
,"w");
168 printf("Cannot open the file : %s\n",hName
);
172 iFp
= fopen(hIdName
,"w");
174 printf("Cannot open the file : %s\n",hIdName
);
178 cFp
= fopen(cName
,"w");
180 printf("Cannot open the file : %s\n",cName
);
189 generateChecksum(fac
->name
, &checksum
, &(fac
->events
));
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 generateEnumEvent(iFp
, fac
->name
, &nbEvent
, checksum
);
195 fprintf(iFp
, "#endif //_LTT_FACILITY_ID_%s_H_\n",fac
->capname
);
198 fprintf(hFp
, "#ifndef _LTT_FACILITY_%s_H_\n",fac
->capname
);
199 fprintf(hFp
, "#define _LTT_FACILITY_%s_H_\n\n",fac
->capname
);
200 generateTypeDefs(hFp
, fac
->name
);
201 generateStructFunc(hFp
, fac
->name
,checksum
);
202 fprintf(hFp
, "#endif //_LTT_FACILITY_%s_H_\n",fac
->capname
);
204 /* generate .h file, calls to register the facility at init time */
205 generateLoaderfile(lFp
,fac
->name
,nbEvent
,checksum
,fac
->capname
);
207 // create ltt-facility-loader-facname.c
208 generateCfile(cFp
, tmp
);
218 /*****************************************************************************
220 * generateEnumEvent : output event enum to .h file
222 * fp : file to be written to
223 * facName : name of facility
225 * nbEvent : number of events in the facility
226 ****************************************************************************/
227 void generateEnumEvent(FILE *fp
, char *facName
, int * nbEvent
, unsigned long checksum
) {
230 fprintf(fp
,"#include <linux/ltt-facilities.h>\n\n");
232 fprintf(fp
,"/**** facility handle ****/\n\n");
233 fprintf(fp
,"extern ltt_facility_t ltt_facility_%s_%X;\n",facName
, checksum
);
234 fprintf(fp
,"extern ltt_facility_t ltt_facility_%s;\n\n\n",facName
, checksum
);
236 fprintf(fp
,"/**** event type ****/\n\n");
237 fprintf(fp
,"enum %s_event {\n",facName
);
239 for(pos
= 0; pos
< fac
->events
.position
;pos
++) {
240 fprintf(fp
,"\tevent_%s", ((event
*)(fac
->events
.array
[pos
]))->name
);
241 if(pos
!= fac
->events
.position
-1) fprintf(fp
,",\n");
243 fprintf(fp
,"\n};\n\n\n");
245 // fprintf(fp,"/**** number of events in the facility ****/\n\n");
246 // fprintf(fp,"int nbEvents_%s = %d;\n\n\n",facName, fac->events.position);
247 *nbEvent
= fac
->events
.position
;
251 /*****************************************************************************
253 * printStruct : Generic struct printing function
255 * fp : file to be written to
256 * len : number of fields
257 * array : array of field info
258 * name : basic struct name
259 * facName : name of facility
260 * whichTypeFirst : struct or array/sequence first
261 * hasStrSeq : string or sequence present?
262 * structCount : struct postfix
263 ****************************************************************************/
266 printStruct(FILE * fp
, int len
, void ** array
, char * name
, char * facName
,
267 int * whichTypeFirst
, int * hasStrSeq
, int * structCount
)
272 type_descriptor
* td
;
274 for (pos
= 0; pos
< len
; pos
++) {
275 fld
= (field
*)array
[pos
];
277 if( td
->type
== STRING
|| td
->type
== SEQUENCE
||
281 // if (*whichTypeFirst == 0) {
282 // *whichTypeFirst = 1; //struct first
287 fprintf(fp
,"struct %s_%s",name
, facName
);
289 fprintf(fp
, "_%d {\n",++*structCount
);
294 fprintf(fp
, "\t%s %s; /* %s */\n",
295 getTypeStr(td
),fld
->name
,fld
->description
);
298 if (*whichTypeFirst
== 0) {
299 //string or sequence or array first
304 fprintf(fp
,"} __attribute__ ((packed));\n\n");
312 fprintf(fp
,"} __attribute__ ((packed));\n\n");
317 /*****************************************************************************
319 * generateHfile : Create the typedefs
321 * fp : file to be written to
322 ****************************************************************************/
324 generateTypeDefs(FILE * fp
, char *facName
)
328 fprintf(fp
,"#include <linux/types.h>\n");
329 fprintf(fp
,"#include <linux/spinlock.h>\n");
330 fprintf(fp
,"#include <linux/ltt/ltt-facility-id-%s.h>\n\n", facName
);
331 fprintf(fp
,"#include <linux/ltt-core.h>\n");
333 fprintf(fp
, "/**** Basic Type Definitions ****/\n\n");
335 for (pos
= 0; pos
< fac
->named_types
.values
.position
; pos
++) {
336 type_descriptor
* type
=
337 (type_descriptor
*)fac
->named_types
.values
.array
[pos
];
338 printStruct(fp
, type
->fields
.position
, type
->fields
.array
,
339 "", type
->type_name
, &tmp
, &tmp
, NULL
);
340 fprintf(fp
, "typedef struct _%s %s;\n\n",
341 type
->type_name
, type
->type_name
);
346 /*****************************************************************************
348 * generateEnumDefinition: generate enum definition if it exists
350 * fp : file to be written to
352 ****************************************************************************/
353 void generateEnumDefinition(FILE * fp
, type_descriptor
* type
){
356 if(type
->already_printed
) return;
358 fprintf(fp
,"enum {\n");
359 for(pos
= 0; pos
< type
->labels
.position
; pos
++){
360 fprintf(fp
,"\tLTT_ENUM_%s", type
->labels
.array
[pos
]);
361 if (pos
!= type
->labels
.position
- 1) fprintf(fp
,",");
362 if(type
->labels_description
.array
[pos
] != NULL
)
363 fprintf(fp
,"\t/* %s */\n",type
->labels_description
.array
[pos
]);
367 fprintf(fp
,"};\n\n\n");
369 type
->already_printed
= 1;
372 /*****************************************************************************
374 * generateStrucTFunc: output structure and function to .h file
376 * fp : file to be written to
377 * facName : name of facility
378 ****************************************************************************/
379 void generateStructFunc(FILE * fp
, char * facName
, unsigned long checksum
){
382 type_descriptor
* td
;
384 int hasStrSeq
, flag
, structCount
, seqCount
,strCount
, whichTypeFirst
=0;
386 for(pos
= 0; pos
< fac
->events
.position
; pos
++){
387 ev
= (event
*) fac
->events
.array
[pos
];
388 //yxx if(ev->nested)continue;
389 fprintf(fp
,"/**** structure and trace function for event: %s ****/\n\n",
391 //if(ev->type == 0){ // event without type
392 // fprintf(fp,"static inline void trace_%s_%s(void){\n",facName,ev->name);
393 // fprintf(fp,"\tltt_log_event(ltt_facility_%s_%X, event_%s, 0, NULL);\n",
394 // facName,checksum,ev->name);
395 // fprintf(fp,"};\n\n\n");
399 //if fields contain enum, print out enum definition
400 //MD : fixed in generateEnumDefinition to do not print the same enum
403 for(pos1
= 0; pos1
< ev
->type
->fields
.position
; pos1
++){
404 fld
= (field
*)ev
->type
->fields
.array
[pos1
];
405 if(fld
->type
->type
== ENUM
) generateEnumDefinition(fp
, fld
->type
);
408 //default: no string, array or sequence in the event
413 //structure for kernel
415 printStruct(fp
, ev
->type
->fields
.position
, ev
->type
->fields
.array
,
416 ev
->name
, facName
, &whichTypeFirst
, &hasStrSeq
, &structCount
);
418 //trace function : function name and parameters
421 fprintf(fp
,"static inline void trace_%s_%s(",facName
,ev
->name
);
425 for(pos1
= 0; pos1
< ev
->type
->fields
.position
; pos1
++){
426 fld
= (field
*)ev
->type
->fields
.array
[pos1
];
428 if(td
->type
== ARRAY
){
429 fprintf(fp
,"%s * %s",getTypeStr(td
), fld
->name
);
430 }else if(td
->type
== STRING
){
431 fprintf(fp
,"short int strlength_%d, %s * %s",
432 ++strCount
, getTypeStr(td
), fld
->name
);
433 }else if(td
->type
== SEQUENCE
){
434 fprintf(fp
,"%s seqlength_%d, %s * %s",
435 uintOutputTypes
[td
->size
], ++seqCount
,getTypeStr(td
), fld
->name
);
436 }else fprintf(fp
,"%s %s",getTypeStr(td
), fld
->name
);
437 if(pos1
!= ev
->type
->fields
.position
- 1) fprintf(fp
,", ");
439 fprintf(fp
,")\n{\n");
441 //length of buffer : length of all structures
442 fprintf(fp
,"\tint length = ");
443 if(ev
->type
== 0) fprintf(fp
, "0");
445 for(pos1
=0;pos1
<structCount
;pos1
++){
446 fprintf(fp
,"sizeof(struct %s_%s_%d)",ev
->name
, facName
,pos1
+1);
447 if(pos1
!= structCount
-1) fprintf(fp
," + ");
450 //length of buffer : length of all arrays, sequences and strings
455 for(pos1
= 0; pos1
< ev
->type
->fields
.position
; pos1
++){
456 fld
= (field
*)ev
->type
->fields
.array
[pos1
];
458 if(td
->type
== SEQUENCE
|| td
->type
==STRING
|| td
->type
==ARRAY
){
459 if(structCount
|| flag
> 0) fprintf(fp
," + ");
460 if(td
->type
== SEQUENCE
)
461 fprintf(fp
,"sizeof(%s) + sizeof(%s) * seqlength_%d",
462 uintOutputTypes
[td
->size
], getTypeStr(td
), ++seqCount
);
463 else if(td
->type
==STRING
) fprintf(fp
,"strlength_%d + 1", ++strCount
);
464 else if(td
->type
==ARRAY
)
465 fprintf(fp
,"sizeof(%s) * %d", getTypeStr(td
),td
->size
);
466 if(structCount
== 0) flag
= 1;
472 // MD no more need. fprintf(fp,"\tchar buff[buflength];\n");
473 // write directly to the channel
474 fprintf(fp
, "\tunsigned int index;\n");
475 fprintf(fp
, "\tstruct ltt_channel_struct *channel;\n");
476 fprintf(fp
, "\tstruct ltt_trace_struct *trace;\n");
477 fprintf(fp
, "\tunsigned long _flags;\n");
479 fprintf(fp
, "\tstruct %s_%s_1* __1;\n\n", ev
->name
, facName
);
481 fprintf(fp
, "\tread_lock(<t_traces.traces_rwlock);\n\n");
483 "\tif(ltt_traces.num_active_traces == 0) goto unlock_traces;\n\n");
486 "\tindex = ltt_get_index_from_facility(ltt_facility_%s_%X,\n"\
487 "\t\t\t\tevent_%s);\n",
488 facName
, checksum
, ev
->name
);
491 fprintf(fp
, "\t/* Disable interrupts. */\n");
492 fprintf(fp
, "\tlocal_irq_save(_flags);\n\n");
495 fprintf(fp
, "\tlist_for_each_entry(trace, <t_traces.head, list) {\n");
496 fprintf(fp
, "\t\tif(!trace->active) continue;\n\n");
498 fprintf(fp
, "\t\tunsigned int header_length = "
499 "ltt_get_event_header_size(trace);\n");
500 fprintf(fp
, "\t\tunsigned int event_length = header_length + length;\n");
502 /* Reserve the channel */
503 fprintf(fp
, "\t\tchannel = ltt_get_channel_from_index(trace, index);\n");
505 "\t\tvoid *buff = relay_reserve(channel->rchan, event_length);\n");
506 fprintf(fp
, "\t\tif(buff == NULL) {\n");
507 fprintf(fp
, "\t\t\t/* Buffer is full*/\n");
508 fprintf(fp
, "\t\t\t/* for debug BUG(); */\n"); // DEBUG!
509 fprintf(fp
, "\t\t\tchannel->events_lost[smp_processor_id()]++;\n");
510 fprintf(fp
, "\t\t\tbreak;\n"); /* don't commit a NULL reservation! */
511 fprintf(fp
, "\t\t}\n");
514 fprintf(fp
, "/* for debug printk(\"f%%lu e\%%u \", ltt_facility_%s_%X, event_%s); */",
515 facName
, checksum
, ev
->name
);
517 /* Write the header */
519 fprintf(fp
, "\t\tltt_write_event_header(trace, channel, buff, \n"
520 "\t\t\t\tltt_facility_%s_%X, event_%s, length);\n",
521 facName
, checksum
, ev
->name
);
524 //declare a char pointer if needed : starts at the end of the structs.
525 if(structCount
+ hasStrSeq
> 1) {
526 fprintf(fp
,"\t\tchar * ptr = (char*)buff + header_length");
527 for(pos1
=0;pos1
<structCount
;pos1
++){
528 fprintf(fp
," + sizeof(struct %s_%s_%d)",ev
->name
, facName
,pos1
+1);
530 if(structCount
+ hasStrSeq
> 1) fprintf(fp
,";\n");
533 // Declare an alias pointer of the struct type to the beginning
534 // of the reserved area, just after the event header.
536 fprintf(fp
, "\t\t__1 = (struct %s_%s_1 *)(buff + header_length);\n",
538 //allocate memory for new struct and initialize it
539 //if(whichTypeFirst == 1){ //struct first
540 //for(pos1=0;pos1<structCount;pos1++){
541 // if(pos1==0) fprintf(fp,
542 // "\tstruct %s_%s_1 * __1 = (struct %s_%s_1 *)buff;\n",
543 // ev->name, facName,ev->name, facName);
544 //MD disabled else fprintf(fp,
545 // "\tstruct %s_%s_%d __%d;\n",
546 // ev->name, facName,pos1+1,pos1+1);
548 //}else if(whichTypeFirst == 2){
549 // for(pos1=0;pos1<structCount;pos1++)
550 // fprintf(fp,"\tstruct %s_%s_%d __%d;\n",
551 // ev->name, facName,pos1+1,pos1+1);
555 if(structCount
) fprintf(fp
,"\t\t//initialize structs\n");
559 for(pos1
= 0; pos1
< ev
->type
->fields
.position
; pos1
++){
560 fld
= (field
*)ev
->type
->fields
.array
[pos1
];
562 if(td
->type
!= ARRAY
&& td
->type
!= SEQUENCE
&& td
->type
!= STRING
){
566 // if(structCount > 1) fprintf(fp,"\n");
568 fprintf(fp
, "\t\t__1->%s = %s;\n", fld
->name
, fld
->name
);
570 //if(structCount == 1 && whichTypeFirst == 1)
571 // fprintf(fp, "\t__1->%s = %s;\n",fld->name,fld->name );
573 // fprintf(fp, "\t__%d.%s = %s;\n",structCount ,fld->name,fld->name);
577 if(structCount
) fprintf(fp
,"\n");
578 //set ptr to the end of first struct if needed;
579 if(structCount
+ hasStrSeq
> 1){
580 fprintf(fp
,"\n\t\t//set ptr to the end of the first struct\n");
581 fprintf(fp
,"\t\tptr += sizeof(struct %s_%s_1);\n\n",ev
->name
, facName
);
584 //copy struct, sequence and string to buffer
590 for(pos1
= 0; pos1
< ev
->type
->fields
.position
; pos1
++){
591 fld
= (field
*)ev
->type
->fields
.array
[pos1
];
593 // if(td->type != STRING && td->type != SEQUENCE && td->type != ARRAY){
594 // if(flag == 0) structCount++;
596 // if((structCount > 1 || whichTypeFirst == 2) && flag == 1){
597 // assert(0); // MD : disabled !
598 // fprintf(fp,"\t//copy struct to buffer\n");
599 // fprintf(fp,"\tmemcpy(ptr, &__%d, sizeof(struct %s_%s_%d));\n",
600 // structCount, ev->name, facName,structCount);
601 // fprintf(fp,"\tptr += sizeof(struct %s_%s_%d);\n\n",
602 // ev->name, facName,structCount);
605 //else if(td->type == SEQUENCE){
606 if(td
->type
== SEQUENCE
){
608 fprintf(fp
,"\t\t//copy sequence length and sequence to buffer\n");
609 fprintf(fp
,"\t\t*ptr = seqlength_%d;\n",++seqCount
);
610 fprintf(fp
,"\t\tptr += sizeof(%s);\n",uintOutputTypes
[td
->size
]);
611 fprintf(fp
,"\t\tmemcpy(ptr, %s, sizeof(%s) * seqlength_%d);\n",
612 fld
->name
, getTypeStr(td
), seqCount
);
613 fprintf(fp
,"\t\tptr += sizeof(%s) * seqlength_%d;\n\n",
614 getTypeStr(td
), seqCount
);
616 else if(td
->type
==STRING
){
618 fprintf(fp
,"\t\t//copy string to buffer\n");
619 fprintf(fp
,"\t\tif(strlength_%d > 0){\n",++strCount
);
620 fprintf(fp
,"\t\t\tmemcpy(ptr, %s, strlength_%d + 1);\n",
621 fld
->name
, strCount
);
622 fprintf(fp
,"\t\t\tptr += strlength_%d + 1;\n",strCount
);
623 fprintf(fp
,"\t\t}else{\n");
624 fprintf(fp
,"\t\t\t*ptr = '\\0';\n");
625 fprintf(fp
,"\t\t\tptr += 1;\n");
626 fprintf(fp
,"\t\t}\n\n");
627 }else if(td
->type
==ARRAY
){
629 fprintf(fp
,"\t//copy array to buffer\n");
630 fprintf(fp
,"\tmemcpy(ptr, %s, sizeof(%s) * %d);\n",
631 fld
->name
, getTypeStr(td
), td
->size
);
632 fprintf(fp
,"\tptr += sizeof(%s) * %d;\n\n", getTypeStr(td
), td
->size
);
635 if(structCount
+ seqCount
> 1) fprintf(fp
,"\n");
638 fprintf(fp
, "\t\t/* Commit the work */\n");
639 fprintf(fp
, "\t\trelay_commit(channel->rchan->buf[smp_processor_id()],\n"
640 "\t\t\t\tbuff, event_length);\n");
642 /* End of traces iteration */
643 fprintf(fp
, "\t}\n\n");
645 fprintf(fp
, "\t/* Re-enable interrupts */\n");
646 fprintf(fp
, "\tlocal_irq_restore(_flags);\n");
647 fprintf(fp
, "\tpreempt_check_resched();\n");
650 fprintf(fp
, "unlock_traces:\n");
651 fprintf(fp
, "\tread_unlock(<t_traces.traces_rwlock);\n");
652 //call trace function
653 //fprintf(fp,"\n\t//call trace function\n");
654 //fprintf(fp,"\tltt_log_event(ltt_facility_%s_%X, %s, bufLength, buff);\n",facName,checksum,ev->name);
655 fprintf(fp
,"}\n\n\n");
660 /*****************************************************************************
662 * getTypeStr : generate type string
664 * td : a type descriptor
666 * char * : type string
667 ****************************************************************************/
668 char * getTypeStr(type_descriptor
* td
){
669 type_descriptor
* t
;
673 return intOutputTypes
[td
->size
];
675 return uintOutputTypes
[td
->size
];
681 return "unsigned long";
689 return floatOutputTypes
[td
->size
];
693 return uintOutputTypes
[td
->size
];
699 return intOutputTypes
[t
->size
];
701 return uintOutputTypes
[t
->size
];
707 return "unsigned long";
715 return floatOutputTypes
[t
->size
];
719 return uintOutputTypes
[t
->size
];
721 error_callback(NULL
,"Nested struct is not supportted");
725 case STRUCT
: //for now we do not support nested struct
726 error_callback(NULL
,"Nested struct is not supportted");
729 error_callback(NULL
,"No type information");
735 /*****************************************************************************
737 * generateLoaderfile: generate a facility loaded .h file
739 * fp : file to be written to
740 * facName : name of facility
741 * nbEvent : number of events in the facility
742 * checksum : checksum for the facility
743 ****************************************************************************/
744 void generateLoaderfile(FILE * fp
, char * facName
, int nbEvent
, unsigned long checksum
, char *capname
){
745 fprintf(fp
, "#ifndef _LTT_FACILITY_LOADER_%s_H_\n",capname
);
746 fprintf(fp
, "#define _LTT_FACILITY_LOADER_%s_H_\n\n",capname
);
747 fprintf(fp
,"#include <linux/ltt-facilities.h>\n", facName
, checksum
);
748 fprintf(fp
,"ltt_facility_t\tltt_facility_%s;\n", facName
, checksum
);
749 fprintf(fp
,"ltt_facility_t\tltt_facility_%s_%X;\n\n", facName
, checksum
);
751 fprintf(fp
,"#define LTT_FACILITY_SYMBOL\t\t\t\t\t\t\tltt_facility_%s\n",
753 fprintf(fp
,"#define LTT_FACILITY_CHECKSUM_SYMBOL\t\tltt_facility_%s_%X\n",
755 fprintf(fp
,"#define LTT_FACILITY_CHECKSUM\t\t\t\t\t\t0x%X\n", checksum
);
756 fprintf(fp
,"#define LTT_FACILITY_NAME\t\t\t\t\t\t\t\t\"%s\"\n", facName
);
757 fprintf(fp
,"#define LTT_FACILITY_NUM_EVENTS\t\t\t\t\t%d\n\n", nbEvent
);
758 fprintf(fp
, "#endif //_LTT_FACILITY_LOADER_%s_H_\n",capname
);
761 void generateCfile(FILE * fp
, char * filefacname
){
764 fprintf(fp
, " * ltt-facility-loader-%s.c\n", filefacname
);
766 fprintf(fp
, " * (C) Copyright 2005 - \n");
767 fprintf(fp
, " * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)\n");
769 fprintf(fp
, " * Contains the LTT facility loader.\n");
771 fprintf(fp
, " */\n");
774 fprintf(fp
, "#include <linux/ltt-facilities.h>\n");
775 fprintf(fp
, "#include <linux/module.h>\n");
776 fprintf(fp
, "#include <linux/init.h>\n");
777 fprintf(fp
, "#include <linux/config.h>\n");
778 fprintf(fp
, "#include \"ltt-facility-loader-%s.h\"\n", filefacname
);
781 fprintf(fp
, "#ifdef CONFIG_LTT\n");
783 fprintf(fp
, "EXPORT_SYMBOL(LTT_FACILITY_SYMBOL);\n");
784 fprintf(fp
, "EXPORT_SYMBOL(LTT_FACILITY_CHECKSUM_SYMBOL);\n");
786 fprintf(fp
, "static const char ltt_facility_name[] = LTT_FACILITY_NAME;\n");
788 fprintf(fp
, "#define SYMBOL_STRING(sym) #sym\n");
790 fprintf(fp
, "static struct ltt_facility facility = {\n");
791 fprintf(fp
, "\t.name = ltt_facility_name,\n");
792 fprintf(fp
, "\t.num_events = LTT_FACILITY_NUM_EVENTS,\n");
793 fprintf(fp
, "\t.checksum = LTT_FACILITY_CHECKSUM,\n");
794 fprintf(fp
, "\t.symbol = SYMBOL_STRING(LTT_FACILITY_SYMBOL)\n");
797 fprintf(fp
, "#ifndef MODULE\n");
799 fprintf(fp
, "/* Built-in facility. */\n");
801 fprintf(fp
, "static int __init facility_init(void)\n");
803 fprintf(fp
, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init in kernel\\n\");\n", filefacname
);
805 fprintf(fp
, "\tLTT_FACILITY_SYMBOL = ltt_facility_builtin_register(&facility);\n");
806 fprintf(fp
, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
808 fprintf(fp
, "\treturn LTT_FACILITY_SYMBOL;\n");
810 fprintf(fp
, "__initcall(facility_init);\n");
814 fprintf(fp
, "#else \n");
816 fprintf(fp
, "/* Dynamic facility. */\n");
818 fprintf(fp
, "static int __init facility_init(void)\n");
820 fprintf(fp
, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init dynamic\\n\");\n", filefacname
);
822 fprintf(fp
, "\tLTT_FACILITY_SYMBOL = ltt_facility_dynamic_register(&facility);\n");
823 fprintf(fp
, "\tLTT_FACILITY_SYMBOL_CHECKSUM = LTT_FACILITY_SYMBOL;\n");
825 fprintf(fp
, "\treturn LTT_FACILITY_SYMBOL;\n");
828 fprintf(fp
, "static void __exit facility_exit(void)\n");
830 fprintf(fp
, "\tint err;\n");
832 fprintf(fp
, "\terr = ltt_facility_dynamic_unregister(LTT_FACILITY_SYMBOL);\n");
833 fprintf(fp
, "\tif(err != 0)\n");
834 fprintf(fp
, "\t\tprintk(KERN_ERR \"LTT : Error in unregistering facility.\\n\");\n");
838 fprintf(fp
, "module_init(facility_init)\n");
839 fprintf(fp
, "module_exit(facility_exit)\n");
842 fprintf(fp
, "MODULE_LICENSE(\"GPL\");\n");
843 fprintf(fp
, "MODULE_AUTHOR(\"Mathieu Desnoyers\");\n");
844 fprintf(fp
, "MODULE_DESCRIPTION(\"Linux Trace Toolkit Facility\");\n");
846 fprintf(fp
, "#endif //MODULE\n");
848 fprintf(fp
, "#endif //CONFIG_LTT\n");
This page took 0.053597 seconds and 5 git commands to generate.