int main(int argc, char ** argv)
{
try
{
bool document_object = false;
bool show_navigation = false;
const option_group general_options = { nullptr, {
{ 'm', "document-object", bind_value(document_object, true),
i18n("Process events through a cainteoir::document object model") },
{ 'n', "show-navigation", bind_value(show_navigation, true),
i18n("Print the navigation structure, not document content") },
}};
const std::initializer_list<const char *> usage = {
i18n("events [OPTION..] DOCUMENT"),
i18n("events [OPTION..]"),
};
const std::initializer_list<option_group> options = {
general_options,
};
if (!parse_command_line(options, usage, argc, argv))
return 0;
rdf::graph metadata;
const char *filename = (argc == 1) ? argv[0] : nullptr;
rdf::uri subject(filename ? filename : std::string(), std::string());
auto reader = cainteoir::createDocumentReader(filename, metadata, std::string());
if (!reader)
{
fprintf(stderr, "unsupported document format for file \"%s\"\n", argv[0]);
return 0;
}
if (document_object || show_navigation)
{
cainteoir::document doc(reader, metadata);
if (show_navigation)
print_navigation(metadata, doc, subject);
else
{
auto docreader = cainteoir::createDocumentReader(doc.children());
print_events(docreader);
}
}
else
print_events(reader);
}
catch (std::runtime_error &e)
{
fprintf(stderr, "error: %s\n", e.what());
}
return 0;
}
void *
getNextKey(void *)
{
XDeviceInfo *info;
Display *display;
display = XOpenDisplay(NULL);
Bool handle_proximity = False;
info = find_device_info(display, device, True);
if (!info) {
//fprintf(stderr, "unable to find device '%s'\n", argv[idx]);
//return EXIT_FAILURE;
} else {
if (register_events(display, info, device, handle_proximity)) {
print_events(display);
}
else {
fprintf(stderr, "no event registered...\n");
//return EXIT_FAILURE;
}
}
//return output;
}
/*
* List events of channel of session and domain.
*/
static int list_events(const char *channel_name)
{
int ret, count, i;
struct lttng_event *events = NULL;
count = lttng_list_events(handle, channel_name, &events);
if (count < 0) {
ret = count;
ERR("%s", lttng_strerror(ret));
goto error;
}
MSG("\n%sEvents:", indent4);
if (count == 0) {
MSG("%sNone\n", indent6);
goto end;
}
for (i = 0; i < count; i++) {
print_events(&events[i]);
}
MSG("");
end:
free(events);
ret = CMD_SUCCESS;
error:
return ret;
}
static void process_data_sock(int h, struct pollfd *pfds, int count)
{
asrt(count <= ts[h].poll_count);
int i;
for( i= 1; i < ts[h].poll_count; i++)
{
if(pfds[i].revents)
{
int ps_i = ts[h].psi[i];
asrt(pfds[i].fd == ts[h].ps[ps_i].pfd.fd);
uint32_t user_id = ts[h].ps[ps_i].user_id;
int type = ts[h].ps[ps_i].type;
int flags = 0;
print_events(pfds[i].revents);
if(IS_READ(pfds[i].revents))
{
flags |= SOCK_THREAD_FD_RD;
}
if(IS_WRITE(pfds[i].revents))
{
flags |= SOCK_THREAD_FD_WR;
}
if(IS_EXCEPTION(pfds[i].revents))
{
flags |= SOCK_THREAD_FD_EXCEPTION;
//remove the whole slot not flags
remove_poll(h, &ts[h].ps[ps_i], ts[h].ps[ps_i].flags);
}
else if(flags)
remove_poll(h, &ts[h].ps[ps_i], flags); //remove the monitor flags that already processed
if(flags)
ts[h].callback(pfds[i].fd, type, flags, user_id);
}
}
}
/*
* Ask session daemon for all user space tracepoints available.
*/
static int list_ust_events(void)
{
int i, size;
struct lttng_domain domain;
struct lttng_handle *handle;
struct lttng_event *event_list;
pid_t cur_pid = 0;
char *cmdline = NULL;
memset(&domain, 0, sizeof(domain));
DBG("Getting UST tracing events");
domain.type = LTTNG_DOMAIN_UST;
handle = lttng_create_handle(NULL, &domain);
if (handle == NULL) {
goto error;
}
size = lttng_list_tracepoints(handle, &event_list);
if (size < 0) {
ERR("Unable to list UST events: %s", lttng_strerror(size));
lttng_destroy_handle(handle);
return size;
}
MSG("UST events:\n-------------");
if (size == 0) {
MSG("None");
}
for (i = 0; i < size; i++) {
if (cur_pid != event_list[i].pid) {
cur_pid = event_list[i].pid;
cmdline = get_cmdline_by_pid(cur_pid);
MSG("\nPID: %d - Name: %s", cur_pid, cmdline);
free(cmdline);
}
print_events(&event_list[i]);
}
MSG("");
free(event_list);
lttng_destroy_handle(handle);
return CMD_SUCCESS;
error:
lttng_destroy_handle(handle);
return -1;
}
/*
* Ask for all trace events in the kernel
*/
static int list_kernel_events(void)
{
int i, size, ret = CMD_SUCCESS;
struct lttng_domain domain;
struct lttng_handle *handle;
struct lttng_event *event_list;
memset(&domain, 0, sizeof(domain));
DBG("Getting kernel tracing events");
domain.type = LTTNG_DOMAIN_KERNEL;
handle = lttng_create_handle(NULL, &domain);
if (handle == NULL) {
ret = CMD_ERROR;
goto error;
}
size = lttng_list_tracepoints(handle, &event_list);
if (size < 0) {
ERR("Unable to list kernel events: %s", lttng_strerror(size));
lttng_destroy_handle(handle);
return CMD_ERROR;
}
if (lttng_opt_mi) {
/* Mi print */
ret = mi_list_kernel_events(event_list, size, &domain);
if (ret) {
ret = CMD_ERROR;
goto end;
}
} else {
MSG("Kernel events:\n-------------");
for (i = 0; i < size; i++) {
print_events(&event_list[i]);
}
MSG("");
}
end:
free(event_list);
lttng_destroy_handle(handle);
return ret;
error:
lttng_destroy_handle(handle);
return ret;
}
void load_events()
{
// initialize random number generator; it has to be done only once (after reset)
srand(current_time());
events_count = eeprom_read_byte(&events_count_ee);
// initialize - for testing purposes
/*
if (events_count == 0)
{
send_string("add_default\r\n");
add_default_events();
}
*/
if (events_count == 0)
{
send_line("No events => MANUAL_MODE");
event_mode = MANUAL_MODE;
return;
}
// load events into ram
eeprom_read_block(&events, &events_ee, sizeof(struct Event) * EVENTS_SIZE);
// prepare
prepare_actual_events();
// print events
print_events();
// check current state of pins
// if the device is power off, and later power on - it doesn't know what should be current state of pins
int32_t time = current_time();
send_string(" start time: ");
char formatted_date[30];
timeToString(time, formatted_date);
send_string(formatted_date);
send_enter();
current_state();
}
int main(int argc, char** argv) {
double lat, lon;
event* events;
int n_events;
if (argc != 3) {
printf("Usage: %s latitude longitude\n", argv[0]);
exit(1);
}
lat = atof(argv[1]);
lon = atof(argv[2]);
n_events = generate_events(lat, lon, time(NULL), &events);
print_events(events, n_events);
printf("No more events.");
return 0;
}
static int do_capture(const char *device)
{
int fd;
char *filename;
if (!device) {
fprintf(stderr, "No device specified, trying to scan all of %s/%s*\n",
DEV_INPUT_EVENT, EVENT_DEV_NAME);
if (getuid() != 0)
fprintf(stderr, "Not running as root, no devices may be available.\n");
filename = scan_devices();
if (!filename)
return usage();
} else
filename = strdup(device);
if (!filename)
return EXIT_FAILURE;
if ((fd = open(filename, O_RDONLY)) < 0) {
perror("evtest");
if (errno == EACCES && getuid() != 0)
fprintf(stderr, "You do not have access to %s. Try "
"running as root instead.\n",
filename);
return EXIT_FAILURE;
}
free(filename);
if (!isatty(fileno(stdout)))
setbuf(stdout, NULL);
if (test_grab(fd))
{
return 0;
}
return print_events(fd);
}
/*
* Ask for all trace events in the kernel and pretty print them.
*/
static int list_kernel_events(void)
{
int i, size;
struct lttng_domain domain;
struct lttng_handle *handle;
struct lttng_event *event_list;
memset(&domain, 0, sizeof(domain));
DBG("Getting kernel tracing events");
domain.type = LTTNG_DOMAIN_KERNEL;
handle = lttng_create_handle(NULL, &domain);
if (handle == NULL) {
goto error;
}
size = lttng_list_tracepoints(handle, &event_list);
if (size < 0) {
ERR("Unable to list kernel events");
lttng_destroy_handle(handle);
return size;
}
MSG("Kernel events:\n-------------");
for (i = 0; i < size; i++) {
print_events(&event_list[i]);
}
MSG("");
free(event_list);
lttng_destroy_handle(handle);
return CMD_SUCCESS;
error:
lttng_destroy_handle(handle);
return -1;
}
/*
* Ask for kernel system calls.
*/
static int list_syscalls(void)
{
int i, size, ret = CMD_SUCCESS;
struct lttng_event *event_list;
DBG("Getting kernel system call events");
size = lttng_list_syscalls(&event_list);
if (size < 0) {
ERR("Unable to list system calls: %s", lttng_strerror(size));
ret = CMD_ERROR;
goto error;
}
if (lttng_opt_mi) {
/* Mi print */
ret = mi_list_syscalls(event_list, size);
if (ret) {
ret = CMD_ERROR;
goto end;
}
} else {
MSG("System calls:\n-------------");
for (i = 0; i < size; i++) {
print_events(&event_list[i]);
}
MSG("");
}
end:
free(event_list);
return ret;
error:
return ret;
}
/*
* List events of channel of session and domain.
*/
static int list_events(const char *channel_name)
{
int ret = CMD_SUCCESS, count, i;
struct lttng_event *events = NULL;
count = lttng_list_events(handle, channel_name, &events);
if (count < 0) {
ret = CMD_ERROR;
ERR("%s", lttng_strerror(count));
goto error;
}
if (lttng_opt_mi) {
/* Mi print */
ret = mi_list_events(events, count);
if (ret) {
ret = CMD_ERROR;
goto end;
}
} else {
/* Pretty print */
MSG("\n%sEvents:", indent4);
if (count == 0) {
MSG("%sNone\n", indent6);
goto end;
}
for (i = 0; i < count; i++) {
print_events(&events[i]);
}
MSG("");
}
end:
free(events);
error:
return ret;
}
int main () {
int fd, grabbed;
char *filename;
if (getuid() != 0) {
fprintf(stderr, "Not running as root, no devices may be available.\n");
}
filename = scan_devices();
if (!filename) {
fprintf(stderr, "Device not found\n");
return EXIT_FAILURE;
}
if ((fd = open(filename, O_RDONLY)) < 0) {
perror("");
if (errno == EACCES && getuid() != 0) {
fprintf(stderr, "You do not have access to %s. Try "
"running as root instead.\n", filename);
}
return EXIT_FAILURE;
}
free(filename);
if (print_device_info(fd)) {
return EXIT_FAILURE;
}
grabbed = ioctl(fd, EVIOCGRAB, (void *) 1);
ioctl(fd, EVIOCGRAB, (void *) 0);
if (grabbed) {
printf("This device is grabbed by another process. Try switching VT.\n");
return EXIT_FAILURE;
}
return print_events(fd);
}
int main(int argc, char **argv)
{
int rc = 0;
auparse_state_t *au = NULL;
setlocale(LC_ALL, "");
if (parse_args(argc, argv))
goto error;
if (help_flag) {
usage(stdout);
goto exit;
}
/* Initialize event list*/
events = list_new((list_free_data_fn*) event_free);
if (events == NULL)
goto unexpected_error;
/* Initialize auparse */
au = init_auparse();
if (au == NULL)
goto error;
if (create_search_criteria(au))
goto error;
while (ausearch_next_event(au) > 0) {
int err = 0;
switch(auparse_get_type(au)) {
case AUDIT_VIRT_MACHINE_ID:
err = process_machine_id_event(au);
break;
case AUDIT_VIRT_CONTROL:
err = process_control_event(au);
break;
case AUDIT_VIRT_RESOURCE:
err = process_resource_event(au);
break;
case AUDIT_AVC:
err = process_avc(au);
break;
case AUDIT_FIRST_ANOM_MSG ... AUDIT_LAST_ANOM_MSG:
case AUDIT_FIRST_KERN_ANOM_MSG ... AUDIT_LAST_KERN_ANOM_MSG:
err = process_anom(au);
break;
case AUDIT_SYSTEM_SHUTDOWN:
err = process_shutdown(au);
break;
}
if (err) {
goto unexpected_error;
}
auparse_next_event(au);
}
/* Show results */
if (summary_flag) {
print_summary();
} else {
print_events();
}
/* success */
goto exit;
unexpected_error:
fprintf(stderr, "Unexpected error\n");
error:
rc = 1;
exit:
if (au)
auparse_destroy(au);
list_free(events);
if (debug)
fprintf(stdout, "Exit code: %d\n", rc);
return rc;
}
int main(int i,char**argv)
{
int epoll_fd;
int epoll_size=100;
struct epoll_event ev,events[20];
int listen_fd;
struct sockaddr_in my_addr;
epoll_fd=epoll_create(epoll_size);
if(epoll_fd==-1)
{
std::cout<<"epoll_create failed!"<<std::endl;
return -1;
}
std::cout<<"epoll_create success!"<<std::endl;
listen_fd=socket(AF_INET,SOCK_STREAM,0);
if(listen_fd==-1)
{
std::cout<<"sock_create failed!"<<std::endl;
return -1;
}
std::cout<<"sock_create success!"<<std::endl;
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(222222);
my_addr.sin_addr.s_addr=inet_addr("10.20.146.85");
bzero(&(my_addr.sin_zero),8);
if(-1==bind(listen_fd,(struct sockaddr*)&my_addr,sizeof(struct sockaddr)))
{
std::cout<<"bind failed!"<<std::endl;
return -1;
};
std::cout<<"bind success!"<<std::endl;
if(-1==listen(listen_fd,20))
{
std::cout<<"listen failed!"<<std::endl;
return -1;
};
std::cout<<"listen success!"<<std::endl;
ev.events=EPOLLIN|EPOLLET;
ev.data.fd=listen_fd;
epoll_ctl(epoll_fd,EPOLL_CTL_ADD,listen_fd,&ev);
for(int i=0;;i++)
{
std::cout<<".... rand("<<i<<")..."<<std::endl;
int nfds=epoll_wait(epoll_fd,events,20,5000);
// sleep(5);
std::cout<<"events ="<<nfds<<std::endl;
for(int i=0;i<nfds;i++)
{
struct epoll_event *event;
event=&events[i];
print_events(event->events);
if(event->data.fd==listen_fd)
{
struct sockaddr_in client_addr;
socklen_t client_addr_size;
int connect_fd=accept(listen_fd,(struct sockaddr*)&client_addr,&client_addr_size);
std::cout<<"accept a new client! clien_fd="<<connect_fd<<std::endl;
struct epoll_event client_event;
client_event.events=EPOLLIN;//|EPOLLET;
client_event.data.fd=connect_fd;
epoll_ctl(epoll_fd,EPOLL_CTL_ADD,connect_fd,&client_event);
}
else
{
char buffer[100]={0};
int rdn=0;
if((rdn=read(event->data.fd,buffer,1))==-1||rdn==0)
{
std::cout<<"readdn= "<<rdn<<std::endl;
epoll_ctl(epoll_fd,EPOLL_CTL_DEL,event->data.fd,NULL);
std::cout<<"del connect_fd :"<<event->data.fd<<std::endl;
getchar();
}
else
{
std::cout<<"readdn = "<<rdn;
std::cout<<":"<<buffer;
std::cout<<" ,@="<<event->data.fd<<std::endl;
getchar();
}
}
}
}
return 0;
}
int
main()
{
sSemaphore1 = create_sem(0L, "test semaphore 1");
sSemaphore2 = create_sem(0L, "test semaphore 2");
sPort1 = create_port(2L, "test port 1");
sPort2 = create_port(1L, "test port 2");
printf("semaphore 1: %ld\n", sSemaphore1);
printf("semaphore 2: %ld\n", sSemaphore2);
printf("port 1: %ld\n", sPort1);
printf("port 2: %ld\n", sPort2);
thread_id thread = spawn_thread(notifier_thread, "notifier",
B_NORMAL_PRIORITY, NULL);
resume_thread(thread);
printf("thread: %ld\n", thread);
object_wait_info initialInfos[] = {
{
sSemaphore1,
B_OBJECT_TYPE_SEMAPHORE,
B_EVENT_ACQUIRE_SEMAPHORE
},
{
sSemaphore2,
B_OBJECT_TYPE_SEMAPHORE,
B_EVENT_ACQUIRE_SEMAPHORE
},
{
sPort1,
B_OBJECT_TYPE_PORT,
B_EVENT_READ
},
{
sPort2,
B_OBJECT_TYPE_PORT,
B_EVENT_WRITE
},
{
0,
B_OBJECT_TYPE_FD,
B_EVENT_READ
},
{
thread,
B_OBJECT_TYPE_THREAD,
B_EVENT_INVALID
}
};
int infoCount = sizeof(initialInfos) / sizeof(object_wait_info);
while (true) {
object_wait_info infos[infoCount];
memcpy(infos, initialInfos, sizeof(initialInfos));
ssize_t result = wait_for_objects_etc(infos, infoCount,
B_RELATIVE_TIMEOUT, 10000000LL);
if (result >= 0)
printf("\nwait_for_objects(): %ld\n", result);
else
printf("\nwait_for_objects(): %s\n", strerror(result));
print_events(infos, infoCount);
for (int i = 0; i < infoCount; i++) {
int32 type = infos[i].type;
int32 object = infos[i].object;
uint16 events = infos[i].events;
char buffer[256];
if (type == B_OBJECT_TYPE_SEMAPHORE) {
if (events & B_EVENT_ACQUIRE_SEMAPHORE) {
status_t error = acquire_sem_etc(object, 1,
B_RELATIVE_TIMEOUT, 0);
printf("acquire_sem(%ld): %s\n", object, strerror(error));
}
} else if (type == B_OBJECT_TYPE_PORT) {
if (events & B_EVENT_READ) {
int32 code;
ssize_t bytesRead = read_port_etc(object, &code,
buffer, sizeof(buffer), B_RELATIVE_TIMEOUT, 0);
printf("read_port(%ld): %ld\n", object, bytesRead);
}
if (events & B_EVENT_WRITE) {
status_t error = write_port_etc(object, 0xc0de, buffer, 10,
B_RELATIVE_TIMEOUT, 0);
printf("write_port(%ld): %s\n", object, strerror(error));
}
} else if (type == B_OBJECT_TYPE_FD) {
if (events & B_EVENT_READ) {
ssize_t bytesRead = read(object, buffer, sizeof(buffer));
printf("read(%ld): %ld\n", object, bytesRead);
}
} else if (type == B_OBJECT_TYPE_THREAD) {
if (events & B_EVENT_INVALID) {
printf("thread %ld quit\n", object);
infoCount--;
}
}
}
}
return 0;
}
int cmd_list(int argc, const char **argv)
{
int i;
bool raw_dump = false;
bool long_desc_flag = false;
struct option list_options[] = {
OPT_BOOLEAN(0, "raw-dump", &raw_dump, "Dump raw events"),
OPT_BOOLEAN('d', "desc", &desc_flag,
"Print extra event descriptions. --no-desc to not print."),
OPT_BOOLEAN('v', "long-desc", &long_desc_flag,
"Print longer event descriptions."),
OPT_BOOLEAN(0, "details", &details_flag,
"Print information on the perf event names and expressions used internally by events."),
OPT_INCR(0, "debug", &verbose,
"Enable debugging output"),
OPT_END()
};
const char * const list_usage[] = {
"perf list [<options>] [hw|sw|cache|tracepoint|pmu|sdt|event_glob]",
NULL
};
set_option_flag(list_options, 0, "raw-dump", PARSE_OPT_HIDDEN);
argc = parse_options(argc, argv, list_options, list_usage,
PARSE_OPT_STOP_AT_NON_OPTION);
setup_pager();
if (!raw_dump && pager_in_use())
printf("\nList of pre-defined events (to be used in -e):\n\n");
if (argc == 0) {
print_events(NULL, raw_dump, !desc_flag, long_desc_flag,
details_flag);
return 0;
}
for (i = 0; i < argc; ++i) {
char *sep, *s;
if (strcmp(argv[i], "tracepoint") == 0)
print_tracepoint_events(NULL, NULL, raw_dump);
else if (strcmp(argv[i], "hw") == 0 ||
strcmp(argv[i], "hardware") == 0)
print_symbol_events(NULL, PERF_TYPE_HARDWARE,
event_symbols_hw, PERF_COUNT_HW_MAX, raw_dump);
else if (strcmp(argv[i], "sw") == 0 ||
strcmp(argv[i], "software") == 0)
print_symbol_events(NULL, PERF_TYPE_SOFTWARE,
event_symbols_sw, PERF_COUNT_SW_MAX, raw_dump);
else if (strcmp(argv[i], "cache") == 0 ||
strcmp(argv[i], "hwcache") == 0)
print_hwcache_events(NULL, raw_dump);
else if (strcmp(argv[i], "pmu") == 0)
print_pmu_events(NULL, raw_dump, !desc_flag,
long_desc_flag, details_flag);
else if (strcmp(argv[i], "sdt") == 0)
print_sdt_events(NULL, NULL, raw_dump);
else if (strcmp(argv[i], "metric") == 0)
metricgroup__print(true, false, NULL, raw_dump, details_flag);
else if (strcmp(argv[i], "metricgroup") == 0)
metricgroup__print(false, true, NULL, raw_dump, details_flag);
else if ((sep = strchr(argv[i], ':')) != NULL) {
int sep_idx;
if (sep == NULL) {
print_events(argv[i], raw_dump, !desc_flag,
long_desc_flag,
details_flag);
continue;
}
sep_idx = sep - argv[i];
s = strdup(argv[i]);
if (s == NULL)
return -1;
s[sep_idx] = '\0';
print_tracepoint_events(s, s + sep_idx + 1, raw_dump);
print_sdt_events(s, s + sep_idx + 1, raw_dump);
metricgroup__print(true, true, s, raw_dump, details_flag);
free(s);
} else {
if (asprintf(&s, "*%s*", argv[i]) < 0) {
printf("Critical: Not enough memory! Trying to continue...\n");
continue;
}
print_symbol_events(s, PERF_TYPE_HARDWARE,
event_symbols_hw, PERF_COUNT_HW_MAX, raw_dump);
print_symbol_events(s, PERF_TYPE_SOFTWARE,
event_symbols_sw, PERF_COUNT_SW_MAX, raw_dump);
print_hwcache_events(s, raw_dump);
print_pmu_events(s, raw_dump, !desc_flag,
long_desc_flag,
details_flag);
print_tracepoint_events(NULL, s, raw_dump);
print_sdt_events(NULL, s, raw_dump);
metricgroup__print(true, true, s, raw_dump, details_flag);
free(s);
}
}
return 0;
}
int main(int argc, char **argv)
{
struct time_type time;
ZOOM_connection *z;
ZOOM_resultset *r;
int *elc;
struct event_line_t *els;
ZOOM_options o;
int i;
int k;
init_statics();
read_params(argc, argv, ¶meters);
z = (ZOOM_connection *) xmalloc(sizeof(*z) * parameters.concurrent);
r = (ZOOM_resultset *) xmalloc(sizeof(*r) * parameters.concurrent);
elc = (int *) xmalloc(sizeof(*elc) * parameters.concurrent * parameters.repeat);
els = (struct event_line_t *) xmalloc(
sizeof(*els) * parameters.concurrent * parameters.repeat * 10);
o = ZOOM_options_create();
/* async mode */
ZOOM_options_set (o, "async", "1");
/* get first record of result set (using piggypack) */
if (parameters.piggypack)
ZOOM_options_set (o, "count", "1");
/* set proxy */
if (strlen(parameters.proxy))
ZOOM_options_set (o, "proxy", parameters.proxy);
/* preferred record syntax */
if (0){
ZOOM_options_set (o, "preferredRecordSyntax", "usmarc");
ZOOM_options_set (o, "elementSetName", "F");
}
time_init(&time);
/* repeat loop */
for (k = 0; k < parameters.repeat; k++){
/* progress zeroing */
for (i = 0; i < 4096; i++){
parameters.progress[i] = k * 5 -1;
}
/* connect to all concurrent connections*/
for ( i = 0; i < parameters.concurrent; i++){
/* set event count to zero */
elc[k * parameters.concurrent + i] = 0;
/* create connection - pass options (they are the same for all) */
z[i] = ZOOM_connection_create(o);
/* connect and init */
ZOOM_connection_connect(z[i], parameters.host, 0);
}
/* search all */
for (i = 0; i < parameters.concurrent; i++)
r[i] = ZOOM_connection_search_pqf (z[i], parameters.query);
/* network I/O. pass number of connections and array of connections */
while ((i = ZOOM_event (parameters.concurrent, z))){
int event = ZOOM_connection_last_event(z[i-1]);
const char *errmsg;
const char *addinfo;
int error = 0;
//int progress = zoom_progress[event];
if (event == ZOOM_EVENT_SEND_DATA || event == ZOOM_EVENT_RECV_DATA)
continue;
time_stamp(&time);
/* updating events and event list */
error = ZOOM_connection_error(z[i-1] , &errmsg, &addinfo);
if (error)
parameters.progress[i] = zoom_progress[ZOOM_EVENT_UNKNOWN];
//parameters.progress[i] = zoom_progress[ZOOM_EVENT_NONE];
else if (event == ZOOM_EVENT_CONNECT)
parameters.progress[i] = zoom_progress[event];
else
//parameters.progress[i] = zoom_progress[event];
parameters.progress[i] += 1;
update_events(elc, els,
k, i-1,
time_sec(&time), time_usec(&time),
parameters.progress[i],
event, zoom_events[event],
error, errmsg);
}
/* destroy connections */
for (i = 0; i<parameters.concurrent; i++)
{
ZOOM_resultset_destroy (r[i]);
ZOOM_connection_destroy (z[i]);
}
} /* for (k = 0; k < parameters.repeat; k++) repeat loop */
/* output */
if (parameters.gnuplot){
printf("# gnuplot data and instruction file \n");
printf("# gnuplot thisfile \n");
printf("\n");
printf("set title \"Z39.50 connection plot\"\n");
printf("set xlabel \"Connection\"\n");
printf("set ylabel \"Time Seconds\"\n");
printf("set zlabel \"Progress\"\n");
printf("set ticslevel 0\n");
printf("set grid\n");
printf("set pm3d\n");
printf("splot '-' using ($1):($2):($3) t '' with points\n");
printf("\n");
printf("\n");
}
print_table_header();
print_events(elc, els, parameters.concurrent);
if (parameters.gnuplot){
printf("end\n");
printf("pause -1 \"Hit ENTER to return\"\n");
}
/* destroy data structures and exit */
xfree(z);
xfree(r);
xfree(elc);
xfree(els);
ZOOM_options_destroy(o);
exit (0);
}
/*
* Ask session daemon for all user space tracepoint fields available.
*/
static int list_ust_event_fields(void)
{
int i, size, ret = CMD_SUCCESS;
struct lttng_domain domain;
struct lttng_handle *handle;
struct lttng_event_field *event_field_list;
pid_t cur_pid = 0;
char *cmdline = NULL;
struct lttng_event cur_event;
memset(&domain, 0, sizeof(domain));
memset(&cur_event, 0, sizeof(cur_event));
DBG("Getting UST tracing event fields");
domain.type = LTTNG_DOMAIN_UST;
handle = lttng_create_handle(NULL, &domain);
if (handle == NULL) {
ret = CMD_ERROR;
goto end;
}
size = lttng_list_tracepoint_fields(handle, &event_field_list);
if (size < 0) {
ERR("Unable to list UST event fields: %s", lttng_strerror(size));
ret = CMD_ERROR;
goto end;
}
if (lttng_opt_mi) {
/* Mi print */
ret = mi_list_ust_event_fields(event_field_list, size, &domain);
if (ret) {
ret = CMD_ERROR;
goto error;
}
} else {
/* Pretty print */
MSG("UST events:\n-------------");
if (size == 0) {
MSG("None");
}
for (i = 0; i < size; i++) {
if (cur_pid != event_field_list[i].event.pid) {
cur_pid = event_field_list[i].event.pid;
cmdline = get_cmdline_by_pid(cur_pid);
if (cmdline == NULL) {
ret = CMD_ERROR;
goto error;
}
MSG("\nPID: %d - Name: %s", cur_pid, cmdline);
free(cmdline);
/* Wipe current event since we are about to print a new PID. */
memset(&cur_event, 0, sizeof(cur_event));
}
if (strcmp(cur_event.name, event_field_list[i].event.name) != 0) {
print_events(&event_field_list[i].event);
memcpy(&cur_event, &event_field_list[i].event,
sizeof(cur_event));
}
print_event_field(&event_field_list[i]);
}
MSG("");
}
error:
free(event_field_list);
end:
lttng_destroy_handle(handle);
return ret;
}
