static void parse_observed_event(struct mgcp_proto_info *info, struct liner *liner)
{
size_t len = strlen(info->dialed);
struct liner tokenizer;
for (
liner_init(&tokenizer, ¶m_delims, liner->start, liner_tok_length(liner));
! liner_eof(&tokenizer);
liner_next(&tokenizer)
) {
unsigned events = parse_events(&tokenizer);
if (events) {
info->observed |= events;
continue;
}
if (liner_tok_length(&tokenizer) < 3) continue;
if (tokenizer.start[0] != 'D' && tokenizer.start[0] != 'd') continue;
if (tokenizer.start[1] != '/') continue;
// append dialed 'digit' into dialed info
for (unsigned d = 2; d < liner_tok_length(&tokenizer); d++) {
if (len >= sizeof(info->dialed)-1) break;
char const c = tokenizer.start[d];
if (c != 'T' && c != 't') info->dialed[len++] = c;
}
}
assert(len < sizeof(info->dialed));
info->dialed[len] = '\0';
}
static int __perf_evsel__name_array_test(const char *names[], int nr_names)
{
int i, err;
struct perf_evsel *evsel;
struct perf_evlist *evlist = perf_evlist__new();
if (evlist == NULL)
return -ENOMEM;
for (i = 0; i < nr_names; ++i) {
err = parse_events(evlist, names[i]);
if (err) {
pr_debug("failed to parse event '%s', err %d\n",
names[i], err);
goto out_delete_evlist;
}
}
err = 0;
evlist__for_each(evlist, evsel) {
if (strcmp(perf_evsel__name(evsel), names[evsel->idx])) {
--err;
pr_debug("%s != %s\n", perf_evsel__name(evsel), names[evsel->idx]);
}
}
out_delete_evlist:
perf_evlist__delete(evlist);
return err;
}
static void do_test(struct allocated_counter const * it)
{
size_t i;
size_t * counter_map;
size_t nr_events;
struct parsed_event parsed[MAX_EVENTS];
struct op_event const * event[MAX_EVENTS];
op_events(it->cpu_type);
nr_events = parse_events(parsed, MAX_EVENTS, it->events);
for (i = 0; i < nr_events; ++i) {
event[i] = find_event_by_name(parsed[i].name, parsed[i].unit_mask,
parsed[i].unit_mask_valid);
if (!event[i]) {
if (it->failure == fail_to_find_event)
goto free_events;
printf("Can't find events %s for cpu %s\n",
parsed[i].name,
op_get_cpu_type_str(it->cpu_type));
exit(EXIT_FAILURE);
}
}
counter_map = map_event_to_counter(event, nr_events, it->cpu_type);
if (!counter_map) {
if (it->failure == fail_to_alloc_counter)
goto free_events;
printf("Can't map this set of events to counter:\n");
show_events(it->events);
exit(EXIT_FAILURE);
}
for (i = 0; i < nr_events; ++i) {
if (counter_map[i] != it->alloc_map[i]) {
printf("Incorrect allocation map for these events:\n");
show_events(it->events);
printf("(expect, found):\n");
show_counter_map(it->alloc_map, nr_events);
show_counter_map(counter_map, nr_events);
exit(EXIT_FAILURE);
}
}
if (it->failure != no_failure) {
/* test should fail but success! */
printf("test should fail with a failure type %d but succeed "
"for events:\n", it->failure);
for (i = 0; i < nr_events; ++i)
printf("%s\n", it->events[i]);
exit(EXIT_FAILURE);
}
free(counter_map);
free_events:
op_free_events();
}
static int perf_evsel__roundtrip_cache_name_test(void)
{
char name[128];
int type, op, err = 0, ret = 0, i, idx;
struct perf_evsel *evsel;
struct perf_evlist *evlist = perf_evlist__new();
if (evlist == NULL)
return -ENOMEM;
for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
/* skip invalid cache type */
if (!perf_evsel__is_cache_op_valid(type, op))
continue;
for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
__perf_evsel__hw_cache_type_op_res_name(type, op, i,
name, sizeof(name));
err = parse_events(evlist, name);
if (err)
ret = err;
}
}
}
idx = 0;
evsel = perf_evlist__first(evlist);
for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
/* skip invalid cache type */
if (!perf_evsel__is_cache_op_valid(type, op))
continue;
for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
__perf_evsel__hw_cache_type_op_res_name(type, op, i,
name, sizeof(name));
if (evsel->idx != idx)
continue;
++idx;
if (strcmp(perf_evsel__name(evsel), name)) {
pr_debug("%s != %s\n", perf_evsel__name(evsel), name);
ret = -1;
}
evsel = perf_evsel__next(evsel);
}
}
}
perf_evlist__delete(evlist);
return ret;
}
static int do_reload(void)
{
struct ast_config *config;
const char *enabled_value;
const char *val;
int res = 0;
struct ast_flags config_flags = { 0, };
const char *s;
ast_mutex_lock(&reload_lock);
/* Reset all settings before reloading configuration */
cel_enabled = CEL_ENALBED_DEFAULT;
eventset = CEL_DEFAULT_EVENTS;
*cel_dateformat = '\0';
ao2_callback(appset, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL);
config = ast_config_load2("cel.conf", "cel", config_flags);
if (config == CONFIG_STATUS_FILEMISSING) {
config = NULL;
goto return_cleanup;
}
if ((enabled_value = ast_variable_retrieve(config, "general", "enable"))) {
cel_enabled = ast_true(enabled_value);
}
if (!cel_enabled) {
goto return_cleanup;
}
/* get the date format for logging */
if ((s = ast_variable_retrieve(config, "general", "dateformat"))) {
ast_copy_string(cel_dateformat, s, sizeof(cel_dateformat));
}
if ((val = ast_variable_retrieve(config, "general", "events"))) {
parse_events(val);
}
if ((val = ast_variable_retrieve(config, "general", "apps"))) {
parse_apps(val);
}
return_cleanup:
ast_verb(3, "CEL logging %sabled.\n", cel_enabled ? "en" : "dis");
ast_mutex_unlock(&reload_lock);
if (config) {
ast_config_destroy(config);
}
return res;
}
static void parse_signal_request(struct mgcp_proto_info *info, struct liner *liner)
{
struct liner tokenizer;
for (
liner_init(&tokenizer, ¶m_delims, liner->start, liner_tok_length(liner));
! liner_eof(&tokenizer);
liner_next(&tokenizer)
) {
info->signaled |= parse_events(&tokenizer);
}
}
int main(int argc, char **argv)
{
char data[4];
int i, res= 0;
printf("\n"
"****************************************************************\n"
"*** NOTE: ***\n"
"*** the HAL must be compiled with Low power quaternion ***\n"
"*** and/or DMP screen orientation support. ***\n"
"*** 'At least' one of the 4 Android virtual sensors ***\n"
"*** must be enabled. ***\n"
"*** ***\n"
"*** Please perform gestures to see the output. ***\n"
"*** Press any key to stop the program. ***\n"
"****************************************************************\n"
"\n");
res = inv_init_sysfs_attributes();
if (res) {
printf("GT:ERR-Can't allocate mem\n");
return -1;
}
/* init Fds to poll for gesture data */
init_fds();
/* on Gesture/DMP supported features */
if (enable_dmp_features(1) < 0) {
printf("GT:ERR-Can't enable Gestures\n");
return -1;
}
do {
for (i = 0; i < NUM_DMP_FEATS; i++)
read(pfd[i].fd, data, 4);
poll(pfd, NUM_DMP_FEATS, POLL_TIME);
parse_events(pfd, NUM_DMP_FEATS);
} while (!_kbhit());
/* off Gesture/DMP supported features */
if (enable_dmp_features(0) < 0) {
printf("GT:ERR-Can't disable Gestures\n");
return -1;
}
/* release resources */
close_fds();
if (sysfs_names_ptr)
free(sysfs_names_ptr);
return res;
}
void emu_run(){
while(emu_running){
wait_for_frame();
int scanlines = 262;
while(scanlines-- > 0){
ppu_run(1);
cpu_exec(&cpu,1364/12);
}
parse_events();
}
}
static void resolve_events(void)
{
size_t count;
size_t i, j;
size_t * counter_map;
size_t nr_counters = op_get_nr_counters(cpu_type);
struct op_event const * selected_events[nr_counters];
count = parse_events(parsed_events, nr_counters, chosen_events);
if (count > nr_counters) {
fprintf(stderr, "Not enough hardware counters.\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < count; ++i) {
for (j = i + 1; j < count; ++j) {
struct parsed_event * pev1 = &parsed_events[i];
struct parsed_event * pev2 = &parsed_events[j];
if (!strcmp(pev1->name, pev2->name) &&
pev1->count == pev2->count &&
pev1->unit_mask == pev2->unit_mask &&
pev1->kernel == pev2->kernel &&
pev1->user == pev2->user) {
fprintf(stderr, "All events must be distinct.\n");
exit(EXIT_FAILURE);
}
}
}
for (i = 0; i < count; ++i) {
struct parsed_event * pev = &parsed_events[i];
selected_events[i] = find_event_by_name(pev->name);
check_event(pev, selected_events[i]);
}
counter_map = map_event_to_counter(selected_events, count, cpu_type);
if (!counter_map) {
fprintf(stderr, "Couldn't allocate hardware counters for the selected events.\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < count; ++i) {
printf("%d ", (unsigned int) counter_map[i]);
}
printf("\n");
free(counter_map);
}
static void show_extra_mask(void)
{
size_t count;
unsigned extra = 0;
count = parse_events(parsed_events, num_chosen_events, chosen_events, ignore_count ? 0 : 1);
if (count > 1) {
fprintf(stderr, "More than one event specified.\n");
exit(EXIT_FAILURE);
}
op_resolve_unit_mask(parsed_events, &extra);
printf ("%d\n", extra);
}
static void show_unit_mask(void)
{
size_t count;
count = parse_events(parsed_events, num_chosen_events, chosen_events, ignore_count ? 0 : 1);
if (count > 1) {
fprintf(stderr, "More than one event specified.\n");
exit(EXIT_FAILURE);
}
op_resolve_unit_mask(parsed_events, NULL);
if (parsed_events[0].unit_mask_name)
printf("%s\n", parsed_events[0].unit_mask_name);
else
printf("%d\n", parsed_events[0].unit_mask);
}
static void show_unit_mask(void)
{
struct op_event * event;
size_t count;
size_t nr_counter = op_get_nr_counters(cpu_type);
count = parse_events(parsed_events, nr_counter, chosen_events);
if (count > 1) {
fprintf(stderr, "More than one event specified.\n");
exit(EXIT_FAILURE);
}
event = find_event_by_name(parsed_events[0].name);
if (!event) {
fprintf(stderr, "No such event found.\n");
exit(EXIT_FAILURE);
}
printf("%d\n", event->unit->default_mask);
}
void main_loop(int fd_shutter) {
int counter = 0;
char image_destination[MAX_STRING];
char buffer[EVENT_BUFFER_SIZE];
while (1) {
int i;
fd_set fds;
FD_ZERO(&fds);
FD_SET(fd_shutter, &fds);
if (select(fd_shutter + 1, &fds, 0, 0, 0) == 1) {
int received = read(fd_shutter, buffer, EVENT_BUFFER_SIZE);
#ifdef HANDLE_SHUTTER
if (parse_events(buffer, received)) {
printf("Shutter pressed\n");
//take_shot();
printf("Pause video\n");
gst_element_set_state(video_pipeline, GST_STATE_PAUSED);
gst_element_set_state(video_pipeline, GST_STATE_NULL);
printf("Capture image\n");
gst_element_set_state(image_pipeline, GST_STATE_PLAYING);
gst_element_get_state(image_pipeline, NULL, NULL, GST_TRANSITION_TIMEOUT_NS);
gst_element_set_state(image_pipeline, GST_STATE_PAUSED);
gst_element_get_state (image_pipeline, NULL, NULL, GST_TRANSITION_TIMEOUT_NS);
gst_element_set_state(image_pipeline, GST_STATE_NULL);
printf("Resume video\n");
gst_element_set_state(video_pipeline, GST_STATE_PLAYING);
sprintf(image_destination, "img%04d.jpeg", counter++);
cp(image_destination, "output.jpeg");
}
#endif
}
}
}
int main(int argc, char **argv)
{
XMLParserContext *h;
int i;
if(argc != 3)
{
printf("error input args\n");
system("pause");
return 0;
}
h = read_XML_file(argv[1]);
for(i = 0; i < h->i_count_data_sets; i++)
{
parse_events(h, i);
post_process(h, i);
}
release_XML_file(h, argv[2]);
system("pause");
return 0;
}
static void resolve_events(void)
{
size_t count, count_events;
size_t i, j;
size_t * counter_map;
size_t nr_counters = op_get_nr_counters(cpu_type);
struct op_event const * selected_events[num_chosen_events];
count = parse_events(parsed_events, num_chosen_events, chosen_events,
ignore_count ? 0 : 1);
for (i = 0; i < count; ++i) {
op_resolve_unit_mask(&parsed_events[i], NULL);
for (j = i + 1; j < count; ++j) {
struct parsed_event * pev1 = &parsed_events[i];
struct parsed_event * pev2 = &parsed_events[j];
if (!strcmp(pev1->name, pev2->name) &&
pev1->count == pev2->count &&
pev1->unit_mask == pev2->unit_mask &&
pev1->kernel == pev2->kernel &&
pev1->user == pev2->user) {
fprintf(stderr, "All events must be distinct.\n");
exit(EXIT_FAILURE);
}
}
}
for (i = 0, count_events = 0; i < count; ++i) {
struct parsed_event * pev = &parsed_events[i];
/* For 0 unit mask always do wild card match */
selected_events[i] = find_event_by_name(pev->name, pev->unit_mask,
pev->unit_mask ? pev->unit_mask_valid : 0);
check_event(pev, selected_events[i]);
if (selected_events[i]->ext == NULL) {
count_events++;
}
}
if (count_events > nr_counters) {
fprintf(stderr, "Not enough hardware counters. "
"Need %lu counters but only has %lu.\n",
(unsigned long) count_events,
(unsigned long) nr_counters);
exit(EXIT_FAILURE);
}
counter_map = map_event_to_counter(selected_events, count, cpu_type);
if (!counter_map) {
fprintf(stderr, "Couldn't allocate hardware counters for the selected events.\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < count; ++i)
if(counter_map[i] == (size_t)-1)
if (selected_events[i]->ext != NULL)
printf("%s ", (char*) selected_events[i]->ext);
else
printf("N/A ");
else
if (strcmp(selected_events[i]->name, TIMER_EVENT_NAME) == 0)
printf("timer ");
else
printf("%d ", (unsigned int) counter_map[i]);
printf("\n");
free(counter_map);
}
/*
* receive notifications from kernel through rtnetlink socket
*/
int recv_events(int sock)
{
struct msghdr msg;
struct iovec iov;
struct sockaddr_nl nla;
char buf[8192];
int err, buflen;
int len = sizeof(buflen);
/* logging a receive buffer size */
err = getsockopt(sock, SOL_SOCKET, SO_RCVBUF, &buflen, (socklen_t *)&len);
if(err < 0) {
rec_log("error: %s: getsockopt(): %s", __func__, strerror(errno));
exit(1);
}
rec_log("info: socket receive buffer size: %d byte", buflen);
/* initialization */
memset(&msg, 0, sizeof(msg));
memset(&iov, 0, sizeof(iov));
memset(&nla, 0, sizeof(nla));
memset(buf, 0, sizeof(buf));
/* set message header */
iov.iov_base = buf;
iov.iov_len = sizeof(buf);
msg.msg_name = (void *)&nla;
msg.msg_namelen = sizeof(nla);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
/* loop of receive event */
while(1) {
/* detect signal received */
if(sigterm_received || sigint_received)
break;
/* clear buffer */
memset(buf, 0, sizeof(buf));
/* receive event */
len = recvmsg(sock, &msg, 0);
if(len < 0) {
rec_log("error: %s: recvmsg(): %s", __func__, strerror(errno));
if(errno == EINTR || errno == EAGAIN ||
errno == ENOBUFS || errno == ENOMEM)
continue;
return(1);
} else if(!len) {
rec_log("error: %s: recvmsg(): receive EOF", __func__);
return(1);
}
/* verify whether a message originates from kernel */
if(nla.nl_pid) {
rec_log("error: %s: received a message from invalid sender(%d)",
__func__, nla.nl_pid);
continue;
}
/* parse messages */
err = parse_events(&msg);
if(err < 0)
break;
}
return(0);
}
int main ( int argc, char ** argv )
{
int i, j;
int sockint, sockctl; // For the listening sockets
struct sockaddr_l2 l2a;
socklen_t alen=sizeof(l2a);
int sint, sctl; // For the one-session-only
// socket descriptor handles
char badr[40];
fd_set fds; // fds for listening sockets
fd_set efds; // dev-event file descriptors
int maxevdevfileno;
char skipsdp = 0; // On request, disable SDPreg
struct timeval tv; // Used for "select"
int evdevmask = 0;// If restricted to using only one evdev
int mutex11 = 0; // try to "mute" in x11?
char *fifoname = NULL; // Filename for fifo, if applicable
// Parse command line
for ( i = 1; i < argc; ++i )
{
if ( ( 0 == strcmp ( argv[i], "-h" ) ) ||
( 0 == strcmp ( argv[i], "-?" ) ) ||
( 0 == strcmp ( argv[i], "--help" ) ) )
{
showhelp();
return 0;
}
else if ( ( 0 == strcmp ( argv[i], "-s" ) ) ||
( 0 == strcmp ( argv[i], "--skipsdp" ) ) )
{
skipsdp = 1;
}
else if ( 0 == strncmp ( argv[i], "-e", 2 ) ) {
evdevmask |= 1 << atoi(argv[i]+2);
}
else if ( 0 == strcmp ( argv[i], "-l" ) )
{
return list_input_devices();
}
else if ( 0 == strcmp ( argv[i], "-d" ) )
{
debugevents = 0xffff;
}
else if ( 0 == strcmp ( argv[i], "-x" ) )
{
mutex11 = 1;
}
else if ( 0 == strncmp ( argv[i], "-f", 2 ) )
{
fifoname = argv[i] + 2;
}
else
{
fprintf ( stderr, "Invalid argument: \'%s\'\n", argv[i]);
return 1;
}
}
if ( ! skipsdp )
{
if ( dosdpregistration() )
{
fprintf(stderr,"Failed to register with SDP server\n");
return 1;
}
}
if ( NULL == fifoname )
{
if ( 1 > initevents (evdevmask, mutex11) )
{
fprintf ( stderr, "Failed to open event interface files\n" );
return 2;
}
} else {
if ( 1 > initfifo ( fifoname ) )
{
fprintf ( stderr, "Failed to create/open fifo [%s]\n", fifoname );
return 2;
}
}
maxevdevfileno = add_filedescriptors ( &efds );
if ( maxevdevfileno <= 0 )
{
fprintf ( stderr, "Failed to organize event input.\n" );
return 13;
}
sockint = socket ( AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP );
sockctl = socket ( AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP );
if ( ( 0 > sockint ) || ( 0 > sockctl ) )
{
fprintf ( stderr, "Failed to generate bluetooth sockets\n" );
return 2;
}
if ( btbind ( sockint, PSMHIDINT ) || btbind ( sockctl, PSMHIDCTL ))
{
fprintf ( stderr, "Failed to bind sockets (%d/%d) "
"to PSM (%d/%d)\n",
sockctl, sockint, PSMHIDCTL, PSMHIDINT );
return 3;
}
if ( listen ( sockint, 1 ) || listen ( sockctl, 1 ) )
{
fprintf ( stderr, "Failed to listen on int/ctl BT socket\n" );
close ( sockint );
close ( sockctl );
return 4;
}
// Add handlers to catch signals:
// All do the same, terminate the program safely
// Ctrl+C will be ignored though (SIGINT) while a connection is active
signal ( SIGHUP, &onsignal );
signal ( SIGTERM, &onsignal );
signal ( SIGINT, &onsignal );
fprintf ( stdout, "The HID-Client is now ready to accept connections "
"from another machine\n" );
//i = system ( "stty -echo" ); // Disable key echo to the console
while ( 0 == prepareshutdown )
{ // Wait for any shutdown-event to occur
sint = sctl = 0;
add_filedescriptors ( &efds );
tv.tv_sec = 0;
tv.tv_usec = 0;
while ( 0 < (j = select(maxevdevfileno+1,&efds,NULL,NULL,&tv)))
{ // Collect and discard input data as long as available
if ( -1 > ( j = parse_events ( &efds, 0 ) ) )
{ // LCtrl-LAlt-PAUSE - terminate program
prepareshutdown = 1;
break;
}
add_filedescriptors ( &efds );
tv.tv_sec = 0;
tv.tv_usec = 500; // minimal delay
}
if ( prepareshutdown )
break;
connectionok = 0;
tv.tv_sec = 1;
tv.tv_usec = 0;
FD_ZERO ( &fds );
FD_SET ( sockctl, &fds );
j = select ( sockctl + 1, &fds, NULL, NULL, &tv );
if ( j < 0 )
{
if ( errno == EINTR )
{ // Ctrl+C ? - handle that elsewhere
continue;
}
fprintf ( stderr, "select() error on BT socket: %s! "
"Aborting.\n", strerror ( errno ) );
return 11;
}
if ( j == 0 )
{ // Nothing happened, check for shutdown req and retry
if ( debugevents & 0x2 )
fprintf ( stdout, "," );
continue;
}
sctl = accept ( sockctl, (struct sockaddr *)&l2a, &alen );
if ( sctl < 0 )
{
if ( errno == EAGAIN )
{
continue;
}
fprintf ( stderr, "Failed to get a control connection:"
" %s\n", strerror ( errno ) );
continue;
}
tv.tv_sec = 3;
tv.tv_usec = 0;
FD_ZERO ( &fds );
FD_SET ( sockint, &fds );
j = select ( sockint + 1, &fds, NULL, NULL, &tv );
if ( j < 0 )
{
if ( errno == EINTR )
{ // Might have been Ctrl+C
close ( sctl );
continue;
}
fprintf ( stderr, "select() error on BT socket: %s! "
"Aborting.\n", strerror ( errno ) );
return 12;
}
if ( j == 0 )
{
fprintf ( stderr, "Interrupt connection failed to "
"establish (control connection already"
" there), timeout!\n" );
close ( sctl );
continue;
}
sint = accept ( sockint, (struct sockaddr *)&l2a, &alen );
if ( sint < 0 )
{
close ( sctl );
if ( errno == EAGAIN )
continue;
fprintf ( stderr, "Failed to get an interrupt "
"connection: %s\n", strerror(errno));
continue;
}
ba2str ( &l2a.l2_bdaddr, badr );
badr[39] = 0;
fprintf ( stdout, "Incoming connection from node [%s] "
"accepted and established.\n", badr );
tv.tv_sec = 0;
tv.tv_usec = 0;
j = -1;
add_filedescriptors ( &efds );
while ( 0 < (j = select(maxevdevfileno+1,&efds,NULL,NULL,&tv)))
{
// This loop removes all input garbage that might be
// already in the queue
if ( -1 > ( j = parse_events ( &efds, 0 ) ) )
{ // LCtrl-LAlt-PAUSE - terminate program
prepareshutdown = 1;
break;
}
add_filedescriptors ( &efds );
tv.tv_sec = 0;
tv.tv_usec = 0;
}
if ( prepareshutdown )
break;
connectionok = 1;
memset ( pressedkey, 0, 8 );
modifierkeys = 0;
mousebuttons = 0;
while ( connectionok )
{
add_filedescriptors ( &efds );
tv.tv_sec = 1;
tv.tv_usec = 0;
while ( 0 < ( j = select ( maxevdevfileno + 1, &efds,
NULL, NULL, &tv ) ) )
{
if ( 0 > ( j = parse_events ( &efds, sint ) ) )
{
// PAUSE pressed - close connection
connectionok = 0;
if ( j < -1 )
{ // LCtrl-LAlt-PAUSE - terminate
close ( sint );
close ( sctl );
prepareshutdown = 1;
}
break;
}
add_filedescriptors ( &efds );
tv.tv_sec = 1;
tv.tv_usec = 0;
}
}
connectionok = 0;
close ( sint );
close ( sctl );
sint = sctl = 0;
fprintf ( stderr, "Connection closed\n" );
usleep ( 500000 ); // Sleep 0.5 secs between connections
// to not be flooded
}
//i = system ( "stty echo" ); // Set console back to normal
close ( sockint );
close ( sockctl );
if ( ! skipsdp )
{
sdpunregister ( sdphandle ); // Remove HID info from SDP server
}
if ( NULL == fifoname )
{
closeevents ();
} else {
closefifo ();
}
cleanup_stdin (); // And remove the input queue from stdin
fprintf ( stderr, "Stopped hidclient.\n" );
return 0;
}
static int do_test_code_reading(bool try_kcore)
{
struct machines machines;
struct machine *machine;
struct thread *thread;
struct record_opts opts = {
.mmap_pages = UINT_MAX,
.user_freq = UINT_MAX,
.user_interval = ULLONG_MAX,
.freq = 4000,
.target = {
.uses_mmap = true,
},
};
struct state state = {
.done_cnt = 0,
};
struct thread_map *threads = NULL;
struct cpu_map *cpus = NULL;
struct perf_evlist *evlist = NULL;
struct perf_evsel *evsel = NULL;
int err = -1, ret;
pid_t pid;
struct map *map;
bool have_vmlinux, have_kcore, excl_kernel = false;
pid = getpid();
machines__init(&machines);
machine = &machines.host;
ret = machine__create_kernel_maps(machine);
if (ret < 0) {
pr_debug("machine__create_kernel_maps failed\n");
goto out_err;
}
/* Force the use of kallsyms instead of vmlinux to try kcore */
if (try_kcore)
symbol_conf.kallsyms_name = "/proc/kallsyms";
/* Load kernel map */
map = machine->vmlinux_maps[MAP__FUNCTION];
ret = map__load(map, NULL);
if (ret < 0) {
pr_debug("map__load failed\n");
goto out_err;
}
have_vmlinux = dso__is_vmlinux(map->dso);
have_kcore = dso__is_kcore(map->dso);
/* 2nd time through we just try kcore */
if (try_kcore && !have_kcore)
return TEST_CODE_READING_NO_KCORE;
/* No point getting kernel events if there is no kernel object */
if (!have_vmlinux && !have_kcore)
excl_kernel = true;
threads = thread_map__new_by_tid(pid);
if (!threads) {
pr_debug("thread_map__new_by_tid failed\n");
goto out_err;
}
ret = perf_event__synthesize_thread_map(NULL, threads,
perf_event__process, machine, false);
if (ret < 0) {
pr_debug("perf_event__synthesize_thread_map failed\n");
goto out_err;
}
thread = machine__findnew_thread(machine, pid, pid);
if (!thread) {
pr_debug("machine__findnew_thread failed\n");
goto out_err;
}
cpus = cpu_map__new(NULL);
if (!cpus) {
pr_debug("cpu_map__new failed\n");
goto out_err;
}
while (1) {
const char *str;
evlist = perf_evlist__new();
if (!evlist) {
pr_debug("perf_evlist__new failed\n");
goto out_err;
}
perf_evlist__set_maps(evlist, cpus, threads);
if (excl_kernel)
str = "cycles:u";
else
str = "cycles";
pr_debug("Parsing event '%s'\n", str);
ret = parse_events(evlist, str);
if (ret < 0) {
pr_debug("parse_events failed\n");
goto out_err;
}
perf_evlist__config(evlist, &opts);
evsel = perf_evlist__first(evlist);
evsel->attr.comm = 1;
evsel->attr.disabled = 1;
evsel->attr.enable_on_exec = 0;
ret = perf_evlist__open(evlist);
if (ret < 0) {
if (!excl_kernel) {
excl_kernel = true;
perf_evlist__set_maps(evlist, NULL, NULL);
perf_evlist__delete(evlist);
evlist = NULL;
continue;
}
pr_debug("perf_evlist__open failed\n");
goto out_err;
}
break;
}
ret = perf_evlist__mmap(evlist, UINT_MAX, false);
if (ret < 0) {
pr_debug("perf_evlist__mmap failed\n");
goto out_err;
}
perf_evlist__enable(evlist);
do_something();
perf_evlist__disable(evlist);
ret = process_events(machine, evlist, &state);
if (ret < 0)
goto out_err;
if (!have_vmlinux && !have_kcore && !try_kcore)
err = TEST_CODE_READING_NO_KERNEL_OBJ;
else if (!have_vmlinux && !try_kcore)
err = TEST_CODE_READING_NO_VMLINUX;
else if (excl_kernel)
err = TEST_CODE_READING_NO_ACCESS;
else
err = TEST_CODE_READING_OK;
out_err:
if (evlist) {
perf_evlist__delete(evlist);
} else {
cpu_map__delete(cpus);
thread_map__delete(threads);
}
machines__destroy_kernel_maps(&machines);
machine__delete_threads(machine);
machines__exit(&machines);
return err;
}
int test__code_reading(void)
{
int ret;
ret = do_test_code_reading(false);
if (!ret)
ret = do_test_code_reading(true);
switch (ret) {
case TEST_CODE_READING_OK:
return 0;
case TEST_CODE_READING_NO_VMLINUX:
fprintf(stderr, " (no vmlinux)");
return 0;
case TEST_CODE_READING_NO_KCORE:
fprintf(stderr, " (no kcore)");
return 0;
case TEST_CODE_READING_NO_ACCESS:
fprintf(stderr, " (no access)");
return 0;
case TEST_CODE_READING_NO_KERNEL_OBJ:
fprintf(stderr, " (no kernel obj)");
return 0;
default:
return -1;
};
}
static int do_test_code_reading(bool try_kcore)
{
struct machine *machine;
struct thread *thread;
struct record_opts opts = {
.mmap_pages = UINT_MAX,
.user_freq = UINT_MAX,
.user_interval = ULLONG_MAX,
.freq = 500,
.target = {
.uses_mmap = true,
},
};
struct state state = {
.done_cnt = 0,
};
struct thread_map *threads = NULL;
struct cpu_map *cpus = NULL;
struct perf_evlist *evlist = NULL;
struct perf_evsel *evsel = NULL;
int err = -1, ret;
pid_t pid;
struct map *map;
bool have_vmlinux, have_kcore, excl_kernel = false;
pid = getpid();
machine = machine__new_host();
ret = machine__create_kernel_maps(machine);
if (ret < 0) {
pr_debug("machine__create_kernel_maps failed\n");
goto out_err;
}
/* Force the use of kallsyms instead of vmlinux to try kcore */
if (try_kcore)
symbol_conf.kallsyms_name = "/proc/kallsyms";
/* Load kernel map */
map = machine__kernel_map(machine);
ret = map__load(map, NULL);
if (ret < 0) {
pr_debug("map__load failed\n");
goto out_err;
}
have_vmlinux = dso__is_vmlinux(map->dso);
have_kcore = dso__is_kcore(map->dso);
/* 2nd time through we just try kcore */
if (try_kcore && !have_kcore)
return TEST_CODE_READING_NO_KCORE;
/* No point getting kernel events if there is no kernel object */
if (!have_vmlinux && !have_kcore)
excl_kernel = true;
threads = thread_map__new_by_tid(pid);
if (!threads) {
pr_debug("thread_map__new_by_tid failed\n");
goto out_err;
}
ret = perf_event__synthesize_thread_map(NULL, threads,
perf_event__process, machine, false, 500);
if (ret < 0) {
pr_debug("perf_event__synthesize_thread_map failed\n");
goto out_err;
}
thread = machine__findnew_thread(machine, pid, pid);
if (!thread) {
pr_debug("machine__findnew_thread failed\n");
goto out_put;
}
cpus = cpu_map__new(NULL);
if (!cpus) {
pr_debug("cpu_map__new failed\n");
goto out_put;
}
while (1) {
const char *str;
evlist = perf_evlist__new();
if (!evlist) {
pr_debug("perf_evlist__new failed\n");
goto out_put;
}
perf_evlist__set_maps(evlist, cpus, threads);
if (excl_kernel)
str = "cycles:u";
else
str = "cycles";
pr_debug("Parsing event '%s'\n", str);
ret = parse_events(evlist, str, NULL);
if (ret < 0) {
pr_debug("parse_events failed\n");
goto out_put;
}
perf_evlist__config(evlist, &opts);
evsel = perf_evlist__first(evlist);
evsel->attr.comm = 1;
evsel->attr.disabled = 1;
evsel->attr.enable_on_exec = 0;
ret = perf_evlist__open(evlist);
if (ret < 0) {
if (!excl_kernel) {
excl_kernel = true;
/*
* Both cpus and threads are now owned by evlist
* and will be freed by following perf_evlist__set_maps
* call. Getting refference to keep them alive.
*/
cpu_map__get(cpus);
thread_map__get(threads);
perf_evlist__set_maps(evlist, NULL, NULL);
perf_evlist__delete(evlist);
evlist = NULL;
continue;
}
if (verbose) {
char errbuf[512];
perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
pr_debug("perf_evlist__open() failed!\n%s\n", errbuf);
}
goto out_put;
}
break;
}
ret = perf_evlist__mmap(evlist, UINT_MAX, false);
if (ret < 0) {
pr_debug("perf_evlist__mmap failed\n");
goto out_put;
}
perf_evlist__enable(evlist);
do_something();
perf_evlist__disable(evlist);
ret = process_events(machine, evlist, &state);
if (ret < 0)
goto out_put;
if (!have_vmlinux && !have_kcore && !try_kcore)
err = TEST_CODE_READING_NO_KERNEL_OBJ;
else if (!have_vmlinux && !try_kcore)
err = TEST_CODE_READING_NO_VMLINUX;
else if (excl_kernel)
err = TEST_CODE_READING_NO_ACCESS;
else
err = TEST_CODE_READING_OK;
out_put:
thread__put(thread);
out_err:
if (evlist) {
perf_evlist__delete(evlist);
} else {
cpu_map__put(cpus);
thread_map__put(threads);
}
machine__delete_threads(machine);
machine__delete(machine);
return err;
}
int test__code_reading(int subtest __maybe_unused)
{
int ret;
ret = do_test_code_reading(false);
if (!ret)
ret = do_test_code_reading(true);
switch (ret) {
case TEST_CODE_READING_OK:
return 0;
case TEST_CODE_READING_NO_VMLINUX:
pr_debug("no vmlinux\n");
return 0;
case TEST_CODE_READING_NO_KCORE:
pr_debug("no kcore\n");
return 0;
case TEST_CODE_READING_NO_ACCESS:
pr_debug("no access\n");
return 0;
case TEST_CODE_READING_NO_KERNEL_OBJ:
pr_debug("no kernel obj\n");
return 0;
default:
return -1;
};
}
/**
* test__perf_time_to_tsc - test converting perf time to TSC.
*
* This function implements a test that checks that the conversion of perf time
* to and from TSC is consistent with the order of events. If the test passes
* %0 is returned, otherwise %-1 is returned. If TSC conversion is not
* supported then then the test passes but " (not supported)" is printed.
*/
int test__perf_time_to_tsc(void)
{
struct record_opts opts = {
.mmap_pages = UINT_MAX,
.user_freq = UINT_MAX,
.user_interval = ULLONG_MAX,
.freq = 4000,
.target = {
.uses_mmap = true,
},
.sample_time = true,
};
struct thread_map *threads = NULL;
struct cpu_map *cpus = NULL;
struct perf_evlist *evlist = NULL;
struct perf_evsel *evsel = NULL;
int err = -1, ret, i;
const char *comm1, *comm2;
struct perf_tsc_conversion tc;
struct perf_event_mmap_page *pc;
union perf_event *event;
u64 test_tsc, comm1_tsc, comm2_tsc;
u64 test_time, comm1_time = 0, comm2_time = 0;
threads = thread_map__new(-1, getpid(), UINT_MAX);
CHECK_NOT_NULL__(threads);
cpus = cpu_map__new(NULL);
CHECK_NOT_NULL__(cpus);
evlist = perf_evlist__new();
CHECK_NOT_NULL__(evlist);
perf_evlist__set_maps(evlist, cpus, threads);
CHECK__(parse_events(evlist, "cycles:u", NULL));
perf_evlist__config(evlist, &opts);
evsel = perf_evlist__first(evlist);
evsel->attr.comm = 1;
evsel->attr.disabled = 1;
evsel->attr.enable_on_exec = 0;
CHECK__(perf_evlist__open(evlist));
CHECK__(perf_evlist__mmap(evlist, UINT_MAX, false));
pc = evlist->mmap[0].base;
ret = perf_read_tsc_conversion(pc, &tc);
if (ret) {
if (ret == -EOPNOTSUPP) {
fprintf(stderr, " (not supported)");
return 0;
}
goto out_err;
}
perf_evlist__enable(evlist);
comm1 = "Test COMM 1";
CHECK__(prctl(PR_SET_NAME, (unsigned long)comm1, 0, 0, 0));
test_tsc = rdtsc();
comm2 = "Test COMM 2";
CHECK__(prctl(PR_SET_NAME, (unsigned long)comm2, 0, 0, 0));
perf_evlist__disable(evlist);
for (i = 0; i < evlist->nr_mmaps; i++) {
while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
struct perf_sample sample;
if (event->header.type != PERF_RECORD_COMM ||
(pid_t)event->comm.pid != getpid() ||
(pid_t)event->comm.tid != getpid())
goto next_event;
if (strcmp(event->comm.comm, comm1) == 0) {
CHECK__(perf_evsel__parse_sample(evsel, event,
&sample));
comm1_time = sample.time;
}
if (strcmp(event->comm.comm, comm2) == 0) {
CHECK__(perf_evsel__parse_sample(evsel, event,
&sample));
comm2_time = sample.time;
}
next_event:
perf_evlist__mmap_consume(evlist, i);
}
}
if (!comm1_time || !comm2_time)
goto out_err;
test_time = tsc_to_perf_time(test_tsc, &tc);
comm1_tsc = perf_time_to_tsc(comm1_time, &tc);
comm2_tsc = perf_time_to_tsc(comm2_time, &tc);
pr_debug("1st event perf time %"PRIu64" tsc %"PRIu64"\n",
comm1_time, comm1_tsc);
pr_debug("rdtsc time %"PRIu64" tsc %"PRIu64"\n",
test_time, test_tsc);
pr_debug("2nd event perf time %"PRIu64" tsc %"PRIu64"\n",
comm2_time, comm2_tsc);
if (test_time <= comm1_time ||
test_time >= comm2_time)
goto out_err;
if (test_tsc <= comm1_tsc ||
test_tsc >= comm2_tsc)
goto out_err;
err = 0;
out_err:
if (evlist) {
perf_evlist__disable(evlist);
perf_evlist__delete(evlist);
}
return err;
}
struct perf_evsel *evsel = NULL;
int found, err = -1;
const char *comm;
threads = thread_map__new(-1, getpid(), UINT_MAX);
CHECK_NOT_NULL__(threads);
cpus = cpu_map__new(NULL);
CHECK_NOT_NULL__(cpus);
evlist = perf_evlist__new();
CHECK_NOT_NULL__(evlist);
perf_evlist__set_maps(evlist, cpus, threads);
CHECK__(parse_events(evlist, "dummy:u", NULL));
CHECK__(parse_events(evlist, "cycles:u", NULL));
perf_evlist__config(evlist, &opts, NULL);
evsel = perf_evlist__first(evlist);
evsel->attr.comm = 1;
evsel->attr.disabled = 1;
evsel->attr.enable_on_exec = 0;
if (perf_evlist__open(evlist) < 0) {
pr_debug("Unable to open dummy and cycles event\n");
err = TEST_SKIP;
goto out_err;
}
static void run_media_streams(int localport, const char *remote_ip, int remoteport, int payload, const char *fmtp,
int jitter, int bitrate, MSVideoSize vs, bool_t ec, bool_t agc, bool_t eq)
{
AudioStream *audio=NULL;
#ifdef VIDEO_ENABLED
VideoStream *video=NULL;
#endif
RtpSession *session=NULL;
PayloadType *pt;
RtpProfile *profile=rtp_profile_clone_full(&av_profile);
OrtpEvQueue *q=ortp_ev_queue_new();
ms_init();
signal(SIGINT,stop_handler);
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
printf("Error: no payload defined with number %i.",payload);
exit(-1);
}
if (fmtp!=NULL) payload_type_set_send_fmtp(pt,fmtp);
if (bitrate>0) pt->normal_bitrate=bitrate;
if (pt->type!=PAYLOAD_VIDEO){
MSSndCardManager *manager=ms_snd_card_manager_get();
MSSndCard *capt= capture_card==NULL ? ms_snd_card_manager_get_default_capture_card(manager) :
ms_snd_card_manager_get_card(manager,capture_card);
MSSndCard *play= playback_card==NULL ? ms_snd_card_manager_get_default_playback_card(manager) :
ms_snd_card_manager_get_card(manager,playback_card);
audio=audio_stream_new(localport,ms_is_ipv6(remote_ip));
audio_stream_enable_automatic_gain_control(audio,agc);
audio_stream_enable_noise_gate(audio,use_ng);
audio_stream_set_echo_canceller_params(audio,ec_len_ms,ec_delay_ms,ec_framesize);
printf("Starting audio stream.\n");
audio_stream_start_full(audio,profile,remote_ip,remoteport,remoteport+1, payload, jitter,infile,outfile,
outfile==NULL ? play : NULL ,infile==NULL ? capt : NULL,infile!=NULL ? FALSE: ec);
if (audio) {
if (use_ng && ng_threshold!=-1)
ms_filter_call_method(audio->volsend,MS_VOLUME_SET_NOISE_GATE_THRESHOLD,&ng_threshold);
session=audio->session;
}
}else{
#ifdef VIDEO_ENABLED
if (eq){
ms_fatal("Cannot put an audio equalizer in a video stream !");
exit(-1);
}
printf("Starting video stream.\n");
video=video_stream_new(localport, ms_is_ipv6(remote_ip));
video_stream_set_sent_video_size(video,vs);
video_stream_use_preview_video_window(video,two_windows);
video_stream_start(video,profile,
remote_ip,
remoteport,remoteport+1,
payload,
jitter,
ms_web_cam_manager_get_default_cam(ms_web_cam_manager_get()));
session=video->session;
#else
printf("Error: video support not compiled.\n");
#endif
}
if (eq || ec){ /*read from stdin interactive commands */
char commands[128];
commands[127]='\0';
ms_sleep(1); /* ensure following text be printed after ortp messages */
if (eq)
printf("\nPlease enter equalizer requests, such as 'eq active 1', 'eq active 0', 'eq 1200 0.1 200'\n");
if (ec)
printf("\nPlease enter echo canceller requests: ec reset; ec <delay ms> <tail_length ms'\n");
while(fgets(commands,sizeof(commands)-1,stdin)!=NULL){
int active,freq,freq_width;
int delay_ms, tail_ms;
float gain;
if (sscanf(commands,"eq active %i",&active)==1){
audio_stream_enable_equalizer(audio,active);
printf("OK\n");
}else if (sscanf(commands,"eq %i %f %i",&freq,&gain,&freq_width)==3){
audio_stream_equalizer_set_gain(audio,freq,gain,freq_width);
printf("OK\n");
}else if (sscanf(commands,"eq %i %f",&freq,&gain)==2){
audio_stream_equalizer_set_gain(audio,freq,gain,0);
printf("OK\n");
}else if (strstr(commands,"dump")){
int n=0,i;
float *t;
ms_filter_call_method(audio->equalizer,MS_EQUALIZER_GET_NUM_FREQUENCIES,&n);
t=(float*)alloca(sizeof(float)*n);
ms_filter_call_method(audio->equalizer,MS_EQUALIZER_DUMP_STATE,t);
for(i=0;i<n;++i){
if (fabs(t[i]-1)>0.01){
printf("%i:%f:0 ",(i*pt->clock_rate)/(2*n),t[i]);
}
}
printf("\nOK\n");
}else if (sscanf(commands,"ec reset %i",&active)==1){
//audio_stream_enable_equalizer(audio,active);
//printf("OK\n");
}else if (sscanf(commands,"ec active %i",&active)==1){
//audio_stream_enable_equalizer(audio,active);
//printf("OK\n");
}else if (sscanf(commands,"ec %i %i",&delay_ms,&tail_ms)==2){
audio_stream_set_echo_canceller_params(audio,tail_ms,delay_ms,128);
// revisit: workaround with old method call to force echo reset
delay_ms*=8;
ms_filter_call_method(audio->ec,MS_FILTER_SET_PLAYBACKDELAY,&delay_ms);
printf("OK\n");
}else if (strstr(commands,"quit")){
break;
}else printf("Cannot understand this.\n");
}
}else{ /* no interactive stuff - continuous debug output */
rtp_session_register_event_queue(session,q);
while(cond)
{
int n;
for(n=0;n<100;++n){
#ifdef WIN32
MSG msg;
Sleep(10);
while (PeekMessage(&msg, NULL, 0, 0,1)){
TranslateMessage(&msg);
DispatchMessage(&msg);
}
#else
struct timespec ts;
ts.tv_sec=0;
ts.tv_nsec=10000000;
nanosleep(&ts,NULL);
#endif
#if defined(VIDEO_ENABLED)
if (video) video_stream_iterate(video);
#endif
}
ortp_global_stats_display();
if (session){
printf("Bandwidth usage: download=%f kbits/sec, upload=%f kbits/sec\n",
rtp_session_compute_recv_bandwidth(session)*1e-3,
rtp_session_compute_send_bandwidth(session)*1e-3);
parse_events(q);
}
}
}
printf("stopping all...\n");
if (audio) audio_stream_stop(audio);
#ifdef VIDEO_ENABLED
if (video) video_stream_stop(video);
#endif
ortp_ev_queue_destroy(q);
rtp_profile_destroy(profile);
}
/*
* Create an event group that contains both a sampled hardware
* (cpu-cycles) and software (intel_cqm/llc_occupancy/) event. We then
* wait for the hardware perf counter to overflow and generate a PMI,
* which triggers an event read for both of the events in the group.
*
* Since reading Intel CQM event counters requires sending SMP IPIs, the
* CQM pmu needs to handle the above situation gracefully, and return
* the last read counter value to avoid triggering a WARN_ON_ONCE() in
* smp_call_function_many() caused by sending IPIs from NMI context.
*/
int test__intel_cqm_count_nmi_context(int subtest __maybe_unused)
{
struct perf_evlist *evlist = NULL;
struct perf_evsel *evsel = NULL;
struct perf_event_attr pe;
int i, fd[2], flag, ret;
size_t mmap_len;
void *event;
pid_t pid;
int err = TEST_FAIL;
flag = perf_event_open_cloexec_flag();
evlist = perf_evlist__new();
if (!evlist) {
pr_debug("perf_evlist__new failed\n");
return TEST_FAIL;
}
ret = parse_events(evlist, "intel_cqm/llc_occupancy/", NULL);
if (ret) {
pr_debug("parse_events failed, is \"intel_cqm/llc_occupancy/\" available?\n");
err = TEST_SKIP;
goto out;
}
evsel = perf_evlist__first(evlist);
if (!evsel) {
pr_debug("perf_evlist__first failed\n");
goto out;
}
memset(&pe, 0, sizeof(pe));
pe.size = sizeof(pe);
pe.type = PERF_TYPE_HARDWARE;
pe.config = PERF_COUNT_HW_CPU_CYCLES;
pe.read_format = PERF_FORMAT_GROUP;
pe.sample_period = 128;
pe.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_READ;
pid = spawn();
fd[0] = sys_perf_event_open(&pe, pid, -1, -1, flag);
if (fd[0] < 0) {
pr_debug("failed to open event\n");
goto out;
}
memset(&pe, 0, sizeof(pe));
pe.size = sizeof(pe);
pe.type = evsel->attr.type;
pe.config = evsel->attr.config;
fd[1] = sys_perf_event_open(&pe, pid, -1, fd[0], flag);
if (fd[1] < 0) {
pr_debug("failed to open event\n");
goto out;
}
/*
* Pick a power-of-two number of pages + 1 for the meta-data
* page (struct perf_event_mmap_page). See tools/perf/design.txt.
*/
mmap_len = page_size * 65;
event = mmap(NULL, mmap_len, PROT_READ, MAP_SHARED, fd[0], 0);
if (event == (void *)(-1)) {
pr_debug("failed to mmap %d\n", errno);
goto out;
}
sleep(1);
err = TEST_OK;
munmap(event, mmap_len);
for (i = 0; i < 2; i++)
close(fd[i]);
kill(pid, SIGKILL);
wait(NULL);
out:
perf_evlist__delete(evlist);
return err;
}
int test__backward_ring_buffer(int subtest __maybe_unused)
{
int ret = TEST_SKIP, err, sample_count = 0, comm_count = 0;
char pid[16], sbuf[STRERR_BUFSIZE];
struct perf_evlist *evlist;
struct perf_evsel *evsel __maybe_unused;
struct parse_events_error parse_error;
struct record_opts opts = {
.target = {
.uid = UINT_MAX,
.uses_mmap = true,
},
.freq = 0,
.mmap_pages = 256,
.default_interval = 1,
};
snprintf(pid, sizeof(pid), "%d", getpid());
pid[sizeof(pid) - 1] = '\0';
opts.target.tid = opts.target.pid = pid;
evlist = perf_evlist__new();
if (!evlist) {
pr_debug("No ehough memory to create evlist\n");
return TEST_FAIL;
}
err = perf_evlist__create_maps(evlist, &opts.target);
if (err < 0) {
pr_debug("Not enough memory to create thread/cpu maps\n");
goto out_delete_evlist;
}
bzero(&parse_error, sizeof(parse_error));
err = parse_events(evlist, "syscalls:sys_enter_prctl", &parse_error);
if (err) {
pr_debug("Failed to parse tracepoint event, try use root\n");
ret = TEST_SKIP;
goto out_delete_evlist;
}
perf_evlist__config(evlist, &opts, NULL);
/* Set backward bit, ring buffer should be writing from end */
evlist__for_each(evlist, evsel)
evsel->attr.write_backward = 1;
err = perf_evlist__open(evlist);
if (err < 0) {
pr_debug("perf_evlist__open: %s\n",
strerror_r(errno, sbuf, sizeof(sbuf)));
goto out_delete_evlist;
}
ret = TEST_FAIL;
err = do_test(evlist, opts.mmap_pages, &sample_count,
&comm_count);
if (err != TEST_OK)
goto out_delete_evlist;
if ((sample_count != NR_ITERS) || (comm_count != NR_ITERS)) {
pr_err("Unexpected counter: sample_count=%d, comm_count=%d\n",
sample_count, comm_count);
goto out_delete_evlist;
}
err = do_test(evlist, 1, &sample_count, &comm_count);
if (err != TEST_OK)
goto out_delete_evlist;
ret = TEST_OK;
out_delete_evlist:
perf_evlist__delete(evlist);
return ret;
}
/**
* test__keep_tracking - test using a dummy software event to keep tracking.
*
* This function implements a test that checks that tracking events continue
* when an event is disabled but a dummy software event is not disabled. If the
* test passes %0 is returned, otherwise %-1 is returned.
*/
int test__keep_tracking(void)
{
struct record_opts opts = {
.mmap_pages = UINT_MAX,
.user_freq = UINT_MAX,
.user_interval = ULLONG_MAX,
.freq = 4000,
.target = {
.uses_mmap = true,
},
};
struct thread_map *threads = NULL;
struct cpu_map *cpus = NULL;
struct perf_evlist *evlist = NULL;
struct perf_evsel *evsel = NULL;
int found, err = -1;
const char *comm;
threads = thread_map__new(-1, getpid(), UINT_MAX);
CHECK_NOT_NULL__(threads);
cpus = cpu_map__new(NULL);
CHECK_NOT_NULL__(cpus);
evlist = perf_evlist__new();
CHECK_NOT_NULL__(evlist);
perf_evlist__set_maps(evlist, cpus, threads);
CHECK__(parse_events(evlist, "dummy:u", NULL));
CHECK__(parse_events(evlist, "cycles:u", NULL));
perf_evlist__config(evlist, &opts);
evsel = perf_evlist__first(evlist);
evsel->attr.comm = 1;
evsel->attr.disabled = 1;
evsel->attr.enable_on_exec = 0;
if (perf_evlist__open(evlist) < 0) {
fprintf(stderr, " (not supported)");
err = 0;
goto out_err;
}
CHECK__(perf_evlist__mmap(evlist, UINT_MAX, false));
/*
* First, test that a 'comm' event can be found when the event is
* enabled.
*/
perf_evlist__enable(evlist);
comm = "Test COMM 1";
CHECK__(prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0));
perf_evlist__disable(evlist);
found = find_comm(evlist, comm);
if (found != 1) {
pr_debug("First time, failed to find tracking event.\n");
goto out_err;
}
/*
* Secondly, test that a 'comm' event can be found when the event is
* disabled with the dummy event still enabled.
*/
perf_evlist__enable(evlist);
evsel = perf_evlist__last(evlist);
CHECK__(perf_evlist__disable_event(evlist, evsel));
comm = "Test COMM 2";
CHECK__(prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0));
perf_evlist__disable(evlist);
found = find_comm(evlist, comm);
if (found != 1) {
pr_debug("Seconf time, failed to find tracking event.\n");
goto out_err;
}
err = 0;
out_err:
if (evlist) {
perf_evlist__disable(evlist);
perf_evlist__delete(evlist);
} else {
cpu_map__put(cpus);
thread_map__put(threads);
}
return err;
}
void run_media_streams(int localport, const char *remote_ip, int remoteport, int payload, const char *fmtp, int jitter, bool_t ec, int bitrate)
{
AudioStream *audio=NULL;
#ifdef VIDEO_ENABLED
VideoStream *video=NULL;
#endif
RtpSession *session=NULL;
PayloadType *pt;
RtpProfile *profile=rtp_profile_clone_full(&av_profile);
OrtpEvQueue *q=ortp_ev_queue_new();
ms_init();
signal(SIGINT,stop_handler);
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL) {
printf("Error: no payload defined with number %i.",payload);
exit(-1);
}
if (fmtp!=NULL) payload_type_set_send_fmtp(pt,fmtp);
if (bitrate>0) pt->normal_bitrate=bitrate;
if (pt->type!=PAYLOAD_VIDEO) {
printf("Starting audio stream.\n");
audio=audio_stream_start(profile,localport,remote_ip,remoteport,payload,jitter, ec);
if (audio) session=audio->session;
} else {
#ifdef VIDEO_ENABLED
printf("Starting video stream.\n");
video=video_stream_new(localport, ms_is_ipv6(remote_ip));
video_stream_start(video,profile,
remote_ip,
remoteport,
payload,
jitter,
"/dev/video0");
session=video->session;
#else
printf("Error: video support not compiled.\n");
#endif
}
rtp_session_register_event_queue(session,q);
while(cond)
{
/* sleep until we receive SIGINT */
#ifdef WIN32
int n;
MSG msg;
for(n=0; n<100; ++n) {
Sleep(10);
while (PeekMessage(&msg, NULL, 0, 0,1)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
#else
sleep(1);
#endif
ortp_global_stats_display();
if (session) {
printf("Bandwidth usage: download=%f kbits/sec, upload=%f kbits/sec\n",
rtp_session_compute_recv_bandwidth(session)*1e-3,
rtp_session_compute_send_bandwidth(session)*1e-3);
parse_events(q);
}
}
printf("stoping all...\n");
if (audio) audio_stream_stop(audio);
#ifdef VIDEO_ENABLED
if (video) video_stream_stop(video);
#endif
ortp_ev_queue_destroy(q);
rtp_profile_destroy(profile);
}
