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; }