3add689828d32a7599f64f645335348640fe0848
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\tgoto commit_work;\n");
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
,"commit_work:\n");
640 fprintf(fp
, "\t\t/* Commit the work */\n");
641 fprintf(fp
, "\t\trelay_commit(channel->rchan->buf[smp_processor_id()],\n"
642 "\t\t\t\tbuff, event_length);\n");
644 /* End of traces iteration */
645 fprintf(fp
, "\t}\n\n");
647 fprintf(fp
, "\t/* Re-enable interrupts */\n");
648 fprintf(fp
, "\tlocal_irq_restore(_flags);\n");
649 fprintf(fp
, "\tpreempt_check_resched();\n");
652 fprintf(fp
, "unlock_traces:\n");
653 fprintf(fp
, "\tread_unlock(<t_traces.traces_rwlock);\n");
654 //call trace function
655 //fprintf(fp,"\n\t//call trace function\n");
656 //fprintf(fp,"\tltt_log_event(ltt_facility_%s_%X, %s, bufLength, buff);\n",facName,checksum,ev->name);
657 fprintf(fp
,"}\n\n\n");
662 /*****************************************************************************
664 * getTypeStr : generate type string
666 * td : a type descriptor
668 * char * : type string
669 ****************************************************************************/
670 char * getTypeStr(type_descriptor
* td
){
671 type_descriptor
* t
;
675 return intOutputTypes
[td
->size
];
677 return uintOutputTypes
[td
->size
];
683 return "unsigned long";
691 return floatOutputTypes
[td
->size
];
695 return uintOutputTypes
[td
->size
];
701 return intOutputTypes
[t
->size
];
703 return uintOutputTypes
[t
->size
];
709 return "unsigned long";
717 return floatOutputTypes
[t
->size
];
721 return uintOutputTypes
[t
->size
];
723 error_callback(NULL
,"Nested struct is not supportted");
727 case STRUCT
: //for now we do not support nested struct
728 error_callback(NULL
,"Nested struct is not supportted");
731 error_callback(NULL
,"No type information");
737 /*****************************************************************************
739 * generateLoaderfile: generate a facility loaded .h file
741 * fp : file to be written to
742 * facName : name of facility
743 * nbEvent : number of events in the facility
744 * checksum : checksum for the facility
745 ****************************************************************************/
746 void generateLoaderfile(FILE * fp
, char * facName
, int nbEvent
, unsigned long checksum
, char *capname
){
747 fprintf(fp
, "#ifndef _LTT_FACILITY_LOADER_%s_H_\n",capname
);
748 fprintf(fp
, "#define _LTT_FACILITY_LOADER_%s_H_\n\n",capname
);
749 fprintf(fp
,"#include <linux/ltt-facilities.h>\n", facName
, checksum
);
750 fprintf(fp
,"ltt_facility_t\tltt_facility_%s;\n", facName
, checksum
);
751 fprintf(fp
,"ltt_facility_t\tltt_facility_%s_%X;\n\n", facName
, checksum
);
753 fprintf(fp
,"#define LTT_FACILITY_SYMBOL\t\t\t\t\t\t\tltt_facility_%s\n",
755 fprintf(fp
,"#define LTT_FACILITY_CHECKSUM_SYMBOL\t\tltt_facility_%s_%X\n",
757 fprintf(fp
,"#define LTT_FACILITY_CHECKSUM\t\t\t\t\t\t0x%X\n", checksum
);
758 fprintf(fp
,"#define LTT_FACILITY_NAME\t\t\t\t\t\t\t\t\"%s\"\n", facName
);
759 fprintf(fp
,"#define LTT_FACILITY_NUM_EVENTS\t\t\t\t\t%d\n\n", nbEvent
);
760 fprintf(fp
, "#endif //_LTT_FACILITY_LOADER_%s_H_\n",capname
);
763 void generateCfile(FILE * fp
, char * filefacname
){
766 fprintf(fp
, " * ltt-facility-loader-%s.c\n", filefacname
);
768 fprintf(fp
, " * (C) Copyright 2005 - \n");
769 fprintf(fp
, " * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)\n");
771 fprintf(fp
, " * Contains the LTT facility loader.\n");
773 fprintf(fp
, " */\n");
776 fprintf(fp
, "#include <linux/ltt-facilities.h>\n");
777 fprintf(fp
, "#include <linux/module.h>\n");
778 fprintf(fp
, "#include <linux/init.h>\n");
779 fprintf(fp
, "#include <linux/config.h>\n");
780 fprintf(fp
, "#include \"ltt-facility-loader-%s.h\"\n", filefacname
);
783 fprintf(fp
, "#ifdef CONFIG_LTT\n");
785 fprintf(fp
, "EXPORT_SYMBOL(LTT_FACILITY_SYMBOL);\n");
786 fprintf(fp
, "EXPORT_SYMBOL(LTT_FACILITY_CHECKSUM_SYMBOL);\n");
788 fprintf(fp
, "static const char ltt_facility_name[] = LTT_FACILITY_NAME;\n");
790 fprintf(fp
, "#define SYMBOL_STRING(sym) #sym\n");
792 fprintf(fp
, "static struct ltt_facility facility = {\n");
793 fprintf(fp
, "\t.name = ltt_facility_name,\n");
794 fprintf(fp
, "\t.num_events = LTT_FACILITY_NUM_EVENTS,\n");
795 fprintf(fp
, "\t.checksum = LTT_FACILITY_CHECKSUM,\n");
796 fprintf(fp
, "\t.symbol = SYMBOL_STRING(LTT_FACILITY_SYMBOL)\n");
799 fprintf(fp
, "#ifndef MODULE\n");
801 fprintf(fp
, "/* Built-in facility. */\n");
803 fprintf(fp
, "static int __init facility_init(void)\n");
805 fprintf(fp
, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init in kernel\\n\");\n", filefacname
);
807 fprintf(fp
, "\tLTT_FACILITY_SYMBOL = ltt_facility_builtin_register(&facility);\n");
808 fprintf(fp
, "\tLTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;\n");
810 fprintf(fp
, "\treturn LTT_FACILITY_SYMBOL;\n");
812 fprintf(fp
, "__initcall(facility_init);\n");
816 fprintf(fp
, "#else \n");
818 fprintf(fp
, "/* Dynamic facility. */\n");
820 fprintf(fp
, "static int __init facility_init(void)\n");
822 fprintf(fp
, "\tprintk(KERN_INFO \"LTT : ltt-facility-%s init dynamic\\n\");\n", filefacname
);
824 fprintf(fp
, "\tLTT_FACILITY_SYMBOL = ltt_facility_dynamic_register(&facility);\n");
825 fprintf(fp
, "\tLTT_FACILITY_SYMBOL_CHECKSUM = LTT_FACILITY_SYMBOL;\n");
827 fprintf(fp
, "\treturn LTT_FACILITY_SYMBOL;\n");
830 fprintf(fp
, "static void __exit facility_exit(void)\n");
832 fprintf(fp
, "\tint err;\n");
834 fprintf(fp
, "\terr = ltt_facility_dynamic_unregister(LTT_FACILITY_SYMBOL);\n");
835 fprintf(fp
, "\tif(err != 0)\n");
836 fprintf(fp
, "\t\tprintk(KERN_ERR \"LTT : Error in unregistering facility.\\n\");\n");
840 fprintf(fp
, "module_init(facility_init)\n");
841 fprintf(fp
, "module_exit(facility_exit)\n");
844 fprintf(fp
, "MODULE_LICENSE(\"GPL\");\n");
845 fprintf(fp
, "MODULE_AUTHOR(\"Mathieu Desnoyers\");\n");
846 fprintf(fp
, "MODULE_DESCRIPTION(\"Linux Trace Toolkit Facility\");\n");
848 fprintf(fp
, "#endif //MODULE\n");
850 fprintf(fp
, "#endif //CONFIG_LTT\n");
This page took 0.075336 seconds and 4 git commands to generate.