long long perf_mmap_read( void *our_mmap, int mmap_size,
long long prev_head,
int sample_type, int read_format, long long reg_mask,
void *validate,
int quiet, int *events_read ) {
struct perf_event_mmap_page *control_page = (struct perf_event_mmap_page * )our_mmap;
long long head,offset;
int i,size;
long long bytesize,prev_head_wrap;
unsigned char *data;
void *data_mmap= (void *)((size_t)our_mmap+getpagesize());
if (mmap_size==0) return 0;
if (control_page==NULL) {
fprintf(stderr,"ERROR mmap page NULL\n");
return -1;
}
head=control_page->data_head;
//rmb(); /* Must always follow read of data_head */
size=head-prev_head;
printf("Head: %lld Prev_head=%lld\n",head,prev_head);
printf("%d new bytes\n",size);
bytesize=mmap_size*getpagesize();
if (size>bytesize) {
printf("error! we overflowed the mmap buffer %d>%lld bytes\n",
size,bytesize);
}
data= (unsigned char *)malloc(bytesize);
if (data==NULL) {
return -1;
}
prev_head_wrap=prev_head%bytesize;
// printf("Copying %d bytes from %d to %d\n",
// bytesize-prev_head_wrap,prev_head_wrap,0);
memcpy(data,(unsigned char*)data_mmap + prev_head_wrap,
bytesize-prev_head_wrap);
//printf("Copying %d bytes from %d to %d\n",
// prev_head_wrap,0,bytesize-prev_head_wrap);
memcpy(data+(bytesize-prev_head_wrap),(unsigned char *)data_mmap,
prev_head_wrap);
struct perf_event_header *event;
offset=0;
if (events_read) *events_read=0;
while(offset<size) {
//printf("Offset %d Size %d\n",offset,size);
event = ( struct perf_event_header * ) & data[offset];
/********************/
/* Print event Type */
/********************/
if (!quiet) {
switch(event->type) {
case PERF_RECORD_MMAP:
printf("PERF_RECORD_MMAP"); break;
case PERF_RECORD_LOST:
printf("PERF_RECORD_LOST"); break;
case PERF_RECORD_COMM:
printf("PERF_RECORD_COMM"); break;
case PERF_RECORD_EXIT:
printf("PERF_RECORD_EXIT"); break;
case PERF_RECORD_THROTTLE:
printf("PERF_RECORD_THROTTLE"); break;
case PERF_RECORD_UNTHROTTLE:
printf("PERF_RECORD_UNTHROTTLE"); break;
case PERF_RECORD_FORK:
printf("PERF_RECORD_FORK"); break;
case PERF_RECORD_READ:
printf("PERF_RECORD_READ"); break;
case PERF_RECORD_SAMPLE:
printf("PERF_RECORD_SAMPLE [%x]",sample_type); break;
case PERF_RECORD_MMAP2:
printf("PERF_RECORD_MMAP2"); break;
default: printf("UNKNOWN %d",event->type); break;
}
printf(", MISC=%d (",event->misc);
switch(event->misc & PERF_RECORD_MISC_CPUMODE_MASK) {
case PERF_RECORD_MISC_CPUMODE_UNKNOWN:
printf("PERF_RECORD_MISC_CPUMODE_UNKNOWN"); break;
case PERF_RECORD_MISC_KERNEL:
printf("PERF_RECORD_MISC_KERNEL"); break;
case PERF_RECORD_MISC_USER:
printf("PERF_RECORD_MISC_USER"); break;
case PERF_RECORD_MISC_HYPERVISOR:
printf("PERF_RECORD_MISC_HYPERVISOR"); break;
case PERF_RECORD_MISC_GUEST_KERNEL:
printf("PERF_RECORD_MISC_GUEST_KERNEL"); break;
case PERF_RECORD_MISC_GUEST_USER:
printf("PERF_RECORD_MISC_GUEST_USER"); break;
default:
printf("Unknown %d!\n",event->misc); break;
}
/* Both have the same value */
if (event->misc & PERF_RECORD_MISC_MMAP_DATA) {
printf(",PERF_RECORD_MISC_MMAP_DATA or PERF_RECORD_MISC_COMM_EXEC ");
}
if (event->misc & PERF_RECORD_MISC_EXACT_IP) {
printf(",PERF_RECORD_MISC_EXACT_IP ");
}
if (event->misc & PERF_RECORD_MISC_EXT_RESERVED) {
printf(",PERF_RECORD_MISC_EXT_RESERVED ");
}
printf("), Size=%d\n",event->size);
}
offset+=8; /* skip header */
/***********************/
/* Print event Details */
/***********************/
switch(event->type) {
/* Lost */
case PERF_RECORD_LOST: {
long long id,lost;
memcpy(&id,&data[offset],sizeof(long long));
if (!quiet) printf("\tID: %lld\n",id);
offset+=8;
memcpy(&lost,&data[offset],sizeof(long long));
if (!quiet) printf("\tLOST: %lld\n",lost);
offset+=8;
}
break;
/* COMM */
case PERF_RECORD_COMM: {
int pid,tid,string_size;
char *string;
memcpy(&pid,&data[offset],sizeof(int));
if (!quiet) printf("\tPID: %d\n",pid);
offset+=4;
memcpy(&tid,&data[offset],sizeof(int));
if (!quiet) printf("\tTID: %d\n",tid);
offset+=4;
/* FIXME: sample_id handling? */
/* two ints plus the 64-bit header */
string_size=event->size-16;
string=(char *)calloc(string_size,sizeof(char));
memcpy(string,&data[offset],string_size);
if (!quiet) printf("\tcomm: %s\n",string);
offset+=string_size;
if (string) free(string);
}
break;
/* Fork */
case PERF_RECORD_FORK: {
int pid,ppid,tid,ptid;
long long fork_time;
memcpy(&pid,&data[offset],sizeof(int));
if (!quiet) printf("\tPID: %d\n",pid);
offset+=4;
memcpy(&ppid,&data[offset],sizeof(int));
if (!quiet) printf("\tPPID: %d\n",ppid);
offset+=4;
memcpy(&tid,&data[offset],sizeof(int));
if (!quiet) printf("\tTID: %d\n",tid);
offset+=4;
memcpy(&ptid,&data[offset],sizeof(int));
if (!quiet) printf("\tPTID: %d\n",ptid);
offset+=4;
memcpy(&fork_time,&data[offset],sizeof(long long));
if (!quiet) printf("\tTime: %lld\n",fork_time);
offset+=8;
}
break;
/* mmap */
case PERF_RECORD_MMAP: {
int pid,tid,string_size;
long long address,len,pgoff;
char *filename;
memcpy(&pid,&data[offset],sizeof(int));
if (!quiet) printf("\tPID: %d\n",pid);
offset+=4;
memcpy(&tid,&data[offset],sizeof(int));
if (!quiet) printf("\tTID: %d\n",tid);
offset+=4;
memcpy(&address,&data[offset],sizeof(long long));
if (!quiet) printf("\tAddress: %llx\n",address);
offset+=8;
memcpy(&len,&data[offset],sizeof(long long));
if (!quiet) printf("\tLength: %llx\n",len);
offset+=8;
memcpy(&pgoff,&data[offset],sizeof(long long));
if (!quiet) printf("\tPage Offset: %llx\n",pgoff);
offset+=8;
string_size=event->size-40;
filename=(char *)calloc(string_size,sizeof(char));
memcpy(filename,&data[offset],string_size);
if (!quiet) printf("\tFilename: %s\n",filename);
offset+=string_size;
if (filename) free(filename);
}
break;
/* mmap2 */
case PERF_RECORD_MMAP2: {
int pid,tid,string_size;
long long address,len,pgoff;
int major,minor;
long long ino,ino_generation;
int prot,flags;
char *filename;
memcpy(&pid,&data[offset],sizeof(int));
if (!quiet) printf("\tPID: %d\n",pid);
offset+=4;
memcpy(&tid,&data[offset],sizeof(int));
if (!quiet) printf("\tTID: %d\n",tid);
offset+=4;
memcpy(&address,&data[offset],sizeof(long long));
if (!quiet) printf("\tAddress: %llx\n",address);
offset+=8;
memcpy(&len,&data[offset],sizeof(long long));
if (!quiet) printf("\tLength: %llx\n",len);
offset+=8;
memcpy(&pgoff,&data[offset],sizeof(long long));
if (!quiet) printf("\tPage Offset: %llx\n",pgoff);
offset+=8;
memcpy(&major,&data[offset],sizeof(int));
if (!quiet) printf("\tMajor: %d\n",major);
offset+=4;
memcpy(&minor,&data[offset],sizeof(int));
if (!quiet) printf("\tMinor: %d\n",minor);
offset+=4;
memcpy(&ino,&data[offset],sizeof(long long));
if (!quiet) printf("\tIno: %llx\n",ino);
offset+=8;
memcpy(&ino_generation,&data[offset],sizeof(long long));
if (!quiet) printf("\tIno generation: %llx\n",ino_generation);
offset+=8;
memcpy(&prot,&data[offset],sizeof(int));
if (!quiet) printf("\tProt: %d\n",prot);
offset+=4;
memcpy(&flags,&data[offset],sizeof(int));
if (!quiet) printf("\tFlags: %d\n",flags);
offset+=4;
string_size=event->size-72;
filename=(char *)calloc(string_size,sizeof(char));
memcpy(filename,&data[offset],string_size);
if (!quiet) printf("\tFilename: %s\n",filename);
offset+=string_size;
if (filename) free(filename);
}
break;
/* Exit */
case PERF_RECORD_EXIT: {
int pid,ppid,tid,ptid;
long long fork_time;
memcpy(&pid,&data[offset],sizeof(int));
if (!quiet) printf("\tPID: %d\n",pid);
offset+=4;
memcpy(&ppid,&data[offset],sizeof(int));
if (!quiet) printf("\tPPID: %d\n",ppid);
offset+=4;
memcpy(&tid,&data[offset],sizeof(int));
if (!quiet) printf("\tTID: %d\n",tid);
offset+=4;
memcpy(&ptid,&data[offset],sizeof(int));
if (!quiet) printf("\tPTID: %d\n",ptid);
offset+=4;
memcpy(&fork_time,&data[offset],sizeof(long long));
if (!quiet) printf("\tTime: %lld\n",fork_time);
offset+=8;
}
break;
/* Sample */
case PERF_RECORD_SAMPLE: {
#if 1
long long iter = offset-8;
while(iter < (offset + 128)) {
long long value;
memcpy(&value, &data[iter], sizeof(long long));
if (!quiet) printf("\t offset %llx: %llx\n", iter, value);
iter += 8;
}
#endif
if (sample_type & PERF_SAMPLE_IP) {
long long ip;
memcpy(&ip,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_IP, IP: %llx\n",ip);
offset+=8;
}
if (sample_type & PERF_SAMPLE_TID) {
int pid, tid;
memcpy(&pid,&data[offset],sizeof(int));
memcpy(&tid,&data[offset+4],sizeof(int));
if (!quiet) {
printf("\tPERF_SAMPLE_TID, pid: %d tid %d\n",pid,tid);
}
offset+=8;
}
if (sample_type & PERF_SAMPLE_TIME) {
long long time;
memcpy(&time,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_TIME, time: %lld\n",time);
offset+=8;
}
if (sample_type & PERF_SAMPLE_ADDR) {
long long addr;
memcpy(&addr,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_ADDR, addr: %llx. Offset %llx\n",addr, offset);
offset+=8;
}
if (sample_type & PERF_SAMPLE_ID) {
long long sample_id;
memcpy(&sample_id,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_ID, sample_id: %lld. Offset %llx\n",sample_id, offset);
offset+=8;
}
if (sample_type & PERF_SAMPLE_STREAM_ID) {
long long sample_stream_id;
memcpy(&sample_stream_id,&data[offset],sizeof(long long));
if (!quiet) {
printf("\tPERF_SAMPLE_STREAM_ID, sample_stream_id: %lld\n",sample_stream_id);
}
offset+=8;
}
if (sample_type & PERF_SAMPLE_CPU) {
int cpu, res;
memcpy(&cpu,&data[offset],sizeof(int));
memcpy(&res,&data[offset+4],sizeof(int));
if (!quiet) printf("\tPERF_SAMPLE_CPU, cpu: %d res %d\n",cpu,res);
offset+=8;
}
if (sample_type & PERF_SAMPLE_PERIOD) {
long long period;
memcpy(&period,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_PERIOD, period: %lld\n",period);
offset+=8;
}
if (sample_type & PERF_SAMPLE_READ) {
int length;
if (!quiet) printf("\tPERF_SAMPLE_READ, read_format\n");
length=handle_struct_read_format(&data[offset],
read_format,
validate,quiet);
if (length>=0) offset+=length;
}
if (sample_type & PERF_SAMPLE_CALLCHAIN) {
long long nr,ip;
memcpy(&nr,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_CALLCHAIN, callchain length: %lld\n",nr);
offset+=8;
for(i=0;i<nr;i++) {
memcpy(&ip,&data[offset],sizeof(long long));
if (!quiet) printf("\t\t ip[%d]: %llx\n",i,ip);
offset+=8;
}
}
if (sample_type & PERF_SAMPLE_RAW) {
int size;
memcpy(&size,&data[offset],sizeof(int));
if (!quiet) printf("\tPERF_SAMPLE_RAW, Raw length: %d\n",size);
offset+=4;
if (!quiet) printf("\t\t");
for(i=0;i<size;i++) {
if (!quiet) printf("%d ",data[offset]);
offset+=1;
}
if (!quiet) printf("\n");
}
if (sample_type & PERF_SAMPLE_BRANCH_STACK) {
long long bnr;
memcpy(&bnr,&data[offset],sizeof(long long));
if (!quiet) {
printf("\tPERF_SAMPLE_BRANCH_STACK, branch_stack entries: %lld\n",bnr);
}
offset+=8;
for(i=0;i<bnr;i++) {
long long from,to,flags;
/* From value */
memcpy(&from,&data[offset],sizeof(long long));
offset+=8;
/* To Value */
memcpy(&to,&data[offset],sizeof(long long));
offset+=8;
if (!quiet) {
printf("\t\t lbr[%d]: %llx %llx ",
i,from,to);
}
/* Flags */
memcpy(&flags,&data[offset],sizeof(long long));
offset+=8;
if (!quiet) {
if (flags==0) printf("0");
if (flags&1) {
printf("MISPREDICTED ");
flags&=~2;
}
if (flags&2) {
printf("PREDICTED ");
flags&=~2;
}
if (flags&4) {
printf("IN_TRANSACTION ");
flags&=~4;
}
if (flags&8) {
printf("TRANSACTION_ABORT ");
flags&=~8;
}
printf("\n");
}
}
}
if (sample_type & PERF_SAMPLE_REGS_USER) {
long long abi;
memcpy(&abi,&data[offset],sizeof(long long));
if (!quiet) {
printf("\tPERF_SAMPLE_REGS_USER, ABI: ");
if (abi==PERF_SAMPLE_REGS_ABI_NONE) printf ("PERF_SAMPLE_REGS_ABI_NONE");
if (abi==PERF_SAMPLE_REGS_ABI_32) printf("PERF_SAMPLE_REGS_ABI_32");
if (abi==PERF_SAMPLE_REGS_ABI_64) printf("PERF_SAMPLE_REGS_ABI_64");
printf("\n");
}
offset+=8;
offset+=print_regs(quiet,abi,reg_mask,
&data[offset]);
if (!quiet) printf("\n");
}
if (sample_type & PERF_SAMPLE_STACK_USER) {
long long size,dyn_size;
int *stack_data;
int k;
memcpy(&size,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_STACK_USER, Requested size: %lld\n",size);
offset+=8;
stack_data=(int *)malloc(size);
memcpy(stack_data,&data[offset],size);
offset+=size;
memcpy(&dyn_size,&data[offset],sizeof(long long));
if (!quiet) printf("\t\tDynamic (used) size: %lld\n",dyn_size);
offset+=8;
if (!quiet) printf("\t\t");
for(k=0;k<dyn_size;k+=4) {
if (!quiet) printf("0x%x ",stack_data[k]);
}
free(stack_data);
if (!quiet) printf("\n");
}
if (sample_type & PERF_SAMPLE_WEIGHT) {
long long weight;
memcpy(&weight,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_WEIGHT, Weight: %lld ",weight);
offset+=8;
if (!quiet) printf("\n");
}
if (sample_type & PERF_SAMPLE_DATA_SRC) {
long long src;
memcpy(&src,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_DATA_SRC, Raw: %llx\n",src);
offset+=8;
if (!quiet) {
if (src!=0) printf("\t\t");
if (src & (PERF_MEM_OP_NA<<PERF_MEM_OP_SHIFT))
printf("Op Not available ");
if (src & (PERF_MEM_OP_LOAD<<PERF_MEM_OP_SHIFT))
printf("Load ");
if (src & (PERF_MEM_OP_STORE<<PERF_MEM_OP_SHIFT))
printf("Store ");
if (src & (PERF_MEM_OP_PFETCH<<PERF_MEM_OP_SHIFT))
printf("Prefetch ");
if (src & (PERF_MEM_OP_EXEC<<PERF_MEM_OP_SHIFT))
printf("Executable code ");
if (src & (PERF_MEM_LVL_NA<<PERF_MEM_LVL_SHIFT))
printf("Level Not available ");
if (src & (PERF_MEM_LVL_HIT<<PERF_MEM_LVL_SHIFT))
printf("Hit ");
if (src & (PERF_MEM_LVL_MISS<<PERF_MEM_LVL_SHIFT))
printf("Miss ");
if (src & (PERF_MEM_LVL_L1<<PERF_MEM_LVL_SHIFT))
printf("L1 cache ");
if (src & (PERF_MEM_LVL_LFB<<PERF_MEM_LVL_SHIFT))
printf("Line fill buffer ");
if (src & (PERF_MEM_LVL_L2<<PERF_MEM_LVL_SHIFT))
printf("L2 cache ");
if (src & (PERF_MEM_LVL_L3<<PERF_MEM_LVL_SHIFT))
printf("L3 cache ");
if (src & (PERF_MEM_LVL_LOC_RAM<<PERF_MEM_LVL_SHIFT))
printf("Local DRAM ");
if (src & (PERF_MEM_LVL_REM_RAM1<<PERF_MEM_LVL_SHIFT))
printf("Remote DRAM 1 hop ");
if (src & (PERF_MEM_LVL_REM_RAM2<<PERF_MEM_LVL_SHIFT))
printf("Remote DRAM 2 hops ");
if (src & (PERF_MEM_LVL_REM_CCE1<<PERF_MEM_LVL_SHIFT))
printf("Remote cache 1 hop ");
if (src & (PERF_MEM_LVL_REM_CCE2<<PERF_MEM_LVL_SHIFT))
printf("Remote cache 2 hops ");
if (src & (PERF_MEM_LVL_IO<<PERF_MEM_LVL_SHIFT))
printf("I/O memory ");
if (src & (PERF_MEM_LVL_UNC<<PERF_MEM_LVL_SHIFT))
printf("Uncached memory ");
if (src & (PERF_MEM_SNOOP_NA<<PERF_MEM_SNOOP_SHIFT))
printf("Not available ");
if (src & (PERF_MEM_SNOOP_NONE<<PERF_MEM_SNOOP_SHIFT))
printf("No snoop ");
if (src & (PERF_MEM_SNOOP_HIT<<PERF_MEM_SNOOP_SHIFT))
printf("Snoop hit ");
if (src & (PERF_MEM_SNOOP_MISS<<PERF_MEM_SNOOP_SHIFT))
printf("Snoop miss ");
if (src & (PERF_MEM_SNOOP_HITM<<PERF_MEM_SNOOP_SHIFT))
printf("Snoop hit modified ");
if (src & (PERF_MEM_LOCK_NA<<PERF_MEM_LOCK_SHIFT))
printf("Not available ");
if (src & (PERF_MEM_LOCK_LOCKED<<PERF_MEM_LOCK_SHIFT))
printf("Locked transaction ");
if (src & (PERF_MEM_TLB_NA<<PERF_MEM_TLB_SHIFT))
printf("Not available ");
if (src & (PERF_MEM_TLB_HIT<<PERF_MEM_TLB_SHIFT))
printf("Hit ");
if (src & (PERF_MEM_TLB_MISS<<PERF_MEM_TLB_SHIFT))
printf("Miss ");
if (src & (PERF_MEM_TLB_L1<<PERF_MEM_TLB_SHIFT))
printf("Level 1 TLB ");
if (src & (PERF_MEM_TLB_L2<<PERF_MEM_TLB_SHIFT))
printf("Level 2 TLB ");
if (src & (PERF_MEM_TLB_WK<<PERF_MEM_TLB_SHIFT))
printf("Hardware walker ");
if (src & (PERF_MEM_TLB_OS<<PERF_MEM_TLB_SHIFT))
printf("OS fault handler ");
}
if (!quiet) printf("\n");
}
if (sample_type & PERF_SAMPLE_IDENTIFIER) {
long long abi;
memcpy(&abi,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_IDENTIFIER, Raw length: %lld\n",abi);
offset+=8;
if (!quiet) printf("\n");
}
if (sample_type & PERF_SAMPLE_TRANSACTION) {
long long abi;
memcpy(&abi,&data[offset],sizeof(long long));
if (!quiet) printf("\tPERF_SAMPLE_TRANSACTION, Raw length: %lld\n",abi);
offset+=8;
if (!quiet) printf("\n");
}
}
break;
default: if (!quiet) printf("\tUnknown type %d\n",event->type);
}
if (events_read) (*events_read)++;
}
control_page->data_tail=head;
free(data);
return head;
}
long long perf_mmap_read( void *our_mmap, int mmap_size,
long long prev_head,
int sample_type, int read_format) {
struct perf_event_mmap_page *control_page = our_mmap;
long long head,offset;
int size;
long long bytesize,prev_head_wrap;
static long long begin_time;
unsigned char *data;
void *data_mmap=our_mmap+getpagesize();
begin_time=0;
if (mmap_size==0) return 0;
if (control_page==NULL) {
fprintf(stderr,"ERROR mmap page NULL\n");
return -1;
}
head=control_page->data_head;
rmb(); /* Must always follow read of data_head */
size=head-prev_head;
//printf("Head: %lld Prev_head=%lld\n",head,prev_head);
//printf("%d new bytes\n",size);
bytesize=mmap_size*getpagesize();
if (size>bytesize) {
printf("error! we overflowed the mmap buffer %d>%lld bytes\n",
size,bytesize);
}
data=malloc(bytesize);
if (data==NULL) {
return -1;
}
prev_head_wrap=prev_head%bytesize;
// printf("Copying %d bytes from %d to %d\n",
// bytesize-prev_head_wrap,prev_head_wrap,0);
memcpy(data,(unsigned char*)data_mmap + prev_head_wrap,
bytesize-prev_head_wrap);
//printf("Copying %d bytes from %d to %d\n",
// prev_head_wrap,0,bytesize-prev_head_wrap);
memcpy(data+(bytesize-prev_head_wrap),(unsigned char *)data_mmap,
prev_head_wrap);
struct perf_event_header *event;
offset=0;
while(offset<size) {
//printf("Offset %d Size %d\n",offset,size);
event = ( struct perf_event_header * ) & data[offset];
/********************/
/* Print event Type */
/********************/
switch(event->type) {
case PERF_RECORD_MMAP:
printf("PERF_RECORD_MMAP"); break;
case PERF_RECORD_LOST:
printf("PERF_RECORD_LOST"); break;
case PERF_RECORD_COMM:
printf("PERF_RECORD_COMM"); break;
case PERF_RECORD_EXIT:
printf("PERF_RECORD_EXIT"); break;
case PERF_RECORD_THROTTLE:
printf("PERF_RECORD_THROTTLE"); break;
case PERF_RECORD_UNTHROTTLE:
printf("PERF_RECORD_UNTHROTTLE"); break;
case PERF_RECORD_FORK:
printf("PERF_RECORD_FORK"); break;
case PERF_RECORD_READ:
printf("PERF_RECORD_READ");
break;
case PERF_RECORD_SAMPLE:
//printf("PERF_RECORD_SAMPLE [%x]",sample_type);
break;
case PERF_RECORD_MMAP2:
printf("PERF_RECORD_MMAP2"); break;
default: printf("UNKNOWN %d",event->type); break;
}
/* Both have the same value */
if (event->misc & PERF_RECORD_MISC_MMAP_DATA) {
printf(",PERF_RECORD_MISC_MMAP_DATA or PERF_RECORD_MISC_COMM_EXEC ");
}
if (event->misc & PERF_RECORD_MISC_EXACT_IP) {
printf(",PERF_RECORD_MISC_EXACT_IP ");
}
if (event->misc & PERF_RECORD_MISC_EXT_RESERVED) {
printf(",PERF_RECORD_MISC_EXT_RESERVED ");
}
offset+=8; /* skip header */
/***********************/
/* Print event Details */
/***********************/
switch(event->type) {
/* Lost */
case PERF_RECORD_LOST: {
long long id,lost;
memcpy(&id,&data[offset],sizeof(long long));
printf("\tID: %lld\n",id);
offset+=8;
memcpy(&lost,&data[offset],sizeof(long long));
printf("\tLOST: %lld\n",lost);
offset+=8;
}
break;
/* COMM */
case PERF_RECORD_COMM: {
int pid,tid,string_size;
char *string;
memcpy(&pid,&data[offset],sizeof(int));
printf("\tPID: %d\n",pid);
offset+=4;
memcpy(&tid,&data[offset],sizeof(int));
printf("\tTID: %d\n",tid);
offset+=4;
/* FIXME: sample_id handling? */
/* two ints plus the 64-bit header */
string_size=event->size-16;
string=calloc(string_size,sizeof(char));
memcpy(string,&data[offset],string_size);
printf("\tcomm: %s\n",string);
offset+=string_size;
if (string) free(string);
}
break;
/* Fork */
case PERF_RECORD_FORK: {
}
break;
/* mmap */
case PERF_RECORD_MMAP: {
}
break;
/* mmap2 */
case PERF_RECORD_MMAP2: {
}
break;
/* Exit */
case PERF_RECORD_EXIT: {
}
break;
/* Throttle/Unthrottle */
case PERF_RECORD_THROTTLE:
case PERF_RECORD_UNTHROTTLE: {
long long throttle_time,id,stream_id;
memcpy(&throttle_time,&data[offset],sizeof(long long));
printf("\tTime: %lld\n",throttle_time);
offset+=8;
memcpy(&id,&data[offset],sizeof(long long));
printf("\tID: %lld\n",id);
offset+=8;
memcpy(&stream_id,&data[offset],sizeof(long long));
printf("\tStream ID: %lld\n",stream_id);
offset+=8;
}
break;
/* Sample */
case PERF_RECORD_SAMPLE: {
long long time=0;
if (sample_type & PERF_SAMPLE_IP) {
long long ip;
memcpy(&ip,&data[offset],sizeof(long long));
printf("\tPERF_SAMPLE_IP, IP: %llx\n",ip);
offset+=8;
}
if (sample_type & PERF_SAMPLE_TID) {
int pid, tid;
memcpy(&pid,&data[offset],sizeof(int));
memcpy(&tid,&data[offset+4],sizeof(int));
printf("\tPERF_SAMPLE_TID, pid: %d tid %d\n",pid,tid);
offset+=8;
}
if (sample_type & PERF_SAMPLE_TIME) {
memcpy(&time,&data[offset],sizeof(long long));
//printf("\tPERF_SAMPLE_TIME, time: %lld\n",time);
if (begin_time==0) begin_time=time;
offset+=8;
}
if (sample_type & PERF_SAMPLE_ADDR) {
long long addr;
memcpy(&addr,&data[offset],sizeof(long long));
printf("\tPERF_SAMPLE_ADDR, addr: %llx\n",addr);
offset+=8;
}
if (sample_type & PERF_SAMPLE_ID) {
long long sample_id;
memcpy(&sample_id,&data[offset],sizeof(long long));
printf("\tPERF_SAMPLE_ID, sample_id: %lld\n",sample_id);
offset+=8;
}
if (sample_type & PERF_SAMPLE_STREAM_ID) {
long long sample_stream_id;
memcpy(&sample_stream_id,&data[offset],sizeof(long long));
printf("\tPERF_SAMPLE_STREAM_ID, sample_stream_id: %lld\n",sample_stream_id);
offset+=8;
}
if (sample_type & PERF_SAMPLE_CPU) {
int cpu, res;
memcpy(&cpu,&data[offset],sizeof(int));
memcpy(&res,&data[offset+4],sizeof(int));
printf("\tPERF_SAMPLE_CPU, cpu: %d res %d\n",cpu,res);
offset+=8;
}
if (sample_type & PERF_SAMPLE_PERIOD) {
long long period;
memcpy(&period,&data[offset],sizeof(long long));
printf("\tPERF_SAMPLE_PERIOD, period: %lld\n",period);
offset+=8;
}
if (sample_type & PERF_SAMPLE_READ) {
int length;
length=handle_struct_read_format(&data[offset],
read_format,time-begin_time);
if (length>=0) offset+=length;
}
if (sample_type & PERF_SAMPLE_CALLCHAIN) {
}
if (sample_type & PERF_SAMPLE_RAW) {
}
if (sample_type & PERF_SAMPLE_BRANCH_STACK) {
}
if (sample_type & PERF_SAMPLE_REGS_USER) {
}
if (sample_type & PERF_SAMPLE_REGS_INTR) {
}
if (sample_type & PERF_SAMPLE_STACK_USER) {
}
if (sample_type & PERF_SAMPLE_WEIGHT) {
}
if (sample_type & PERF_SAMPLE_DATA_SRC) {
}
if (sample_type & PERF_SAMPLE_IDENTIFIER) {
}
if (sample_type & PERF_SAMPLE_TRANSACTION) {
}
}
break;
default: printf("\tUnknown type %d\n",event->type);
}
}
control_page->data_tail=head;
free(data);
return head;
}
