From 98963de4a2dfae12d8aafa0f9a6d97cf4a44e12d Mon Sep 17 00:00:00 2001 From: Pierre-Marc Fournier Date: Tue, 17 Feb 2009 13:34:04 -0500 Subject: [PATCH] ust: collect many channels and start work on pipe listener --- hello/hello.c | 137 +++++++++++++++++++++++++++++------------ libmarkers/marker.c | 52 +++++++++++++++- libmarkers/marker.h | 12 +++- libtracectl/tracectl.c | 136 +++++++++++++++++++++++++++++++++++++--- libtracing/relay.c | 2 +- libtracing/relay.h | 2 +- libtracing/tracer.c | 1 + share/kernelcompat.h | 28 +++++++-- 8 files changed, 313 insertions(+), 57 deletions(-) diff --git a/hello/hello.c b/hello/hello.c index 2e74505..d6750d0 100644 --- a/hello/hello.c +++ b/hello/hello.c @@ -34,15 +34,19 @@ int safe_printf(const char *fmt, ...) va_end(ap); } +struct consumer_channel { + int fd; + struct ltt_channel_struct *chan; +}; + int consumer(void *arg) { int result; - int fd; - char str[] = "Hello, this is the consumer.\n"; - struct ltt_trace_struct *trace; + struct consumer_channel *consumer_channels; + int i; ltt_lock_traces(); trace = _ltt_trace_find(trace_name); @@ -53,43 +57,91 @@ int consumer(void *arg) return 1; } - CPRINTF("consumer: got a trace: %s with %d channels\n", trace_name, trace->nr_channels); - - struct ltt_channel_struct *chan = &trace->channels[0]; + consumer_channels = (struct consumer_channel *) malloc(trace->nr_channels * sizeof(struct consumer_channel)); + if(consumer_channels == NULL) { + ERR("malloc returned NULL"); + return 1; + } - CPRINTF("channel 1 (%s) active=%u", chan->channel_name, chan->active & 1); + CPRINTF("opening trace files"); + for(i=0; inr_channels; i++) { + char tmp[100]; + struct ltt_channel_struct *chan = &trace->channels[i]; - struct rchan *rchan = chan->trans_channel_data; - struct rchan_buf *rbuf = rchan->buf; - struct ltt_channel_buf_struct *lttbuf = chan->buf; - long consumed_old; + consumer_channels[i].chan = chan; - result = fd = open("trace.out", O_WRONLY | O_CREAT | O_TRUNC, 00644); - if(result == -1) { - perror("open"); - return -1; + snprintf(tmp, sizeof(tmp), "trace/%s", chan->channel_name); + result = consumer_channels[i].fd = open(tmp, O_WRONLY | O_CREAT | O_TRUNC, 00644); + if(result == -1) { + perror("open"); + return -1; + } + CPRINTF("\topened trace file %s", tmp); + } + CPRINTF("done opening trace files"); for(;;) { - write(STDOUT_FILENO, str, sizeof(str)); - - result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old); - if(result < 0) { - CPRINTF("ltt_do_get_subbuf: error: %s", strerror(-result)); + /*wait*/ + + for(i=0; inr_channels; i++) { + struct rchan *rchan = consumer_channels[i].chan->trans_channel_data; + struct rchan_buf *rbuf = rchan->buf; + struct ltt_channel_buf_struct *lttbuf = consumer_channels[i].chan->buf; + long consumed_old; + + result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old); + if(result < 0) { + CPRINTF("ltt_do_get_subbuf: error: %s", strerror(-result)); + } + else { + CPRINTF("success!"); + + result = write(consumer_channels[i].fd, rbuf->buf_data + (consumed_old & (2 * 4096-1)), 4096); + ltt_do_put_subbuf(rbuf, lttbuf, consumed_old); + } } - else { - CPRINTF("success!"); - - result = write(fd, rbuf->buf_data + (consumed_old & (2 * 4096-1)), 4096); - ltt_do_put_subbuf(rbuf, lttbuf, consumed_old); - } - - //CPRINTF("There seems to be %ld bytes available", SUBBUF_TRUNC(local_read(<tbuf->offset), rbuf->chan) - consumed_old); - CPRINTF("Commit count %ld", local_read(<tbuf->commit_count[0])); - sleep(1); } + +// CPRINTF("consumer: got a trace: %s with %d channels\n", trace_name, trace->nr_channels); +// +// struct ltt_channel_struct *chan = &trace->channels[0]; +// +// CPRINTF("channel 1 (%s) active=%u", chan->channel_name, chan->active & 1); + +// struct rchan *rchan = chan->trans_channel_data; +// struct rchan_buf *rbuf = rchan->buf; +// struct ltt_channel_buf_struct *lttbuf = chan->buf; +// long consumed_old; +// +// result = fd = open("trace.out", O_WRONLY | O_CREAT | O_TRUNC, 00644); +// if(result == -1) { +// perror("open"); +// return -1; +// } + +// for(;;) { +// write(STDOUT_FILENO, str, sizeof(str)); +// +// result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old); +// if(result < 0) { +// CPRINTF("ltt_do_get_subbuf: error: %s", strerror(-result)); +// } +// else { +// CPRINTF("success!"); +// +// result = write(fd, rbuf->buf_data + (consumed_old & (2 * 4096-1)), 4096); +// ltt_do_put_subbuf(rbuf, lttbuf, consumed_old); +// } +// +// //CPRINTF("There seems to be %ld bytes available", SUBBUF_TRUNC(local_read(<tbuf->offset), rbuf->chan) - consumed_old); +// CPRINTF("Commit count %ld", local_read(<tbuf->commit_count[0])); +// +// +// sleep(1); +// } } void start_consumer(void) @@ -144,6 +196,7 @@ int init_int_handler(void) int main() { int result; + int i; init_int_handler(); @@ -162,7 +215,9 @@ int main() //result = ltt_marker_connect("metadata", "testev", "default"); //if(result) // ERR("ltt_marker_connect"); - + result = ltt_marker_connect("foo", "bar", "default"); + if(result) + ERR("ltt_marker_connect"); result = ltt_trace_setup(trace_name); if(result < 0) { @@ -192,19 +247,23 @@ int main() printf("Hello, World!\n"); sleep(1); - for(;;) { + for(i=0; i<50; i++) { //trace_mark(abc, testmark, "", MARK_NOARGS); //trace_mark(metadata, testev, "", MARK_NOARGS); - trace_mark(metadata, core_marker_id, - "channel %s name %s event_id %hu " - "int #1u%zu long #1u%zu pointer #1u%zu " - "size_t #1u%zu alignment #1u%u", - "abc", "def", (unsigned short)1000, - sizeof(int), sizeof(long), sizeof(void *), - sizeof(size_t), ltt_get_alignment()); + trace_mark(foo, bar, "%s", "FOOBAZ"); + //trace_mark(metadata, core_marker_id, + // "channel %s name %s event_id %hu " + // "int #1u%zu long #1u%zu pointer #1u%zu " + // "size_t #1u%zu alignment #1u%u", + // "abc", "def", (unsigned short)1000, + // sizeof(int), sizeof(long), sizeof(void *), + // sizeof(size_t), ltt_get_alignment()); usleep(100000); } + ltt_trace_stop(trace_name); + ltt_trace_destroy(trace_name); + scanf("%*s"); return 0; diff --git a/libmarkers/marker.c b/libmarkers/marker.c index 980cf39..d31f2cf 100644 --- a/libmarkers/marker.c +++ b/libmarkers/marker.c @@ -1061,14 +1061,14 @@ static void marker_get_iter(struct marker_iter *iter) int found = 0; /* Core kernel markers */ - if (!iter->module) { + if (!iter->lib) { found = marker_get_iter_range(&iter->marker, __start___markers, __stop___markers); if (found) goto end; } /* Markers in modules. */ -//ust// found = module_get_iter_markers(iter); + found = lib_get_iter_markers(iter); end: if (!found) marker_iter_reset(iter); @@ -1099,7 +1099,7 @@ void marker_iter_stop(struct marker_iter *iter) void marker_iter_reset(struct marker_iter *iter) { - iter->module = NULL; + iter->lib = NULL; iter->marker = NULL; } //ust// EXPORT_SYMBOL_GPL(marker_iter_reset); @@ -1412,3 +1412,49 @@ void ltt_dump_marker_state(struct ltt_trace_struct *trace) marker_iter_stop(&iter); } //ust// EXPORT_SYMBOL_GPL(ltt_dump_marker_state); + + +static LIST_HEAD(libs); + +/* + * Returns 0 if current not found. + * Returns 1 if current found. + */ +int lib_get_iter_markers(struct marker_iter *iter) +{ + struct lib *iter_lib; + int found = 0; + +//ust// mutex_lock(&module_mutex); + list_for_each_entry(iter_lib, &libs, list) { + if (iter_lib < iter->lib) + continue; + else if (iter_lib > iter->lib) + iter->marker = NULL; + found = marker_get_iter_range(&iter->marker, + iter_lib->markers_start, + iter_lib->markers_start + iter_lib->markers_count); + if (found) { + iter->lib = iter_lib; + break; + } + } +//ust// mutex_unlock(&module_mutex); + return found; +} + +int marker_register_lib(struct marker *markers_start, int markers_count) +{ + struct lib *pl; + + pl = (struct lib *) malloc(sizeof(struct lib)); + + pl->markers_start = markers_start; + pl->markers_count = markers_count; + + list_add(&pl->list, &libs); + + printf("just registered a markers section from %p and having %d markers\n", markers_start, markers_count); + + return 0; +} diff --git a/libmarkers/marker.h b/libmarkers/marker.h index 5fdd66f..f26bcac 100644 --- a/libmarkers/marker.h +++ b/libmarkers/marker.h @@ -19,6 +19,7 @@ //ust// #include #include "kernelcompat.h" #include "compiler.h" +#include "list.h" //ust// struct module; //ust// struct task_struct; @@ -251,7 +252,8 @@ extern void *marker_get_private_data(const char *channel, const char *name, #define marker_synchronize_unregister() synchronize_sched() struct marker_iter { - struct module *module; +//ust// struct module *module; + struct lib *lib; struct marker *marker; }; @@ -273,4 +275,12 @@ extern int is_marker_enabled(const char *channel, const char *name); //ust// } //ust// #endif + +struct lib { + struct marker *markers_start; + int markers_count; + struct list_head list; +}; + + #endif diff --git a/libtracectl/tracectl.c b/libtracectl/tracectl.c index aca3abc..46874d4 100644 --- a/libtracectl/tracectl.c +++ b/libtracectl/tracectl.c @@ -4,6 +4,7 @@ #include #include #include +#include #define UNIX_PATH_MAX 108 //#define SOCKETDIR "/var/run/ust/socks" @@ -16,14 +17,32 @@ #define ERR(fmt, args...) fprintf(stderr, "usertrace: ERROR: " fmt "\n", ## args) #define PERROR(call) perror("usertrace: ERROR: " call) +#define MAX_MSG_SIZE (100) +#define MSG_NOTIF 1 +#define MSG_REGISTER_NOTIF 2 + struct tracecmd { /* no padding */ uint32_t size; uint16_t command; }; +//struct listener_arg { +// int pipe_fd; +//}; + +struct trctl_msg { + /* size: the size of all the fields except size itself */ + uint32_t size; + uint16_t type; + /* Only the necessary part of the payload is transferred. It + * may even be none of it. + */ + char payload[94]; +}; pid_t mypid; char mysocketfile[UNIX_PATH_MAX] = ""; +int pfd = -1; void do_command(struct tracecmd *cmd) { @@ -33,6 +52,94 @@ void receive_commands() { } +int fd_notif = -1; +void notif_cb(void) +{ + int result; + struct trctl_msg msg; + + /* FIXME: fd_notif should probably be protected by a spinlock */ + + if(fd_notif == -1) + return; + + msg.type = MSG_NOTIF; + msg.size = sizeof(msg.type); + + /* FIXME: don't block here */ + result = write(fd_notif, &msg, msg.size+sizeof(msg.size)); + if(result == -1) { + PERROR("write"); + return; + } +} + +int listener_main(void *p) +{ + int result; + + /* Allowing only 1 connection for now. */ + result = listen(pfd, 1); + if(result == -1) { + PERROR("listen"); + return 1; + } + + for(;;) { + + uint32_t size; + int fd; + struct sockaddr_un addr; + socklen_t addrlen = sizeof(addr); + + result = fd = accept(pfd, (struct sockaddr *)&addr, &addrlen); + if(result == -1) { + PERROR("accept"); + continue; + } + + for(;;) { + struct trctl_msg msg; + unsigned char dontclose=0; + + result = read(fd, &msg.size, sizeof(msg.size)); + if(result == -1) { + PERROR("read"); + continue; + } + + if(size > MAX_MSG_SIZE) { + ERR("trctl message too big"); + break; + } + + result = read(fd, &msg.type, sizeof(msg.type)); + if(result == -1) { + PERROR("read"); + continue; + } + + switch(msg.type) { + case MSG_REGISTER_NOTIF: + /* TODO: put it in notif mode */ + goto next_conn; + }; + } + next_conn:; + } +} + +void create_listener(void) +{ + int result; + static char listener_stack[16384]; + + result = clone(listener_main, listener_stack+sizeof(listener_stack)-1, CLONE_FS | CLONE_FILES | CLONE_VM, NULL); + if(result == -1) { + perror("clone"); + } +} + /* The signal handler itself. */ void sighandler(int sig) @@ -43,12 +150,12 @@ void sighandler(int sig) /* Called by the app signal handler to chain it to us. */ -void chain_signal() +void chain_signal(void) { sighandler(USTSIGNAL); } -int init_socket() +static int init_socket(void) { int result; int fd; @@ -80,13 +187,16 @@ int init_socket() strcpy(mysocketfile, addr.sun_path); + pfd = fd; + return 0; + close_sock: close(fd); return -1; } -void destroy_socket() +static void destroy_socket(void) { int result; @@ -99,7 +209,7 @@ void destroy_socket() } } -int init_signal_handler(void) +static int init_signal_handler(void) { /* Attempt to handler SIGIO. If the main program wants to * handle it, fine, it'll override us. They it'll have to @@ -130,15 +240,25 @@ int init_signal_handler(void) return 0; } -void __attribute__((constructor)) init() +static void __attribute__((constructor)) init() { int result; mypid = getpid(); - /* if using instead seperate thread, then should create thread */ - result = init_signal_handler(); + /* Must create socket before signal handler to prevent races + * on pfd variable. + */ result = init_socket(); + if(result == -1) { + ERR("init_socket error"); + return; + } + result = init_signal_handler(); + if(result == -1) { + ERR("init_signal_handler error"); + return; + } return; @@ -149,7 +269,7 @@ void __attribute__((constructor)) init() /* This is only called if we terminate normally, not with an unhandled signal, * so we cannot rely on it. */ -void __attribute__((destructor)) fini() +static void __attribute__((destructor)) fini() { destroy_socket(); } diff --git a/libtracing/relay.c b/libtracing/relay.c index 0f503a8..ad22727 100644 --- a/libtracing/relay.c +++ b/libtracing/relay.c @@ -181,7 +181,7 @@ static void relay_destroy_buf(struct rchan_buf *buf) static void relay_remove_buf(struct kref *kref) { struct rchan_buf *buf = container_of(kref, struct rchan_buf, kref); - buf->chan->cb->remove_buf_file(buf); +//ust// buf->chan->cb->remove_buf_file(buf); relay_destroy_buf(buf); } diff --git a/libtracing/relay.h b/libtracing/relay.h index 54bd2b9..80f0b6b 100644 --- a/libtracing/relay.h +++ b/libtracing/relay.h @@ -143,7 +143,7 @@ struct rchan_callbacks { * * The callback should return 0 if successful, negative if not. */ - int (*remove_buf_file)(struct rchan_buf *buf); +//ust// int (*remove_buf_file)(struct rchan_buf *buf); }; extern struct buf_page *ltt_relay_find_prev_page(struct rchan_buf *buf, diff --git a/libtracing/tracer.c b/libtracing/tracer.c index 81c2925..ea156f6 100644 --- a/libtracing/tracer.c +++ b/libtracing/tracer.c @@ -838,6 +838,7 @@ static void __ltt_trace_destroy(struct ltt_trace_struct *trace) trace->ops->finish_channel(chan); } + return; /* FIXME: temporary for ust */ //ust// flush_scheduled_work(); /* diff --git a/share/kernelcompat.h b/share/kernelcompat.h index ee676de..9139e75 100644 --- a/share/kernelcompat.h +++ b/share/kernelcompat.h @@ -290,19 +290,39 @@ static __inline__ int get_count_order(unsigned int count) /* TRACE CLOCK */ +//ust// static inline u64 trace_clock_read64(void) +//ust// { +//ust// uint32_t low; +//ust// uint32_t high; +//ust// uint64_t retval; +//ust// __asm__ volatile ("rdtsc\n" : "=a" (low), "=d" (high)); +//ust// +//ust// retval = high; +//ust// retval <<= 32; +//ust// return retval | low; +//ust// } + static inline u64 trace_clock_read64(void) { - return 0LL; + struct timeval tv; + u64 retval; + + gettimeofday(&tv, NULL); + retval = tv.tv_sec; + retval *= 1000000; + retval += tv.tv_usec; + + return retval; } -static inline unsigned int trace_clock_frequency(void) +static inline u64 trace_clock_frequency(void) { - return 0LL; + return 1000000LL; } static inline u32 trace_clock_freq_scale(void) { - return 0; + return 1; } -- 2.34.1