5 #include <linux/errno.h>
9 #include "LinuxEvents.h"
11 #define TRACE_HEARTBEAT_ID 19
12 #define PROCESS_FORK_ID 20
13 #define PROCESS_EXIT_ID 21
16 #define OVERFLOW_FIGURE 0x100000000
17 //#define OVERFLOW_FIGURE 0xffffffff
19 typedef struct _new_process
21 uint32_t event_data1
; /* Data associated with event */
23 } LTT_PACKED_STRUCT new_process
;
25 #define write_to_buffer(DEST, SRC, SIZE) \
28 memcpy(DEST, SRC, SIZE);\
32 int readFile(int fd
, void * buf
, size_t size
, char * mesg
)
35 nbBytes
= read(fd
, buf
, size
);
43 void getDataEndianType(char * size
, char * endian
)
47 int sizeInt
=sizeof(int), sizeLong
=sizeof(long), sizePointer
=sizeof(void *);
49 if(c
== 1) strcpy(endian
,"LITTLE_ENDIAN");
50 else strcpy(endian
, "BIG_ENDIAN");
52 if(sizeInt
== 2 && sizeLong
== 4 && sizePointer
== 4)
54 else if(sizeInt
== 4 && sizeLong
== 4 && sizePointer
== 4)
56 else if(sizeInt
== 4 && sizeLong
== 8 && sizePointer
== 8)
58 else if(sizeInt
== 8 && sizeLong
== 8 && sizePointer
== 8)
60 else strcpy(size
,"UNKNOWN");
63 #define BUFFER_SIZE 80
65 typedef struct _buffer_start
{
70 } __attribute__ ((packed
)) buffer_start
;
72 typedef struct _heartbeat
{
76 } __attribute__ ((packed
)) heartbeat
;
79 int main(int argc
, char ** argv
){
83 int fdFac
, fdIntr
, fdProc
;
84 char arch_size
[BUFFER_SIZE
];
85 char endian
[BUFFER_SIZE
];
86 char node_name
[BUFFER_SIZE
];
87 char domainname
[BUFFER_SIZE
];
88 char kernel_name
[BUFFER_SIZE
];
89 char kernel_release
[BUFFER_SIZE
];
90 char kernel_version
[BUFFER_SIZE
];
91 char machine
[BUFFER_SIZE
];
92 char processor
[BUFFER_SIZE
];
93 char hardware_platform
[BUFFER_SIZE
];
94 char operating_system
[BUFFER_SIZE
];
97 int ltt_major_version
;
98 int ltt_minor_version
;
100 char buf
[BUFFER_SIZE
];
105 char foo
[4*BUFFER_SIZE
];
106 char foo_eventdefs
[4*BUFFER_SIZE
];
107 char foo_control
[4*BUFFER_SIZE
];
108 char foo_cpu
[4*BUFFER_SIZE
];
109 char foo_info
[4*BUFFER_SIZE
];
111 char foo_control_facilities
[4*BUFFER_SIZE
];
112 char foo_control_processes
[4*BUFFER_SIZE
];
113 char foo_control_interrupts
[4*BUFFER_SIZE
];
114 char foo_info_system
[4*BUFFER_SIZE
];
116 struct stat lTDFStat
;
118 int block_number
, block_size
;
119 char * buffer
, *buf_out
, cpuStr
[4*BUFFER_SIZE
];
120 char * buf_fac
, * buf_intr
, * buf_proc
;
121 void * write_pos
, *write_pos_fac
, * write_pos_intr
, *write_pos_proc
;
123 trace_buffer_start
*tBufStart
;
124 trace_buffer_end
*tBufEnd
;
125 trace_file_system
* tFileSys
;
126 uint16_t newId
, startId
, tmpId
;
128 uint32_t time_delta
, startTimeDelta
, previous_time_delta
;
129 void * cur_pos
, *end_pos
;
130 buffer_start start
, start_proc
, start_intr
;
131 buffer_start end
, end_proc
, end_intr
;
135 int reserve_size
= sizeof(buffer_start
) + sizeof(uint16_t) + 2*sizeof(uint32_t);//lost_size and buffer_end event
141 printf("Usage : ./convert processfile_name number_of_cpu tracefile1 tracefile2 ... trace_creation_directory\n");
142 printf("For more details, see README.\n");
147 printf("cpu number = %d\n", cpu
);
150 if(argc
!= nb_para
&& argc
!= nb_para
+1){
151 printf("need trace files and cpu number or root directory for the new tracefile\n");
157 strcpy(foo_eventdefs
, "foo/eventdefs");
158 strcpy(foo_control
, "foo/control");
159 strcpy(foo_cpu
, "foo/cpu");
160 strcpy(foo_info
, "foo/info");
162 strcpy(foo
, argv
[nb_para
]);
163 strcpy(foo_eventdefs
, argv
[nb_para
]);
164 strcat(foo_eventdefs
,"/eventdefs");
165 strcpy(foo_control
, argv
[nb_para
]);
166 strcat(foo_control
,"/control");
167 strcpy(foo_cpu
, argv
[nb_para
]);
168 strcat(foo_cpu
,"/cpu");
169 strcpy(foo_info
, argv
[nb_para
]);
170 strcat(foo_info
,"/info");
172 strcpy(foo_control_facilities
, foo_control
);
173 strcat(foo_control_facilities
,"/facilities");
174 strcpy(foo_control_processes
, foo_control
);
175 strcat(foo_control_processes
, "/processes");
176 strcpy(foo_control_interrupts
, foo_control
);
177 strcat(foo_control_interrupts
, "/interrupts");
178 strcpy(foo_info_system
, foo_info
);
179 strcat(foo_info_system
, "/system.xml");
182 getDataEndianType(arch_size
, endian
);
183 printf("Arch_size: %s, Endian: %s\n", arch_size
, endian
);
185 fp
= fopen("sysInfo.out","r");
187 g_error("Unable to open file sysInfo.out\n");
190 for(i
=0;i
<INFO_ENTRY
;i
++){
191 if(!fgets(buf
,BUFFER_SIZE
-1,fp
))
192 g_error("The format of sysInfo.out is not right\n");
193 if(strncmp(buf
,"node_name=",10)==0){
194 strcpy(node_name
,&buf
[10]);
195 node_name
[strlen(node_name
)-1] = '\0';
196 }else if(strncmp(buf
,"domainname=",11)==0){
197 strcpy(domainname
,&buf
[11]);
198 domainname
[strlen(domainname
)-1] = '\0';
199 }else if(strncmp(buf
,"kernel_name=",12)==0){
200 strcpy(kernel_name
,&buf
[12]);
201 kernel_name
[strlen(kernel_name
)-1] = '\0';
202 }else if(strncmp(buf
,"kernel_release=",15)==0){
203 strcpy(kernel_release
,&buf
[15]);
204 kernel_release
[strlen(kernel_release
)-1] = '\0';
205 }else if(strncmp(buf
,"kernel_version=",15)==0){
206 strcpy(kernel_version
,&buf
[15]);
207 kernel_version
[strlen(kernel_version
)-1] = '\0';
208 }else if(strncmp(buf
,"machine=",8)==0){
209 strcpy(machine
,&buf
[8]);
210 machine
[strlen(machine
)-1] = '\0';
211 }else if(strncmp(buf
,"processor=",10)==0){
212 strcpy(processor
,&buf
[10]);
213 processor
[strlen(processor
)-1] = '\0';
214 }else if(strncmp(buf
,"hardware_platform=",18)==0){
215 strcpy(hardware_platform
,&buf
[18]);
216 hardware_platform
[strlen(hardware_platform
)-1] = '\0';
217 }else if(strncmp(buf
,"operating_system=",17)==0){
218 strcpy(operating_system
,&buf
[17]);
219 operating_system
[strlen(operating_system
)-1] = '\0';
224 if(mkdir(foo
, S_IFDIR
| S_IRWXU
| S_IRGRP
| S_IROTH
))
225 g_error("can not make %s directory", foo
);
226 if(mkdir(foo_info
, S_IFDIR
| S_IRWXU
| S_IRGRP
| S_IROTH
))
227 g_error("can not make %s directory", foo_info
);
228 if(mkdir(foo_cpu
, S_IFDIR
| S_IRWXU
| S_IRGRP
| S_IROTH
))
229 g_error("can not make %s directory", foo_cpu
);
230 if(mkdir(foo_control
, S_IFDIR
| S_IRWXU
| S_IRGRP
| S_IROTH
))
231 g_error("can not make %s directory", foo_control
);
232 if(mkdir(foo_eventdefs
, S_IFDIR
| S_IRWXU
| S_IRGRP
| S_IROTH
))
233 g_error("can not make %s directory", foo_eventdefs
);
235 fp
= fopen(foo_info_system
,"w");
237 g_error("Unable to open file system.xml\n");
240 fdFac
= open(foo_control_facilities
,O_CREAT
| O_RDWR
| O_TRUNC
,S_IRUSR
|S_IWUSR
| S_IRGRP
| S_IROTH
);
242 g_error("Unable to open file facilities\n");
244 fdIntr
= open(foo_control_interrupts
,O_CREAT
| O_RDWR
| O_TRUNC
,S_IRUSR
|S_IWUSR
| S_IRGRP
| S_IROTH
);
246 g_error("Unable to open file interrupts\n");
248 fdProc
= open(foo_control_processes
,O_CREAT
| O_RDWR
| O_TRUNC
,S_IRUSR
|S_IWUSR
| S_IRGRP
| S_IROTH
);
250 g_error("Unable to open file process\n");
255 fd
= open(argv
[nb_para
-cpu
+k
], O_RDONLY
, 0);
257 g_error("Unable to open input data file %s\n", argv
[nb_para
-cpu
+k
]);
260 if(fstat(fd
, &lTDFStat
) < 0){
261 g_error("Unable to get the status of the input data file\n");
263 file_size
= lTDFStat
.st_size
;
265 buffer
= g_new(char, 4000);
266 readFile(fd
,(void*)buffer
, 3500, "Unable to read block header");
269 evId
= *(uint8_t *)cur_pos
;
270 cur_pos
+= sizeof(uint8_t);
272 time_delta
= *(uint32_t*)cur_pos
;
273 cur_pos
+= sizeof(uint32_t);
274 tBufStart
= (trace_buffer_start
*)cur_pos
;
275 cur_pos
+= sizeof(trace_buffer_start
);
276 cur_pos
+= sizeof(uint16_t); //Skip event size
278 evId
= *(uint8_t *)cur_pos
;
279 cur_pos
+= sizeof(uint8_t);
280 cur_pos
+= sizeof(uint32_t);
281 tStart
= (trace_start
*)cur_pos
;
284 startTimeDelta
= time_delta
;
285 start
.seconds
= tBufStart
->Time
.tv_sec
;
286 start
.nanoseconds
= tBufStart
->Time
.tv_usec
;
287 start
.cycle_count
= tBufStart
->TSC
;
288 start
.block_id
= tBufStart
->ID
;
289 end
.block_id
= start
.block_id
;
291 ltt_major_version
= tStart
->MajorVersion
;
292 ltt_minor_version
= tStart
->MinorVersion
;
293 ltt_block_size
= tStart
->BufferSize
;
294 ltt_log_cpu
= tStart
->LogCPUID
;
296 block_size
= ltt_block_size
;
297 block_number
= file_size
/block_size
;
300 buffer
= g_new(char, block_size
);
301 buf_fac
= g_new(char, block_size
);
302 write_pos_fac
= buf_fac
;
303 buf_intr
= g_new(char, block_size
);
304 write_pos_intr
= buf_intr
;
305 buf_proc
= g_new(char, block_size
);
306 write_pos_proc
= buf_proc
;
308 buf_out
= g_new(char, block_size
);
310 sprintf(cpuStr
,"%s/%d\0",foo_cpu
,k
);
311 fdCpu
= open(cpuStr
, O_CREAT
| O_RDWR
| O_TRUNC
,S_IRUSR
|S_IWUSR
| S_IRGRP
| S_IROTH
); //for cpu k
312 if(fdCpu
< 0) g_error("Unable to open cpu file %d\n", k
);
313 lseek(fd
,0,SEEK_SET
);
315 for(i
=0;i
<block_number
;i
++){
319 memset((void*)buf_out
, 0, block_size
);
321 memset((void*)buf_intr
, 0, block_size
);
322 memset((void*)buf_fac
, 0, block_size
);
323 memset((void*)buf_proc
, 0, block_size
);
324 write_pos_intr
= buf_intr
;
325 write_pos_fac
= buf_fac
;
326 write_pos_proc
= buf_proc
;
328 memset((void*)buffer
,0,block_size
);
329 readFile(fd
,(void*)buffer
, block_size
, "Unable to read block header");
332 evId
= *(uint8_t *)cur_pos
;
333 cur_pos
+= sizeof(uint8_t);
335 time_delta
= *(uint32_t*)cur_pos
;
336 cur_pos
+= sizeof(uint32_t);
337 tBufStart
= (trace_buffer_start
*)cur_pos
;
338 cur_pos
+= sizeof(trace_buffer_start
);
339 cur_pos
+= sizeof(uint16_t); //Skip event size
342 startTimeDelta
= time_delta
;
343 previous_time_delta
= time_delta
;
344 start
.seconds
= tBufStart
->Time
.tv_sec
;
345 start
.nanoseconds
= tBufStart
->Time
.tv_usec
;
346 start
.cycle_count
= tBufStart
->TSC
;
347 start
.block_id
= tBufStart
->ID
;
348 end
.block_id
= start
.block_id
;
350 end_pos
= buffer
+ block_size
; //end of the buffer
351 size_lost
= *(uint32_t*)(end_pos
- sizeof(uint32_t));
353 end_pos
= buffer
+ block_size
- size_lost
; //buffer_end event
355 tBufEnd
= (trace_buffer_end
*)(end_pos
+ 2 * sizeof(uint8_t)+sizeof(uint32_t));
357 tBufEnd
= (trace_buffer_end
*)(end_pos
+sizeof(uint8_t)+sizeof(uint32_t));
359 end
.seconds
= tBufEnd
->Time
.tv_sec
;
360 end
.nanoseconds
= tBufEnd
->Time
.tv_usec
;
361 end
.cycle_count
= tBufEnd
->TSC
;
363 //skip buffer start and trace start events
364 if(i
==0) //the first block
365 cur_pos
= buffer
+ sizeof(trace_buffer_start
) + sizeof(trace_start
) + 2*(sizeof(uint8_t)+sizeof(uint16_t)+sizeof(uint32_t));
367 cur_pos
= buffer
+ sizeof(trace_buffer_start
) + sizeof(uint8_t)+sizeof(uint16_t)+sizeof(uint32_t);
369 //write start block event
370 write_to_buffer(write_pos
,(void*)&startId
, sizeof(uint16_t));
371 write_to_buffer(write_pos
,(void*)&startTimeDelta
, sizeof(uint32_t));
372 write_to_buffer(write_pos
,(void*)&start
, sizeof(buffer_start
));
374 //write start block event into processes and interrupts files
375 write_to_buffer(write_pos_intr
,(void*)&startId
, sizeof(uint16_t));
376 write_to_buffer(write_pos_intr
,(void*)&startTimeDelta
, sizeof(uint32_t));
378 start_intr
.nanoseconds
-= 20;
379 write_to_buffer(write_pos_intr
,(void*)&start_intr
, sizeof(buffer_start
));
381 write_to_buffer(write_pos_proc
,(void*)&startId
, sizeof(uint16_t));
382 write_to_buffer(write_pos_proc
,(void*)&startTimeDelta
, sizeof(uint32_t));
384 start_proc
.nanoseconds
-= 40;
385 write_to_buffer(write_pos_proc
,(void*)&start_proc
, sizeof(buffer_start
));
387 //parse *.proc file to get process and irq info
389 int lIntID
; /* Interrupt ID */
390 int lPID
, lPPID
; /* Process PID and Parent PID */
391 char lName
[256]; /* Process name */
396 fProc
= fopen(argv
[1],"r");
398 g_error("Unable to open file %s\n", argv
[1]);
401 while(fscanf(fProc
, "PID: %d; PPID: %d; NAME: %s\n", &lPID
, &lPPID
, lName
) > 0){
402 defaultId
= PROCESS_FORK_ID
;
403 process
.event_data1
= lPID
;
404 process
.event_data2
= lPPID
;
405 write_to_buffer(write_pos_proc
,(void*)&defaultId
, sizeof(uint16_t));
406 write_to_buffer(write_pos_proc
,(void*)&startTimeDelta
, sizeof(uint32_t));
407 write_to_buffer(write_pos_proc
,(void*)&process
, sizeof(new_process
));
410 while(fscanf(fProc
, "IRQ: %d; NAME: ", &lIntID
) > 0){
411 /* Read 'til the end of the line */
412 fgets(lName
, 200, fProc
);
414 defaultId
= TRACE_IRQ_ENTRY
;
417 write_to_buffer(write_pos_intr
,(void*)&defaultId
, sizeof(uint16_t));
418 write_to_buffer(write_pos_intr
,(void*)&startTimeDelta
, sizeof(uint32_t));
419 write_to_buffer(write_pos_intr
,(void*)&irq
, sizeof(trace_irq_entry
));
430 cpu_id
= *(uint8_t*)cur_pos
;
431 cur_pos
+= sizeof(uint8_t);
433 evId
= *(uint8_t *)cur_pos
;
435 if(evId
== TRACE_HEARTBEAT
) {
436 newId
= TRACE_HEARTBEAT_ID
;
438 cur_pos
+= sizeof(uint8_t);
439 time_delta
= *(uint32_t*)cur_pos
;
440 cur_pos
+= sizeof(uint32_t);
442 if(time_delta
< previous_time_delta
){
443 end
.cycle_count
+= OVERFLOW_FIGURE
;
445 previous_time_delta
= time_delta
;
447 //write event_id and time_delta
448 write_to_buffer(write_pos
,(void*)&newId
,sizeof(uint16_t));
449 write_to_buffer(write_pos
,(void*)&time_delta
, sizeof(uint32_t));
451 if(evId
== TRACE_BUFFER_END
){
452 int size
= block_size
+ ((void*)buf_out
- write_pos
)+ sizeof(uint16_t) + sizeof(uint32_t);
453 write_to_buffer(write_pos
,(void*)&end
,sizeof(buffer_start
));
454 write_pos
= buf_out
+ block_size
- sizeof(uint32_t);
455 write_to_buffer(write_pos
,(void*)&size
, sizeof(uint32_t));
456 write(fdCpu
,(void*)buf_out
, block_size
);
458 //write out processes and intrrupts files
460 int size_intr
= block_size
- (write_pos_intr
- (void*)buf_intr
);
461 int size_proc
= block_size
- (write_pos_proc
- (void*)buf_proc
);
462 write_to_buffer(write_pos_intr
,(void*)&newId
,sizeof(uint16_t));
463 write_to_buffer(write_pos_intr
,(void*)&time_delta
, sizeof(uint32_t));
465 end_intr
.nanoseconds
-= 20;
466 write_to_buffer(write_pos_intr
,(void*)&end_intr
,sizeof(buffer_start
));
468 write_to_buffer(write_pos_proc
,(void*)&newId
,sizeof(uint16_t));
469 write_to_buffer(write_pos_proc
,(void*)&time_delta
, sizeof(uint32_t));
471 end_proc
.nanoseconds
-= 40;
472 write_to_buffer(write_pos_proc
,(void*)&end_proc
,sizeof(buffer_start
));
474 write_pos_intr
= buf_intr
+ block_size
- sizeof(uint32_t);
475 write_pos_proc
= buf_proc
+ block_size
- sizeof(uint32_t);
476 write_to_buffer(write_pos_intr
,(void*)&size_intr
, sizeof(uint32_t));
477 write_to_buffer(write_pos_proc
,(void*)&size_proc
, sizeof(uint32_t));
478 //for now don't output processes and interrupt information
479 // write(fdIntr,(void*)buf_intr,block_size);
480 // write(fdProc,(void*)buf_proc,block_size);
487 case TRACE_SYSCALL_ENTRY
:
488 event_size
= sizeof(trace_syscall_entry
);
490 case TRACE_SYSCALL_EXIT
:
493 case TRACE_TRAP_ENTRY
:
494 event_size
= sizeof(trace_trap_entry
);
496 case TRACE_TRAP_EXIT
:
499 case TRACE_IRQ_ENTRY
:
500 event_size
= sizeof(trace_irq_entry
);
501 timeDelta
= time_delta
;
502 write_to_buffer(write_pos_intr
,(void*)&newId
, sizeof(uint16_t));
503 write_to_buffer(write_pos_intr
,(void*)&timeDelta
, sizeof(uint32_t));
504 write_to_buffer(write_pos_intr
,cur_pos
, event_size
);
508 timeDelta
= time_delta
;
509 write_to_buffer(write_pos_intr
,(void*)&newId
, sizeof(uint16_t));
510 write_to_buffer(write_pos_intr
,(void*)&timeDelta
, sizeof(uint32_t));
512 case TRACE_SCHEDCHANGE
:
513 event_size
= sizeof(trace_schedchange
);
515 case TRACE_KERNEL_TIMER
:
519 event_size
= sizeof(trace_soft_irq
);
520 // timeDelta = time_delta;
521 // write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
522 // write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint32_t));
523 // write_to_buffer(write_pos_intr,cur_pos, event_size);
526 event_size
= sizeof(trace_process
);
527 timeDelta
= time_delta
;
528 subId
= *(uint8_t*)cur_pos
;
529 if(subId
== TRACE_PROCESS_FORK
|| subId
==TRACE_PROCESS_EXIT
){
530 if( subId
== TRACE_PROCESS_FORK
)tmpId
= PROCESS_FORK_ID
;
531 else tmpId
= PROCESS_EXIT_ID
;
532 write_to_buffer(write_pos_proc
,(void*)&tmpId
, sizeof(uint16_t));
533 write_to_buffer(write_pos_proc
,(void*)&timeDelta
, sizeof(uint32_t));
535 process
= *(new_process
*)(cur_pos
+ sizeof(uint8_t));
536 write_to_buffer(write_pos_proc
,(void*)&process
, sizeof(new_process
));
539 case TRACE_FILE_SYSTEM
:
540 event_size
= sizeof(trace_file_system
)- sizeof(char*);
543 event_size
= sizeof(trace_timer
);
546 event_size
= sizeof(trace_memory
);
549 event_size
= sizeof(trace_socket
);
552 event_size
= sizeof(trace_ipc
);
555 event_size
= sizeof(trace_network
);
557 case TRACE_HEARTBEAT
:
560 beat
.nanoseconds
= 0;
561 beat
.cycle_count
= start
.cycle_count
+ beat_count
* OVERFLOW_FIGURE
;
564 // end.cycle_count += OVERFLOW_FIGURE;
566 write_to_buffer(write_pos_intr
,(void*)&newId
, sizeof(uint16_t));
567 write_to_buffer(write_pos_intr
,(void*)&timeDelta
, sizeof(uint32_t));
568 write_to_buffer(write_pos_intr
,(void*)&beat
, sizeof(heartbeat
));
569 write_to_buffer(write_pos_proc
,(void*)&newId
, sizeof(uint16_t));
570 write_to_buffer(write_pos_proc
,(void*)&timeDelta
, sizeof(uint32_t));
571 write_to_buffer(write_pos_proc
,(void*)&beat
, sizeof(heartbeat
));
577 if(evId
!= TRACE_FILE_SYSTEM
&& event_size
>=0){
578 write_to_buffer(write_pos
, cur_pos
, event_size
);
580 if(evId
== TRACE_HEARTBEAT
){
581 write_to_buffer(write_pos
, (void*)&beat
, sizeof(heartbeat
));
584 cur_pos
+= event_size
+ sizeof(uint16_t); //skip data_size
585 }else if(evId
== TRACE_FILE_SYSTEM
){
588 tFileSys
= (trace_file_system
*)cur_pos
;
589 subId
= tFileSys
->event_sub_id
;
590 if(subId
== TRACE_FILE_SYSTEM_OPEN
|| subId
== TRACE_FILE_SYSTEM_EXEC
){
591 nbBytes
= tFileSys
->event_data2
+1;
594 write_to_buffer(write_pos
, cur_pos
, event_size
);
595 cur_pos
+= event_size
+ sizeof(char*);
597 write_to_buffer(write_pos
, cur_pos
, nbBytes
);
599 write_to_buffer(write_pos
, (void*)&c
, 1);
601 cur_pos
+= nbBytes
+ sizeof(uint16_t); //skip data_size
602 }else if(event_size
== -1){
603 printf("Unknown event: evId=%d, i=%d, event_count=%d\n", newId
, i
, event_count
);
622 //write to system.xml
623 fprintf(fp
,"<system \n");
624 fprintf(fp
,"node_name=\"%s\" \n", node_name
);
625 fprintf(fp
,"domainname=\"%s\" \n", domainname
);
626 fprintf(fp
,"cpu=\"%d\" \n", cpu
);
627 fprintf(fp
,"arch_size=\"%s\" \n", arch_size
);
628 fprintf(fp
,"endian=\"%s\" \n",endian
);
629 fprintf(fp
,"kernel_name=\"%s\" \n",kernel_name
);
630 fprintf(fp
,"kernel_release=\"%s\" \n",kernel_release
);
631 fprintf(fp
,"kernel_version=\"%s\" \n",kernel_version
);
632 fprintf(fp
,"machine=\"%s\" \n",machine
);
633 fprintf(fp
,"processor=\"%s\" \n",processor
);
634 fprintf(fp
,"hardware_platform=\"%s\" \n",hardware_platform
);
635 fprintf(fp
,"operating_system=\"%s\" \n",operating_system
);
636 fprintf(fp
,"ltt_major_version=\"%d\" \n",ltt_major_version
);
637 fprintf(fp
,"ltt_minor_version=\"%d\" \n",ltt_minor_version
);
638 fprintf(fp
,"ltt_block_size=\"%d\" \n",ltt_block_size
);
640 fprintf(fp
,"This is just a test\n");
641 fprintf(fp
,"</system>\n");