void mmap_random_event(int type) {
int which;
switch(rand()%6) {
case 0: /* mmap random */
which=find_random_active_event();
setup_mmap(which);
break;
case 1: /* aux random */
break;
case 2: /* munmap random */
which=find_random_active_event();
unmap_mmap(which,0);
break;
case 3: /* mmap read */
which=find_random_active_event();
perf_mmap_read(which);
break;
case 4: /* trash mmap */
if (type & TYPE_TRASH_MMAP) {
trash_random_mmap();
}
break;
default:
break;
}
return;
}
void poll_random_event(void) {
int i,result,num_fds;
struct pollfd pollfds[MAX_POLL_FDS];
int timeout;
char log_buffer[BUFSIZ];
num_fds=rand()%MAX_POLL_FDS;
for(i=0;i<num_fds;i++) {
pollfds[i].fd=event_data[find_random_active_event()].fd;
pollfds[i].events=POLLIN;
}
/* Want short timeout (ms) */
timeout=rand()%10;
if (ignore_but_dont_skip.poll) return;
stats.poll_attempts++;
stats.total_syscalls++;
result=poll(pollfds,num_fds,timeout);
if (result>0) {
stats.poll_successful++;
if (logging&TYPE_POLL) {
sprintf(log_buffer,"p %d ",num_fds);
write(log_fd,log_buffer,strlen(log_buffer));
for(i=0;i<num_fds;i++) {
sprintf(log_buffer,"%d %x ",pollfds[i].fd,
pollfds[i].events);
write(log_fd,log_buffer,strlen(log_buffer));
}
sprintf(log_buffer,"%d\n",timeout);
write(log_fd,log_buffer,strlen(log_buffer));
}
}
}
void read_random_event(void) {
int i,result,read_size;
i=find_random_active_event();
/* Exit if no events */
if (i<0) return;
/* Exit if event has fd of 0, not want to read stdin */
if (event_data[i].fd==0) return;
switch (rand()%4) {
case 0: read_size=event_data[i].read_size;
break;
case 1: read_size=(rand()%8)*sizeof(long long);
break;
case 2: read_size=(rand()%MAX_READ_SIZE);
break;
default: read_size=(rand()%MAX_READ_SIZE)*sizeof(long long);
}
stats.read_attempts++;
if (ignore_but_dont_skip.read) return;
result=read(event_data[i].fd,data,read_size);
if (result>0) {
stats.read_successful++;
if (logging&TYPE_READ) {
sprintf(log_buffer,"R %d %d\n",
event_data[i].fd,read_size);
write(log_fd,log_buffer,strlen(log_buffer));
}
}
}
void open_random_event(int mmap_enabled, int overflow_enabled) {
int fd;
int i,trinity_type;
i=find_empty_event();
/* return if no free events */
if (i<0) return;
event_data[i].overflows=0;
event_data[i].throttles=0;
/* repeat until we create a valid event */
while(1) {
/* call trinity random perf_event_open() code */
//generic_sanitise(0);
trinity_type=syscall_perf_event_open.sanitise(&shm->syscall[0]);
memcpy(&event_data[i].attr,
(struct perf_event_attr *)shm->syscall[0].a1,
sizeof(struct perf_event_attr));
event_data[i].pid=shm->syscall[0].a2;
event_data[i].cpu=get_cpu();
event_data[i].group_fd=shm->syscall[0].a4;
event_data[i].flags=shm->syscall[0].a5;
post_perf_event_open(&shm->syscall[0]);
/* Randomly make part of a group 1/4 of the time */
if (rand()%4==2) {
int j;
j=find_random_active_event();
/* is it a master? */
/* can we set a group leader that isn't itself */
/* a leader? */
// if (event_data[j].group_fd==-1) {
event_data[i].group_fd=event_data[j].fd;
// }
}
/* Randomly try to use a kprobe */
if (event_data[i].attr.type==PERF_TYPE_TRACEPOINT) {
if (rand()%10==5) {
event_data[i].attr.config=kprobe_id;
}
}
if (ignore_but_dont_skip.open) return;
/* Debugging code */
/* We don't usually log failed opens as there are so many */
if (logging&TYPE_OPEN) {
#if LOG_FAILURES
if (trigger_failure_logging) {
/* uncomment if failing opens causing crashes */
// static int quit_next=0;
// if (event_data[i].attr.type==PERF_TYPE_TRACEPOINT) {
sprintf(log_buffer,"# O -1 %d %d %d %lx ",
event_data[i].pid,
event_data[i].cpu,
event_data[i].group_fd,
event_data[i].flags);
write(log_fd,log_buffer,strlen(log_buffer));
perf_log_attr(&event_data[i].attr);
// fsync(log_fd);
// }
// if (quit_next==1) exit(1);
// if (quit_next) quit_next--;
// if ((event_data[i].attr.read_format==0x2d2d2d))
// quit_next=2;
}
#endif
}
/* Actually try to open the event */
fd=perf_event_open(
&event_data[i].attr,
event_data[i].pid,
event_data[i].cpu,
event_data[i].group_fd,
event_data[i].flags);
stats.open_attempts++;
stats.total_syscalls++;
int which_type=event_data[i].attr.type;
if ((which_type<0) || (which_type>MAX_OPEN_TYPE-1)) {
which_type=MAX_OPEN_TYPE-1;
}
/* If we succede, break out of the infinite loop */
if (fd>0) {
stats.open_type_success[which_type]++;
stats.open_trinity_type_success[trinity_type]++;
break;
}
#if 0
/* Track source of UNKNOWN errnos */
if (errno==16) {
printf("Event t=%d c=%llx pid=%d cpu=%d %s\n",
event_data[i].attr.type,
event_data[i].attr.config,
event_data[i].pid,
event_data[i].cpu,
strerror(errno));
}
#endif
/* Otherwise, track the errors */
if (errno<MAX_ERRNOS) {
stats.open_errno_count[errno]++;
stats.open_type_fail[which_type]++;
stats.open_trinity_type_fail[trinity_type]++;
}
/* no more file descriptors, so give up */
if (errno==EMFILE) return;
}
/* We successfully opened an event! */
stats.open_successful++;
stats.current_open++;
if (logging&TYPE_OPEN) {
sprintf(log_buffer,"O %d %d %d %d %lx ",
fd,
event_data[i].pid,
event_data[i].cpu,
event_data[i].group_fd,
event_data[i].flags);
write(log_fd,log_buffer,strlen(log_buffer));
perf_log_attr(&event_data[i].attr);
#if FSYNC_EVERY
fsync(log_fd);
#endif
}
event_data[i].fd=fd;
event_data[i].active=1;
active_events++;
/* if we are member of a group, update size of group */
/* this is needed for calcuating "proper" read size */
/* Also I don't think we adjust this on close */
if (event_data[i].group_fd!=-1) {
int j=lookup_event(event_data[i].group_fd);
event_data[j].number_in_group++;
event_data[j].read_size=update_read_size(j);
}
/* Setup mmap buffer */
if (mmap_enabled) {
setup_mmap(i);
}
/* Setup overflow 50% of the time */
if ((overflow_enabled) && (rand()%2)) {
if (!ignore_but_dont_skip.overflow) {
int fcntl_result;
if (logging&TYPE_OVERFLOW) {
sprintf(log_buffer,"o %d\n",event_data[i].fd);
write(log_fd,log_buffer,strlen(log_buffer));
}
memset(&event_data[i].sa, 0, sizeof(struct sigaction));
event_data[i].sa.sa_sigaction = our_handler;
event_data[i].sa.sa_flags = SA_SIGINFO;
if (sigaction( SIGRTMIN+2, &event_data[i].sa, NULL) < 0) {
printf("Error setting up signal handler\n");
}
fcntl_result=fcntl(event_data[i].fd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC);
if (fcntl_result<0) fprintf(stderr,"F1 error!\n");
fcntl_result=fcntl(event_data[i].fd, F_SETSIG, SIGRTMIN+2);
if (fcntl_result<0) fprintf(stderr,"F1 error!\n");
fcntl_result=fcntl(event_data[i].fd, F_SETOWN,getpid());
if (fcntl_result<0) fprintf(stderr,"F1 error!\n");
}
}
event_data[i].number_in_group=1;
event_data[i].read_size=update_read_size(i);
}
