From mboxrd@z Thu Jan 1 00:00:00 1970 From: nils.carlson@ludd.ltu.se (Nils Carlson) Date: Thu, 4 Nov 2010 20:18:14 +0100 Subject: [ltt-dev] [UST PATCH] Remove //ust commented code In-Reply-To: <4CD038B3.3080902@polymtl.ca> References: <1288606194-30478-1-git-send-email-nils.carlson@ericsson.com> <4CD038B3.3080902@polymtl.ca> Message-ID: <70539912-894A-4388-8A55-3F595F2DF745@ludd.ltu.se> On Nov 2, 2010, at 5:13 PM, David Goulet wrote: > Hi Nils, > > I remember talking about that with Pierre-Marc and he raised an > interesting concern about that. He suggested that we should > *strongly* review the code around these comments to double check for > correct implementation and possible errors. I will agree that this > is quite a pain to do but I do agree with that. > > Don't you have any intern over there @Ericsson :P ? > Sorry... Last summer we had a summer intern, but this year we didn't. But I think I'll agree with you for now. I need to clean some of these things up for the multi-session support anyway. /Nils > David > > On 10-11-01 06:09 AM, Nils Carlson wrote: >> I don't like keeping it around, makes grepping a pain. I've made >> a new TODO and added a FIXME or two, but there's a lot more >> potential/work here. >> >> Signed-off-by: Nils Carlson >> --- >> TODO | 1 + >> libust/buffers.c | 125 ++----------------------- >> libust/buffers.h | 23 +---- >> libust/channels.c | 12 --- >> libust/marker-control.c | 196 >> +--------------------------------------- >> libust/marker.c | 154 ++++--------------------------- >> libust/serialize.c | 11 +-- >> libust/tracepoint.c | 73 +-------------- >> libust/tracer.c | 230 ++ >> +------------------------------------------- >> libust/tracer.h | 2 +- >> libust/tracercore.c | 2 - >> libust/type-serializer.c | 2 - >> 12 files changed, 50 insertions(+), 781 deletions(-) >> >> diff --git a/TODO b/TODO >> index 46d5b64..ef8f3d0 100644 >> --- a/TODO >> +++ b/TODO >> @@ -25,3 +25,4 @@ >> This is to guarantee there will never be a system call in the >> tracing path. Currently there is a system >> call when the buffer is full to notify the listener it can be >> collected. >> - In early tracing mode, the only channels that can be used >> reliably are "metadata" and "ust". The "usttrace" tool always uses >> early tracing and is hence subject to this limitation. Traces setup >> with the "ustctl" tool ("manual mode") are not subject to this >> limitation and can contain channels that have any name. Also, when >> loading a library with dlopen(), in order for markers in the >> library to generate events in the trace, these markers must be in >> the same channel as an event that was in the executable or its >> dynamically linked libraries that were loaded at start time. If >> using early tracing, only the "ust" channel can be used. Fix this. >> (RCU locking of channel structures in progress by Mathieu Desnoyers) >> +- There was event_id compacting stuff earlier, maybe reintroduce? >> diff --git a/libust/buffers.c b/libust/buffers.c >> index bb5d8c5..2f6b760 100644 >> --- a/libust/buffers.c >> +++ b/libust/buffers.c >> @@ -217,7 +217,6 @@ static void ust_buffers_destroy_buf(struct >> ust_buffer *buf) >> PERROR("munmap"); >> } >> >> -//ust// chan->buf[buf->cpu] = NULL; >> free(buf); >> kref_put(&chan->kref, ust_buffers_destroy_channel); >> } >> @@ -316,8 +315,7 @@ void ust_buffers_channel_close(struct >> ust_channel *chan) >> for(i=0; in_cpus; i++) { >> /* FIXME: if we make it here, then all buffers were necessarily >> allocated. Moreover, we don't >> * initialize to NULL so we cannot use this check. Should we? */ >> -//ust// if (chan->buf[i]) >> - ust_buffers_close_buf(chan->buf[i]); >> + ust_buffers_close_buf(chan->buf[i]); >> } >> >> list_del(&chan->list); >> @@ -385,22 +383,10 @@ static notrace void ltt_buf_unfull(struct >> ust_buffer *buf, >> { >> } >> >> -/* >> - * Promote compiler barrier to a smp_mb(). >> - * For the specific LTTng case, this IPI call should be removed if >> the >> - * architecture does not reorder writes. This should eventually >> be provided by >> - * a separate architecture-specific infrastructure. >> - */ >> -//ust// static void remote_mb(void *info) >> -//ust// { >> -//ust// smp_mb(); >> -//ust// } >> - >> int ust_buffers_get_subbuf(struct ust_buffer *buf, long *consumed) >> { >> struct ust_channel *channel = buf->chan; >> long consumed_old, consumed_idx, commit_count, write_offset; >> -//ust// int retval; >> >> consumed_old = uatomic_read(&buf->consumed); >> consumed_idx = SUBBUF_INDEX(consumed_old, buf->chan); >> @@ -442,19 +428,12 @@ int ust_buffers_get_subbuf(struct ust_buffer >> *buf, long *consumed) >> * really have to ensure total order between the 3 barriers >> running on >> * the 2 CPUs. >> */ >> -//ust// #ifdef LTT_NO_IPI_BARRIER >> + >> /* >> * Local rmb to match the remote wmb to read the commit count >> before the >> * buffer data and the write offset. >> */ >> smp_rmb(); >> -//ust// #else >> -//ust// if (raw_smp_processor_id() != buf->cpu) { >> -//ust// smp_mb(); /* Total order with IPI handler smp_mb() */ >> -//ust// smp_call_function_single(buf->cpu, remote_mb, NULL, 1); >> -//ust// smp_mb(); /* Total order with IPI handler smp_mb() */ >> -//ust// } >> -//ust// #endif >> >> write_offset = uatomic_read(&buf->offset); >> /* >> @@ -478,11 +457,6 @@ int ust_buffers_get_subbuf(struct ust_buffer >> *buf, long *consumed) >> return -EAGAIN; >> } >> >> - /* FIXME: is this ok to disable the reading feature? */ >> -//ust// retval = update_read_sb_index(buf, consumed_idx); >> -//ust// if (retval) >> -//ust// return retval; >> - >> *consumed = consumed_old; >> >> return 0; >> @@ -497,14 +471,12 @@ int ust_buffers_put_subbuf(struct ust_buffer >> *buf, unsigned long uconsumed_old) >> consumed_old = consumed_old | uconsumed_old; >> consumed_new = SUBBUF_ALIGN(consumed_old, buf->chan); >> >> -//ust// spin_lock(<t_buf->full_lock); >> if (uatomic_cmpxchg(&buf->consumed, consumed_old, >> consumed_new) >> != consumed_old) { >> /* We have been pushed by the writer : the last >> * buffer read _is_ corrupted! It can also >> * happen if this is a buffer we never got. */ >> -//ust// spin_unlock(<t_buf->full_lock); >> return -EIO; >> } else { >> /* tell the client that buffer is now unfull */ >> @@ -513,7 +485,6 @@ int ust_buffers_put_subbuf(struct ust_buffer >> *buf, unsigned long uconsumed_old) >> index = SUBBUF_INDEX(consumed_old, buf->chan); >> data = BUFFER_OFFSET(consumed_old, buf->chan); >> ltt_buf_unfull(buf, index, data); >> -//ust// spin_unlock(<t_buf->full_lock); >> } >> return 0; >> } >> @@ -562,9 +533,6 @@ static void ltt_relay_print_errors(struct >> ust_trace *trace, >> if (!channel) >> return; >> >> -//ust// for (cons_off = 0; cons_off< rchan->alloc_size; >> -//ust// cons_off = SUBBUF_ALIGN(cons_off, rchan)) >> -//ust// ust_buffers_print_written(ltt_chan, cons_off, cpu); >> for (cons_off = uatomic_read(<t_buf->consumed); >> (SUBBUF_TRUNC(uatomic_read(<t_buf->offset), >> channel) >> @@ -597,45 +565,6 @@ static void ltt_relay_release_channel(struct >> kref *kref) >> free(ltt_chan->buf); >> } >> >> -/* >> - * Create ltt buffer. >> - */ >> -//ust// static int ltt_relay_create_buffer(struct ust_trace *trace, >> -//ust// struct ltt_channel_struct *ltt_chan, struct rchan_buf >> *buf, >> -//ust// unsigned int cpu, unsigned int n_subbufs) >> -//ust// { >> -//ust// struct ltt_channel_buf_struct *ltt_buf = >> -//ust// percpu_ptr(ltt_chan->buf, cpu); >> -//ust// unsigned int j; >> -//ust// >> -//ust// ltt_buf->commit_count = >> -//ust// kzalloc_node(sizeof(ltt_buf->commit_count) * n_subbufs, >> -//ust// GFP_KERNEL, cpu_to_node(cpu)); >> -//ust// if (!ltt_buf->commit_count) >> -//ust// return -ENOMEM; >> -//ust// kref_get(&trace->kref); >> -//ust// kref_get(&trace->ltt_transport_kref); >> -//ust// kref_get(<t_chan->kref); >> -//ust// uatomic_set(<t_buf->offset, ltt_subbuffer_header_size()); >> -//ust// uatomic_set(<t_buf->consumed, 0); >> -//ust// uatomic_set(<t_buf->active_readers, 0); >> -//ust// for (j = 0; j< n_subbufs; j++) >> -//ust// uatomic_set(<t_buf->commit_count[j], 0); >> -//ust// init_waitqueue_head(<t_buf->write_wait); >> -//ust// uatomic_set(<t_buf->wakeup_readers, 0); >> -//ust// spin_lock_init(<t_buf->full_lock); >> -//ust// >> -//ust// ltt_buffer_begin_callback(buf, trace->start_tsc, 0); >> -//ust// /* atomic_add made on local variable on data that belongs >> to >> -//ust// * various CPUs : ok because tracing not started (for >> this cpu). */ >> -//ust// uatomic_add(<t_buf->commit_count[0], >> ltt_subbuffer_header_size()); >> -//ust// >> -//ust// uatomic_set(<t_buf->events_lost, 0); >> -//ust// uatomic_set(<t_buf->corrupted_subbuffers, 0); >> -//ust// >> -//ust// return 0; >> -//ust// } >> - >> static int ust_buffers_init_buffer(struct ust_trace *trace, >> struct ust_channel *ltt_chan, struct ust_buffer *buf, >> unsigned int n_subbufs) >> @@ -658,9 +587,6 @@ static int ust_buffers_init_buffer(struct >> ust_trace *trace, >> uatomic_set(&buf->commit_count[j].cc, 0); >> uatomic_set(&buf->commit_count[j].cc_sb, 0); >> } >> -//ust// init_waitqueue_head(&buf->write_wait); >> -//ust// uatomic_set(&buf->wakeup_readers, 0); >> -//ust// spin_lock_init(&buf->full_lock); >> >> ltt_buffer_begin(buf, trace->start_tsc, 0); >> >> @@ -677,10 +603,6 @@ static int ust_buffers_init_buffer(struct >> ust_trace *trace, >> buf->data_ready_fd_read = fds[0]; >> buf->data_ready_fd_write = fds[1]; >> >> -//ust// buf->commit_seq = malloc(sizeof(buf->commit_seq) * >> n_subbufs); >> -//ust// if(!ltt_buf->commit_seq) { >> -//ust// return -1; >> -//ust// } >> memset(buf->commit_seq, 0, sizeof(buf->commit_seq[0]) * n_subbufs); >> >> /* FIXME: decrementally destroy on error */ >> @@ -697,12 +619,12 @@ static void ust_buffers_destroy_buffer(struct >> ust_channel *ltt_chan, int cpu) >> kref_put(<t_chan->trace->ltt_transport_kref, >> ltt_release_transport); >> ltt_relay_print_buffer_errors(ltt_chan, cpu); >> -//ust// free(ltt_buf->commit_seq); >> + >> free(ltt_buf->commit_count); >> ltt_buf->commit_count = NULL; >> kref_put(<t_chan->kref, ltt_relay_release_channel); >> kref_put(&trace->kref, ltt_release_trace); >> -//ust// wake_up_interruptible(&trace->kref_wq); >> + >> } >> >> static int ust_buffers_alloc_channel_buf_structs(struct >> ust_channel *chan) >> @@ -776,7 +698,7 @@ static int ust_buffers_create_channel(const >> char *trace_name, struct ust_trace * >> ltt_chan->n_subbufs_order = get_count_order(n_subbufs); >> ltt_chan->commit_count_mask = (~0UL>> ltt_chan->n_subbufs_order); >> ltt_chan->n_cpus = get_n_cpus(); >> -//ust// ltt_chan->buf = percpu_alloc_mask(sizeof(struct >> ltt_channel_buf_struct), GFP_KERNEL, cpu_possible_map); >> + >> ltt_chan->buf = (void *) zmalloc(ltt_chan->n_cpus * sizeof(void >> *)); >> if(ltt_chan->buf == NULL) { >> goto error; >> @@ -811,37 +733,13 @@ error: >> return -1; >> } >> >> -static void ltt_relay_async_wakeup_chan(struct ust_channel >> *ltt_channel) >> -{ >> -//ust// unsigned int i; >> -//ust// struct rchan *rchan = ltt_channel->trans_channel_data; >> -//ust// >> -//ust// for_each_possible_cpu(i) { >> -//ust// struct ltt_channel_buf_struct *ltt_buf = >> -//ust// percpu_ptr(ltt_channel->buf, i); >> -//ust// >> -//ust// if (uatomic_read(<t_buf->wakeup_readers) == 1) { >> -//ust// uatomic_set(<t_buf->wakeup_readers, 0); >> -//ust// wake_up_interruptible(&rchan->buf[i]->read_wait); >> -//ust// } >> -//ust// } >> -} >> >> static void ltt_relay_finish_buffer(struct ust_channel *channel, >> unsigned int cpu) >> { >> -// int result; >> - >> if (channel->buf[cpu]) { >> struct ust_buffer *buf = channel->buf[cpu]; >> ltt_force_switch(buf, FORCE_FLUSH); >> -//ust// ltt_relay_wake_writers(ltt_buf); >> - /* closing the pipe tells the consumer the buffer is finished */ >> - >> - //result = write(ltt_buf->data_ready_fd_write, "D", 1); >> - //if(result == -1) { >> - // PERROR("write (in ltt_relay_finish_buffer)"); >> - // ERR("this should never happen!"); >> - //} >> + >> close(buf->data_ready_fd_write); >> } >> } >> @@ -1082,14 +980,12 @@ void ltt_force_switch_lockless_slow(struct >> ust_buffer *buf, >> */ >> if (mode == FORCE_ACTIVE) { >> ltt_reserve_push_reader(chan, buf, offsets.end - 1); >> -//ust// ltt_clear_noref_flag(chan, buf, SUBBUF_INDEX(offsets.end >> - 1, chan)); >> } >> >> /* >> * Switch old subbuffer if needed. >> */ >> if (offsets.end_switch_old) { >> -//ust// ltt_clear_noref_flag(rchan, buf, SUBBUF_INDEX(offsets.old >> - 1, rchan)); >> ltt_reserve_switch_old_subbuf(chan, buf,&offsets,&tsc); >> } >> >> @@ -1268,15 +1164,9 @@ int ltt_reserve_slot_lockless_slow(struct >> ust_channel *chan, >> ltt_reserve_push_reader(chan, buf, offsets.end - 1); >> >> /* >> - * Clear noref flag for this subbuffer. >> - */ >> -//ust// ltt_clear_noref_flag(chan, buf, SUBBUF_INDEX(offsets.end - >> 1, chan)); >> - >> - /* >> * Switch old subbuffer if needed. >> */ >> if (unlikely(offsets.end_switch_old)) { >> -//ust// ltt_clear_noref_flag(chan, buf, SUBBUF_INDEX(offsets.old >> - 1, chan)); >> ltt_reserve_switch_old_subbuf(chan, buf,&offsets, tsc); >> DBG("Switching %s_%d", chan->channel_name, cpu); >> } >> @@ -1301,7 +1191,8 @@ static struct ltt_transport >> ust_relay_transport = { >> .create_channel = ust_buffers_create_channel, >> .finish_channel = ltt_relay_finish_channel, >> .remove_channel = ltt_relay_remove_channel, >> - .wakeup_channel = ltt_relay_async_wakeup_chan, >> + /* FIXME: No such function, is it needed? */ >> + .wakeup_channel = NULL, >> }, >> }; >> >> diff --git a/libust/buffers.h b/libust/buffers.h >> index a2ad83e..562f096 100644 >> --- a/libust/buffers.h >> +++ b/libust/buffers.h >> @@ -89,7 +89,7 @@ struct ust_buffer { >> struct list_head open_buffers_list; >> >> unsigned int finalized; >> -//ust// struct timer_list switch_timer; /* timer for periodical >> switch */ >> + >> unsigned long switch_timer_interval; /* 0 = unset */ >> >> struct ust_channel *chan; >> @@ -255,7 +255,7 @@ static __inline__ void ltt_check_deliver(struct >> ust_channel *chan, >> /* >> * Set noref flag for this subbuffer. >> */ >> -//ust// ltt_set_noref_flag(rchan, buf, idx); >> + >> ltt_vmcore_check_deliver(buf, commit_count, idx); >> >> /* wakeup consumer */ >> @@ -324,12 +324,6 @@ static __inline__ int ltt_relay_try_reserve( >> >> *tsc = trace_clock_read64(); >> >> -//ust// #ifdef CONFIG_LTT_VMCORE >> -//ust// prefetch(&buf->commit_count[SUBBUF_INDEX(*o_begin, >> rchan)]); >> -//ust// prefetch(&buf->commit_seq[SUBBUF_INDEX(*o_begin, rchan)]); >> -//ust// #else >> -//ust// prefetchw(&buf->commit_count[SUBBUF_INDEX(*o_begin, >> rchan)]); >> -//ust// #endif >> if (last_tsc_overflow(buf, *tsc)) >> *rflags = LTT_RFLAG_ID_SIZE_TSC; >> >> @@ -403,11 +397,6 @@ static __inline__ int ltt_reserve_slot(struct >> ust_channel *chan, >> */ >> ltt_reserve_push_reader(chan, buf, o_end - 1); >> >> - /* >> - * Clear noref flag for this subbuffer. >> - */ >> -//ust// ltt_clear_noref_flag(chan, buf, SUBBUF_INDEX(o_end - 1, >> chan)); >> - >> *buf_offset = o_begin + before_hdr_pad; >> return 0; >> slow_path: >> @@ -434,7 +423,7 @@ static __inline__ void ltt_force_switch(struct >> ust_buffer *buf, >> * commit count reaches back the reserve offset (module subbuffer >> size). It is >> * useful for crash dump. >> */ >> -//ust// #ifdef CONFIG_LTT_VMCORE >> + >> static __inline__ void ltt_write_commit_counter(struct ust_channel >> *chan, >> struct ust_buffer *buf, long idx, long buf_offset, >> long commit_count, size_t data_size) >> @@ -460,12 +449,6 @@ static __inline__ void >> ltt_write_commit_counter(struct ust_channel *chan, >> >> DBG("commit_seq for channel %s_%d, subbuf %ld is now %ld", buf- >> >chan->channel_name, buf->cpu, idx, commit_count); >> } >> -//ust// #else >> -//ust// static __inline__ void ltt_write_commit_counter(struct >> ust_buffer *buf, >> -//ust// long idx, long buf_offset, long commit_count, size_t >> data_size) >> -//ust// { >> -//ust// } >> -//ust// #endif >> >> /* >> * Atomic unordered slot commit. Increments the commit count in the >> diff --git a/libust/channels.c b/libust/channels.c >> index 57e9801..b454ecc 100644 >> --- a/libust/channels.c >> +++ b/libust/channels.c >> @@ -80,8 +80,6 @@ static void release_channel_setting(struct kref >> *kref) >> iter->index = free_index++; >> iter->free_event_id = 0; >> } >> - /* FIXME: why not run this? */ >> -//ust// markers_compact_event_ids(); >> } >> } >> >> @@ -133,7 +131,6 @@ end: >> pthread_mutex_unlock(<t_channel_mutex); >> return ret; >> } >> -//ust// EXPORT_SYMBOL_GPL(ltt_channels_register); >> >> /** >> * ltt_channels_unregister - Unregister a trace channel. >> @@ -157,7 +154,6 @@ end: >> pthread_mutex_unlock(<t_channel_mutex); >> return ret; >> } >> -//ust// EXPORT_SYMBOL_GPL(ltt_channels_unregister); >> >> /** >> * ltt_channels_set_default - Set channel default behavior. >> @@ -184,7 +180,6 @@ end: >> pthread_mutex_unlock(<t_channel_mutex); >> return ret; >> } >> -//ust// EXPORT_SYMBOL_GPL(ltt_channels_set_default); >> >> /** >> * ltt_channels_get_name_from_index - get channel name from >> channel index >> @@ -202,7 +197,6 @@ const char >> *ltt_channels_get_name_from_index(unsigned int index) >> return iter->name; >> return NULL; >> } >> -//ust// EXPORT_SYMBOL_GPL(ltt_channels_get_name_from_index); >> >> static struct ltt_channel_setting * >> ltt_channels_get_setting_from_name(const char *name) >> @@ -234,7 +228,6 @@ int ltt_channels_get_index_from_name(const char >> *name) >> else >> return -1; >> } >> -//ust// EXPORT_SYMBOL_GPL(ltt_channels_get_index_from_name); >> >> /** >> * ltt_channels_trace_alloc - Allocate channel structures for a >> trace >> @@ -283,7 +276,6 @@ end: >> pthread_mutex_unlock(<t_channel_mutex); >> return channel; >> } >> -//ust// EXPORT_SYMBOL_GPL(ltt_channels_trace_alloc); >> >> /** >> * ltt_channels_trace_free - Free one trace's channels >> @@ -301,7 +293,6 @@ void ltt_channels_trace_free(struct ust_channel >> *channels) >> pthread_mutex_unlock(<t_channel_mutex); >> unlock_markers(); >> } >> -//ust// EXPORT_SYMBOL_GPL(ltt_channels_trace_free); >> >> /** >> * _ltt_channels_get_event_id - get next event ID for a marker >> @@ -358,6 +349,3 @@ int ltt_channels_get_event_id(const char >> *channel, const char *name) >> return ret; >> } >> >> -//ust// MODULE_LICENSE("GPL"); >> -//ust// MODULE_AUTHOR("Mathieu Desnoyers"); >> -//ust// MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation >> Channel Management"); >> diff --git a/libust/marker-control.c b/libust/marker-control.c >> index db7311a..0ffa2f0 100644 >> --- a/libust/marker-control.c >> +++ b/libust/marker-control.c >> @@ -46,17 +46,12 @@ struct ltt_available_probe default_probe = { >> .callbacks[0] = ltt_serialize_data, >> }; >> >> -//ust//static struct kmem_cache *markers_loaded_cachep; >> static LIST_HEAD(markers_loaded_list); >> /* >> * List sorted by name strcmp order. >> */ >> static LIST_HEAD(probes_registered_list); >> >> -//ust// static struct proc_dir_entry *pentry; >> - >> -//ust// static struct file_operations ltt_fops; >> - >> static struct ltt_available_probe *get_probe_from_name(const char >> *pname) >> { >> struct ltt_available_probe *iter; >> @@ -77,30 +72,6 @@ static struct ltt_available_probe >> *get_probe_from_name(const char *pname) >> return NULL; >> } >> >> -/* (unused) >> -static char *skip_spaces(char *buf) >> -{ >> - while (*buf != '\0'&& isspace(*buf)) >> - buf++; >> - return buf; >> -} >> - >> -static char *skip_nonspaces(char *buf) >> -{ >> - while (*buf != '\0'&& !isspace(*buf)) >> - buf++; >> - return buf; >> -} >> - >> -static void get_marker_string(char *buf, char **start, >> - char **end) >> -{ >> - *start = skip_spaces(buf); >> - *end = skip_nonspaces(*start); >> - **end = '\0'; >> -} >> -*/ >> - >> int ltt_probe_register(struct ltt_available_probe *pdata) >> { >> int ret = 0; >> @@ -235,158 +206,6 @@ end: >> return ret; >> } >> >> -/* >> - * function handling proc entry write. >> - * >> - * connect []] >> - * disconnect [] >> - */ >> -//ust// static ssize_t ltt_write(struct file *file, const char >> __user *buffer, >> -//ust// size_t count, loff_t *offset) >> -//ust// { >> -//ust// char *kbuf; >> -//ust// char *iter, *marker_action, *arg[4]; >> -//ust// ssize_t ret; >> -//ust// int i; >> -//ust// >> -//ust// if (!count) >> -//ust// return -EINVAL; >> -//ust// >> -//ust// kbuf = vmalloc(count + 1); >> -//ust// kbuf[count] = '\0'; /* Transform into a string */ >> -//ust// ret = copy_from_user(kbuf, buffer, count); >> -//ust// if (ret) { >> -//ust// ret = -EINVAL; >> -//ust// goto end; >> -//ust// } >> -//ust// get_marker_string(kbuf,&marker_action,&iter); >> -//ust// if (!marker_action || marker_action == iter) { >> -//ust// ret = -EINVAL; >> -//ust// goto end; >> -//ust// } >> -//ust// for (i = 0; i< 4; i++) { >> -//ust// arg[i] = NULL; >> -//ust// if (iter< kbuf + count) { >> -//ust// iter++; /* skip the added '\0' */ >> -//ust// get_marker_string(iter,&arg[i],&iter); >> -//ust// if (arg[i] == iter) >> -//ust// arg[i] = NULL; >> -//ust// } >> -//ust// } >> -//ust// >> -//ust// if (!arg[0] || !arg[1]) { >> -//ust// ret = -EINVAL; >> -//ust// goto end; >> -//ust// } >> -//ust// >> -//ust// if (!strcmp(marker_action, "connect")) { >> -//ust// ret = ltt_marker_connect(arg[0], arg[1], arg[2]); >> -//ust// if (ret) >> -//ust// goto end; >> -//ust// } else if (!strcmp(marker_action, "disconnect")) { >> -//ust// ret = ltt_marker_disconnect(arg[0], arg[1], arg[2]); >> -//ust// if (ret) >> -//ust// goto end; >> -//ust// } >> -//ust// ret = count; >> -//ust// end: >> -//ust// vfree(kbuf); >> -//ust// return ret; >> -//ust// } >> -//ust// >> -//ust// static void *s_next(struct seq_file *m, void *p, loff_t >> *pos) >> -//ust// { >> -//ust// struct marker_iter *iter = m->private; >> -//ust// >> -//ust// marker_iter_next(iter); >> -//ust// if (!iter->marker) { >> -//ust// /* >> -//ust// * Setting the iter module to -1UL will make sure >> -//ust// * that no module can possibly hold the current marker. >> -//ust// */ >> -//ust// iter->module = (void *)-1UL; >> -//ust// return NULL; >> -//ust// } >> -//ust// return iter->marker; >> -//ust// } >> -//ust// >> -//ust// static void *s_start(struct seq_file *m, loff_t *pos) >> -//ust// { >> -//ust// struct marker_iter *iter = m->private; >> -//ust// >> -//ust// if (!*pos) >> -//ust// marker_iter_reset(iter); >> -//ust// marker_iter_start(iter); >> -//ust// if (!iter->marker) { >> -//ust// /* >> -//ust// * Setting the iter module to -1UL will make sure >> -//ust// * that no module can possibly hold the current marker. >> -//ust// */ >> -//ust// iter->module = (void *)-1UL; >> -//ust// return NULL; >> -//ust// } >> -//ust// return iter->marker; >> -//ust// } >> -//ust// >> -//ust// static void s_stop(struct seq_file *m, void *p) >> -//ust// { >> -//ust// marker_iter_stop(m->private); >> -//ust// } >> -//ust// >> -//ust// static int s_show(struct seq_file *m, void *p) >> -//ust// { >> -//ust// struct marker_iter *iter = m->private; >> -//ust// >> -//ust// seq_printf(m, "channel: %s marker: %s format: \"%s\" >> state: %d " >> -//ust// "event_id: %hu call: 0x%p probe %s : 0x%p\n", >> -//ust// iter->marker->channel, >> -//ust// iter->marker->name, iter->marker->format, >> -//ust// _imv_read(iter->marker->state), >> -//ust// iter->marker->event_id, >> -//ust// iter->marker->call, >> -//ust// iter->marker->ptype ? "multi" : "single", >> -//ust// iter->marker->ptype ? >> -//ust// (void*)iter->marker->multi : (void*)iter->marker- >> >single.func); >> -//ust// return 0; >> -//ust// } >> -//ust// >> -//ust// static const struct seq_operations ltt_seq_op = { >> -//ust// .start = s_start, >> -//ust// .next = s_next, >> -//ust// .stop = s_stop, >> -//ust// .show = s_show, >> -//ust// }; >> -//ust// >> -//ust// static int ltt_open(struct inode *inode, struct file *file) >> -//ust// { >> -//ust// /* >> -//ust// * Iterator kept in m->private. >> -//ust// * Restart iteration on all modules between reads because >> we do not lock >> -//ust// * the module mutex between those. >> -//ust// */ >> -//ust// int ret; >> -//ust// struct marker_iter *iter; >> -//ust// >> -//ust// iter = kzalloc(sizeof(*iter), GFP_KERNEL); >> -//ust// if (!iter) >> -//ust// return -ENOMEM; >> -//ust// >> -//ust// ret = seq_open(file,<t_seq_op); >> -//ust// if (ret == 0) >> -//ust// ((struct seq_file *)file->private_data)->private = iter; >> -//ust// else >> -//ust// kfree(iter); >> -//ust// return ret; >> -//ust// } >> -//ust// >> -//ust// static struct file_operations ltt_fops = { >> -//ust// .write = ltt_write, >> -//ust// .open = ltt_open, >> -//ust// .read = seq_read, >> -//ust// .llseek = seq_lseek, >> -//ust// .release = seq_release_private, >> -//ust// }; >> - >> static void disconnect_all_markers(void) >> { >> struct ltt_active_marker *pdata, *tmp; >> @@ -406,11 +225,6 @@ void __attribute__((constructor)) >> init_marker_control(void) >> if(!initialized) { >> int ret; >> >> -//ust// pentry = create_proc_entry("ltt", S_IRUSR|S_IWUSR, NULL); >> -//ust// if (!pentry) >> -//ust// return -EBUSY; >> -//ust// markers_loaded_cachep = KMEM_CACHE(ltt_active_marker, 0); >> - >> ret = ltt_probe_register(&default_probe); >> BUG_ON(ret); >> ret = ltt_marker_connect("metadata", "core_marker_format", >> @@ -418,18 +232,15 @@ void __attribute__((constructor)) >> init_marker_control(void) >> BUG_ON(ret); >> ret = ltt_marker_connect("metadata", "core_marker_id", >> DEFAULT_PROBE); >> BUG_ON(ret); >> -//ust// pentry->proc_fops =<t_fops; >> >> initialized = 1; >> } >> } >> -//ust// module_init(marker_control_init); >> >> static void __attribute__((destructor)) marker_control_exit(void) >> { >> int ret; >> >> -//ust// remove_proc_entry("ltt", NULL); >> ret = ltt_marker_disconnect("metadata", "core_marker_format", >> DEFAULT_PROBE); >> BUG_ON(ret); >> @@ -439,11 +250,6 @@ static void __attribute__((destructor)) >> marker_control_exit(void) >> ret = ltt_probe_unregister(&default_probe); >> BUG_ON(ret); >> disconnect_all_markers(); >> -//ust// kmem_cache_destroy(markers_loaded_cachep); >> -//ust// marker_synchronize_unregister(); >> + >> } >> -//ust// module_exit(marker_control_exit); >> >> -//ust// MODULE_LICENSE("GPL"); >> -//ust// MODULE_AUTHOR("Mathieu Desnoyers"); >> -//ust// MODULE_DESCRIPTION("Linux Trace Toolkit Marker Control"); >> diff --git a/libust/marker.c b/libust/marker.c >> index cb8ffc1..1a9df8a 100644 >> --- a/libust/marker.c >> +++ b/libust/marker.c >> @@ -118,7 +118,6 @@ notrace void __mark_empty_function(const struct >> marker *mdata, >> void *probe_private, struct registers *regs, void *call_private, >> const char *fmt, va_list *args) >> { >> } >> -//ust// EXPORT_SYMBOL_GPL(__mark_empty_function); >> >> /* >> * marker_probe_cb Callback that prepares the variable argument >> list for probes. >> @@ -141,7 +140,7 @@ notrace void marker_probe_cb(const struct >> marker *mdata, >> * sure the teardown of the callbacks can be done correctly when >> they >> * are in modules and they insure RCU read coherency. >> */ >> -//ust// rcu_read_lock_sched_notrace(); >> + >> ptype = mdata->ptype; >> if (likely(!ptype)) { >> marker_probe_func *func; >> @@ -179,9 +178,7 @@ notrace void marker_probe_cb(const struct >> marker *mdata, >> va_end(args); >> } >> } >> -//ust// rcu_read_unlock_sched_notrace(); >> } >> -//ust// EXPORT_SYMBOL_GPL(marker_probe_cb); >> >> /* >> * marker_probe_cb Callback that does not prepare the variable >> argument list. >> @@ -197,7 +194,6 @@ static notrace void marker_probe_cb_noarg(const >> struct marker *mdata, >> va_list args; /* not initialized */ >> char ptype; >> >> -//ust// rcu_read_lock_sched_notrace(); >> ptype = mdata->ptype; >> if (likely(!ptype)) { >> marker_probe_func *func; >> @@ -230,7 +226,6 @@ static notrace void marker_probe_cb_noarg(const >> struct marker *mdata, >> multi[i].func(mdata, multi[i].probe_private, regs, >> call_private, mdata->format,&args); >> } >> -//ust// rcu_read_unlock_sched_notrace(); >> } >> >> static void free_old_closure(struct rcu_head *head) >> @@ -495,9 +490,7 @@ static int remove_marker(const char *channel, >> const char *name) >> free(e->format); >> ret = ltt_channels_unregister(e->channel); >> WARN_ON(ret); >> - /* Make sure the call_rcu has been executed */ >> -//ust// if (e->rcu_pending) >> -//ust// rcu_barrier_sched(); >> + >> free(e); >> return 0; >> } >> @@ -589,9 +582,6 @@ static int set_marker(struct marker_entry >> *entry, struct marker *elem, >> * try_module_get should always succeed because we hold >> * markers_mutex to get the tp_cb address. >> */ >> -//ust// ret = try_module_get(__module_text_address( >> -//ust// (unsigned long)elem->tp_cb)); >> -//ust// BUG_ON(!ret); >> ret = tracepoint_probe_register_noupdate( >> elem->tp_name, >> elem->tp_cb, NULL); >> @@ -603,8 +593,6 @@ static int set_marker(struct marker_entry >> *entry, struct marker *elem, >> * tracepoint_probe_update_all() must be called >> * before the module containing tp_cb is unloaded. >> */ >> -//ust// module_put(__module_text_address( >> -//ust// (unsigned long)elem->tp_cb)); >> } >> } >> elem->state__imv = active; >> @@ -632,11 +620,6 @@ static void disable_marker(struct marker *elem) >> ret = tracepoint_probe_unregister_noupdate(elem->tp_name, >> elem->tp_cb, NULL); >> WARN_ON(ret); >> - /* >> - * tracepoint_probe_update_all() must be called >> - * before the module containing tp_cb is unloaded. >> - */ >> -//ust// module_put(__module_text_address((unsigned long)elem- >> >tp_cb)); >> } >> elem->state__imv = 0; >> elem->single.func = __mark_empty_function; >> @@ -715,11 +698,9 @@ static void lib_update_markers(void) >> struct lib *lib; >> >> /* FIXME: we should probably take a mutex here on libs */ >> -//ust// pthread_mutex_lock(&module_mutex); >> list_for_each_entry(lib,&libs, list) >> marker_update_probe_range(lib->markers_start, >> lib->markers_start + lib->markers_count); >> -//ust// pthread_mutex_unlock(&module_mutex); >> } >> >> /* >> @@ -741,15 +722,10 @@ static void lib_update_markers(void) >> */ >> static void marker_update_probes(void) >> { >> - /* Core kernel markers */ >> -//ust// marker_update_probe_range(__start___markers, >> __stop___markers); >> - /* Markers in modules. */ >> -//ust// module_update_markers(); >> lib_update_markers(); >> tracepoint_probe_update_all(); >> /* Update immediate values */ >> core_imv_update(); >> -//ust// module_imv_update(); /* FIXME: need to port for libs? */ >> marker_update_processes(); >> } >> >> @@ -815,8 +791,6 @@ int marker_probe_register(const char *channel, >> const char *name, >> * If we detect that a call_rcu is pending for this marker, >> * make sure it's executed now. >> */ >> -//ust// if (entry->rcu_pending) >> -//ust// rcu_barrier_sched(); >> old = marker_entry_add_probe(entry, probe, probe_private); >> if (IS_ERR(old)) { >> ret = PTR_ERR(old); >> @@ -834,13 +808,12 @@ int marker_probe_register(const char >> *channel, const char *name, >> entry = get_marker(channel, name); >> if (!entry) >> goto end; >> -//ust// if (entry->rcu_pending) >> -//ust// rcu_barrier_sched(); >> + >> entry->oldptr = old; >> entry->rcu_pending = 1; >> /* write rcu_pending before calling the RCU callback */ >> smp_wmb(); >> -//ust// call_rcu_sched(&entry->rcu, free_old_closure); >> + >> synchronize_rcu(); free_old_closure(&entry->rcu); >> goto end; >> >> @@ -854,7 +827,7 @@ end: >> pthread_mutex_unlock(&markers_mutex); >> return ret; >> } >> -//ust// EXPORT_SYMBOL_GPL(marker_probe_register); >> + >> >> /** >> * marker_probe_unregister - Disconnect a probe from a marker >> @@ -880,8 +853,7 @@ int marker_probe_unregister(const char >> *channel, const char *name, >> entry = get_marker(channel, name); >> if (!entry) >> goto end; >> -//ust// if (entry->rcu_pending) >> -//ust// rcu_barrier_sched(); >> + >> old = marker_entry_remove_probe(entry, probe, probe_private); >> pthread_mutex_unlock(&markers_mutex); >> >> @@ -891,13 +863,12 @@ int marker_probe_unregister(const char >> *channel, const char *name, >> entry = get_marker(channel, name); >> if (!entry) >> goto end; >> -//ust// if (entry->rcu_pending) >> -//ust// rcu_barrier_sched(); >> + >> entry->oldptr = old; >> entry->rcu_pending = 1; >> /* write rcu_pending before calling the RCU callback */ >> smp_wmb(); >> -//ust// call_rcu_sched(&entry->rcu, free_old_closure); >> + >> synchronize_rcu(); free_old_closure(&entry->rcu); >> remove_marker(channel, name); /* Ignore busy error message */ >> ret = 0; >> @@ -905,7 +876,7 @@ end: >> pthread_mutex_unlock(&markers_mutex); >> return ret; >> } >> -//ust// EXPORT_SYMBOL_GPL(marker_probe_unregister); >> + >> >> static struct marker_entry * >> get_marker_from_private_data(marker_probe_func *probe, void >> *probe_private) >> @@ -965,8 +936,7 @@ int >> marker_probe_unregister_private_data(marker_probe_func *probe, >> ret = -ENOENT; >> goto end; >> } >> -//ust// if (entry->rcu_pending) >> -//ust// rcu_barrier_sched(); >> + >> old = marker_entry_remove_probe(entry, NULL, probe_private); >> channel = strdup(entry->channel); >> name = strdup(entry->name); >> @@ -978,13 +948,12 @@ int >> marker_probe_unregister_private_data(marker_probe_func *probe, >> entry = get_marker(channel, name); >> if (!entry) >> goto end; >> -//ust// if (entry->rcu_pending) >> -//ust// rcu_barrier_sched(); >> + >> entry->oldptr = old; >> entry->rcu_pending = 1; >> /* write rcu_pending before calling the RCU callback */ >> smp_wmb(); >> -//ust// call_rcu_sched(&entry->rcu, free_old_closure); >> + >> synchronize_rcu(); free_old_closure(&entry->rcu); >> /* Ignore busy error message */ >> remove_marker(channel, name); >> @@ -994,7 +963,6 @@ end: >> free(name); >> return ret; >> } >> -//ust// EXPORT_SYMBOL_GPL(marker_probe_unregister_private_data); >> >> /** >> * marker_get_private_data - Get a marker's probe private data >> @@ -1044,37 +1012,6 @@ void *marker_get_private_data(const char >> *channel, const char *name, >> } >> return ERR_PTR(-ENOENT); >> } >> -//ust// EXPORT_SYMBOL_GPL(marker_get_private_data); >> - >> -/** >> - * markers_compact_event_ids - Compact markers event IDs and >> reassign channels >> - * >> - * Called when no channel users are active by the channel >> infrastructure. >> - * Called with lock_markers() and channel mutex held. >> - */ >> -//ust// void markers_compact_event_ids(void) >> -//ust// { >> -//ust// struct marker_entry *entry; >> -//ust// unsigned int i; >> -//ust// struct hlist_head *head; >> -//ust// struct hlist_node *node; >> -//ust// int ret; >> -//ust// >> -//ust// for (i = 0; i< MARKER_TABLE_SIZE; i++) { >> -//ust// head =&marker_table[i]; >> -//ust// hlist_for_each_entry(entry, node, head, hlist) { >> -//ust// ret = ltt_channels_get_index_from_name(entry->channel); >> -//ust// WARN_ON(ret< 0); >> -//ust// entry->channel_id = ret; >> -//ust// ret = _ltt_channels_get_event_id(entry->channel, >> -//ust// entry->name); >> -//ust// WARN_ON(ret< 0); >> -//ust// entry->event_id = ret; >> -//ust// } >> -//ust// } >> -//ust// } >> - >> -//ust//#ifdef CONFIG_MODULES >> >> /* >> * Returns 0 if current not found. >> @@ -1085,7 +1022,6 @@ int lib_get_iter_markers(struct marker_iter >> *iter) >> struct lib *iter_lib; >> int found = 0; >> >> -//ust// pthread_mutex_lock(&module_mutex); >> list_for_each_entry(iter_lib,&libs, list) { >> if (iter_lib< iter->lib) >> continue; >> @@ -1099,7 +1035,7 @@ int lib_get_iter_markers(struct marker_iter >> *iter) >> break; >> } >> } >> -//ust// pthread_mutex_unlock(&module_mutex); >> + >> return found; >> } >> >> @@ -1123,7 +1059,7 @@ int marker_get_iter_range(struct marker >> **marker, struct marker *begin, >> return 1; >> return 0; >> } >> -//ust// EXPORT_SYMBOL_GPL(marker_get_iter_range); >> + >> >> static void marker_get_iter(struct marker_iter *iter) >> { >> @@ -1148,7 +1084,6 @@ void marker_iter_start(struct marker_iter >> *iter) >> { >> marker_get_iter(iter); >> } >> -//ust// EXPORT_SYMBOL_GPL(marker_iter_start); >> >> void marker_iter_next(struct marker_iter *iter) >> { >> @@ -1160,19 +1095,19 @@ void marker_iter_next(struct marker_iter >> *iter) >> */ >> marker_get_iter(iter); >> } >> -//ust// EXPORT_SYMBOL_GPL(marker_iter_next); >> + >> >> void marker_iter_stop(struct marker_iter *iter) >> { >> } >> -//ust// EXPORT_SYMBOL_GPL(marker_iter_stop); >> + >> >> void marker_iter_reset(struct marker_iter *iter) >> { >> iter->lib = NULL; >> iter->marker = NULL; >> } >> -//ust// EXPORT_SYMBOL_GPL(marker_iter_reset); >> + >> >> #ifdef CONFIG_MARKERS_USERSPACE >> /* >> @@ -1192,50 +1127,6 @@ static void free_user_marker(char __user >> *state, struct hlist_head *head) >> } >> >> /* >> - * Update current process. >> - * Note that we have to wait a whole scheduler period before we >> are sure that >> - * every running userspace threads have their markers updated. >> - * (synchronize_sched() can be used to insure this). >> - */ >> -//ust// void marker_update_process(void) >> -//ust// { >> -//ust// struct user_marker *umark; >> -//ust// struct hlist_node *pos; >> -//ust// struct marker_entry *entry; >> -//ust// >> -//ust// pthread_mutex_lock(&markers_mutex); >> -//ust// pthread_mutex_lock(¤t->group_leader- >> >user_markers_mutex); >> -//ust// if (strcmp(current->comm, "testprog") == 0) >> -//ust// DBG("do update pending for testprog"); >> -//ust// hlist_for_each_entry(umark, pos, >> -//ust// ¤t->group_leader->user_markers, hlist) { >> -//ust// DBG("Updating marker %s in %s", umark->name, current- >> >comm); >> -//ust// entry = get_marker("userspace", umark->name); >> -//ust// if (entry) { >> -//ust// if (entry->format&& >> -//ust// strcmp(entry->format, umark->format) != 0) { >> -//ust// WARN("error, wrong format in process %s", >> -//ust// current->comm); >> -//ust// break; >> -//ust// } >> -//ust// if (put_user(!!entry->refcount, umark->state)) { >> -//ust// WARN("Marker in %s caused a fault", >> -//ust// current->comm); >> -//ust// break; >> -//ust// } >> -//ust// } else { >> -//ust// if (put_user(0, umark->state)) { >> -//ust// WARN("Marker in %s caused a fault", current->comm); >> -//ust// break; >> -//ust// } >> -//ust// } >> -//ust// } >> -//ust// clear_thread_flag(TIF_MARKER_PENDING); >> -//ust// pthread_mutex_unlock(¤t->group_leader- >> >user_markers_mutex); >> -//ust// pthread_mutex_unlock(&markers_mutex); >> -//ust// } >> - >> -/* >> * Called at process exit and upon do_execve(). >> * We assume that when the leader exits, no more references can be >> done to the >> * leader structure by the other threads. >> @@ -1268,7 +1159,6 @@ int is_marker_enabled(const char *channel, >> const char *name) >> >> return entry&& !!entry->refcount; >> } >> -//ust// #endif >> >> int marker_module_notify(struct notifier_block *self, >> unsigned long val, void *data) >> @@ -1293,11 +1183,6 @@ struct notifier_block marker_module_nb = { >> .priority = 0, >> }; >> >> -//ust// static int init_markers(void) >> -//ust// { >> -//ust// return register_module_notifier(&marker_module_nb); >> -//ust// } >> -//ust// __initcall(init_markers); >> /* TODO: call marker_module_nb() when a library is linked at >> runtime (dlopen)? */ >> >> #endif /* CONFIG_MODULES */ >> @@ -1340,7 +1225,6 @@ void ltt_dump_marker_state(struct ust_trace >> *trace) >> } >> pthread_mutex_unlock(&markers_mutex); >> } >> -//ust// EXPORT_SYMBOL_GPL(ltt_dump_marker_state); >> >> static void (*new_marker_cb)(struct marker *) = NULL; >> >> @@ -1379,7 +1263,7 @@ int marker_register_lib(struct marker >> *markers_start, int markers_count) >> lib_update_markers(); >> >> DBG("just registered a markers section from %p and having %d >> markers", markers_start, markers_count); >> - >> + >> return 0; >> } >> >> @@ -1393,7 +1277,7 @@ int marker_unregister_lib(struct marker >> *markers_start) >> lock_markers(); >> >> /* FIXME: we should probably take a mutex here on libs */ >> -//ust// pthread_mutex_lock(&module_mutex); >> + >> list_for_each_entry(lib,&libs, list) { >> if(lib->markers_start == markers_start) { >> struct lib *lib2free = lib; >> diff --git a/libust/serialize.c b/libust/serialize.c >> index bd947ab..0bba97b 100644 >> --- a/libust/serialize.c >> +++ b/libust/serialize.c >> @@ -237,9 +237,6 @@ repeat: >> case 'z': >> *trace_size = sizeof(size_t); >> break; >> -//ust// case 't': >> -//ust// *trace_size = sizeof(ptrdiff_t); >> -//ust// break; >> case 'h': >> *trace_size = sizeof(short); >> break; >> @@ -347,9 +344,6 @@ repeat: >> case 'z': >> *c_size = sizeof(size_t); >> break; >> -//ust// case 't': >> -//ust// *c_size = sizeof(ptrdiff_t); >> -//ust// break; >> case 'h': >> *c_size = sizeof(short); >> break; >> @@ -653,7 +647,7 @@ notrace void ltt_vtrace(const struct marker >> *mdata, void *probe_data, >> if (unlikely(ltt_traces.num_active_traces == 0)) >> return; >> >> - rcu_read_lock(); //ust// rcu_read_lock_sched_notrace(); >> + rcu_read_lock(); >> cpu = ust_get_cpu(); >> >> /* Force volatile access. */ >> @@ -730,7 +724,6 @@ notrace void ltt_vtrace(const struct marker >> *mdata, void *probe_data, >> >> va_copy(args_copy, *args); >> /* FIXME : could probably encapsulate transport better. */ >> -//ust// buf = ((struct rchan *)channel->trans_channel_data)- >> >buf[cpu]; >> buf = channel->buf[cpu]; >> /* Out-of-order write : header and data */ >> buf_offset = ltt_write_event_header(channel, buf, buf_offset, >> @@ -749,7 +742,7 @@ notrace void ltt_vtrace(const struct marker >> *mdata, void *probe_data, >> tracer_stack_pos = stack_pos_ctx; >> STORE_SHARED(ltt_nesting, LOAD_SHARED(ltt_nesting) - 1); >> >> - rcu_read_unlock(); //ust// rcu_read_unlock_sched_notrace(); >> + rcu_read_unlock(); >> } >> >> notrace void ltt_trace(const struct marker *mdata, void *probe_data, >> diff --git a/libust/tracepoint.c b/libust/tracepoint.c >> index 6fe9cd7..d778737 100644 >> --- a/libust/tracepoint.c >> +++ b/libust/tracepoint.c >> @@ -28,8 +28,6 @@ >> #define _LGPL_SOURCE >> #include >> >> -//extern struct tracepoint __start___tracepoints[] >> __attribute__((visibility("hidden"))); >> -//extern struct tracepoint __stop___tracepoints[] >> __attribute__((visibility("hidden"))); >> >> /* Set to 1 to enable tracepoint debug output */ >> static const int tracepoint_debug; >> @@ -66,7 +64,6 @@ struct tracepoint_entry { >> >> struct tp_probes { >> union { >> -//ust// struct rcu_head rcu; >> struct list_head list; >> } u; >> struct probe probes[0]; >> @@ -79,17 +76,11 @@ static inline void *allocate_probes(int count) >> return p == NULL ? NULL : p->probes; >> } >> >> -//ust// static void rcu_free_old_probes(struct rcu_head *head) >> -//ust// { >> -//ust// kfree(container_of(head, struct tp_probes, u.rcu)); >> -//ust// } >> - >> static inline void release_probes(void *old) >> { >> if (old) { >> struct tp_probes *tp_probes = _ust_container_of(old, >> struct tp_probes, probes[0]); >> -//ust// call_rcu_sched(&tp_probes->u.rcu, rcu_free_old_probes); >> synchronize_rcu(); >> free(tp_probes); >> } >> @@ -313,11 +304,9 @@ static void lib_update_tracepoints(void) >> { >> struct tracepoint_lib *lib; >> >> -//ust// pthread_mutex_lock(&module_mutex); >> list_for_each_entry(lib,&libs, list) >> tracepoint_update_probe_range(lib->tracepoints_start, >> lib->tracepoints_start + lib->tracepoints_count); >> -//ust// pthread_mutex_unlock(&module_mutex); >> } >> >> /* >> @@ -325,14 +314,10 @@ static void lib_update_tracepoints(void) >> */ >> static void tracepoint_update_probes(void) >> { >> - /* Core kernel tracepoints */ >> -//ust// tracepoint_update_probe_range(__start___tracepoints, >> -//ust// __stop___tracepoints); >> /* tracepoints in modules. */ >> lib_update_tracepoints(); >> /* Update immediate values */ >> core_imv_update(); >> -//ust// module_imv_update(); >> } >> >> static struct probe * >> @@ -375,7 +360,6 @@ int tracepoint_probe_register(const char *name, >> void *probe, void *data) >> release_probes(old); >> return 0; >> } >> -//ust// EXPORT_SYMBOL_GPL(tracepoint_probe_register); >> >> static void *tracepoint_remove_probe(const char *name, void >> *probe, void *data) >> { >> @@ -418,7 +402,6 @@ int tracepoint_probe_unregister(const char >> *name, void *probe, void *data) >> release_probes(old); >> return 0; >> } >> -//ust// EXPORT_SYMBOL_GPL(tracepoint_probe_unregister); >> >> static LIST_HEAD(old_probes); >> static int need_update; >> @@ -455,7 +438,6 @@ int tracepoint_probe_register_noupdate(const >> char *name, void *probe, >> pthread_mutex_unlock(&tracepoints_mutex); >> return 0; >> } >> -//ust// EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate); >> >> /** >> * tracepoint_probe_unregister_noupdate - remove a probe but not >> disconnect >> @@ -479,7 +461,6 @@ int tracepoint_probe_unregister_noupdate(const >> char *name, void *probe, >> pthread_mutex_unlock(&tracepoints_mutex); >> return 0; >> } >> -//ust// EXPORT_SYMBOL_GPL(tracepoint_probe_unregister_noupdate); >> >> /** >> * tracepoint_probe_update_all - update tracepoints >> @@ -502,12 +483,10 @@ void tracepoint_probe_update_all(void) >> tracepoint_update_probes(); >> list_for_each_entry_safe(pos, next,&release_probes, u.list) { >> list_del(&pos->u.list); >> -//ust// call_rcu_sched(&pos->u.rcu, rcu_free_old_probes); >> synchronize_rcu(); >> free(pos); >> } >> } >> -//ust// EXPORT_SYMBOL_GPL(tracepoint_probe_update_all); >> >> /* >> * Returns 0 if current not found. >> @@ -518,7 +497,6 @@ int lib_get_iter_tracepoints(struct >> tracepoint_iter *iter) >> struct tracepoint_lib *iter_lib; >> int found = 0; >> >> -//ust// pthread_mutex_lock(&module_mutex); >> list_for_each_entry(iter_lib,&libs, list) { >> if (iter_lib< iter->lib) >> continue; >> @@ -532,7 +510,7 @@ int lib_get_iter_tracepoints(struct >> tracepoint_iter *iter) >> break; >> } >> } >> -//ust// pthread_mutex_unlock(&module_mutex); >> + >> return found; >> } >> >> @@ -557,22 +535,13 @@ int tracepoint_get_iter_range(struct >> tracepoint **tracepoint, >> return 1; >> return 0; >> } >> -//ust// EXPORT_SYMBOL_GPL(tracepoint_get_iter_range); >> >> static void tracepoint_get_iter(struct tracepoint_iter *iter) >> { >> int found = 0; >> >> -//ust// /* Core kernel tracepoints */ >> -//ust// if (!iter->module) { >> -//ust// found = tracepoint_get_iter_range(&iter->tracepoint, >> -//ust// __start___tracepoints, __stop___tracepoints); >> -//ust// if (found) >> -//ust// goto end; >> -//ust// } >> - /* tracepoints in libs. */ >> found = lib_get_iter_tracepoints(iter); >> -//ust// end: >> + >> if (!found) >> tracepoint_iter_reset(iter); >> } >> @@ -581,7 +550,6 @@ void tracepoint_iter_start(struct >> tracepoint_iter *iter) >> { >> tracepoint_get_iter(iter); >> } >> -//ust// EXPORT_SYMBOL_GPL(tracepoint_iter_start); >> >> void tracepoint_iter_next(struct tracepoint_iter *iter) >> { >> @@ -593,52 +561,15 @@ void tracepoint_iter_next(struct >> tracepoint_iter *iter) >> */ >> tracepoint_get_iter(iter); >> } >> -//ust// EXPORT_SYMBOL_GPL(tracepoint_iter_next); >> >> void tracepoint_iter_stop(struct tracepoint_iter *iter) >> { >> } >> -//ust// EXPORT_SYMBOL_GPL(tracepoint_iter_stop); >> >> void tracepoint_iter_reset(struct tracepoint_iter *iter) >> { >> -//ust// iter->module = NULL; >> iter->tracepoint = NULL; >> } >> -//ust// EXPORT_SYMBOL_GPL(tracepoint_iter_reset); >> - >> -//ust// #ifdef CONFIG_MODULES >> - >> -//ust// int tracepoint_module_notify(struct notifier_block *self, >> -//ust// unsigned long val, void *data) >> -//ust// { >> -//ust// struct module *mod = data; >> -//ust// >> -//ust// switch (val) { >> -//ust// case MODULE_STATE_COMING: >> -//ust// tracepoint_update_probe_range(mod->tracepoints, >> -//ust// mod->tracepoints + mod->num_tracepoints); >> -//ust// break; >> -//ust// case MODULE_STATE_GOING: >> -//ust// tracepoint_update_probe_range(mod->tracepoints, >> -//ust// mod->tracepoints + mod->num_tracepoints); >> -//ust// break; >> -//ust// } >> -//ust// return 0; >> -//ust// } >> - >> -//ust// struct notifier_block tracepoint_module_nb = { >> -//ust// .notifier_call = tracepoint_module_notify, >> -//ust// .priority = 0, >> -//ust// }; >> - >> -//ust// static int init_tracepoints(void) >> -//ust// { >> -//ust// return register_module_notifier(&tracepoint_module_nb); >> -//ust// } >> -//ust// __initcall(init_tracepoints); >> - >> -//ust// #endif /* CONFIG_MODULES */ >> >> static void (*new_tracepoint_cb)(struct tracepoint *) = NULL; >> >> diff --git a/libust/tracer.c b/libust/tracer.c >> index c9422c8..da6f914 100644 >> --- a/libust/tracer.c >> +++ b/libust/tracer.c >> @@ -40,10 +40,6 @@ >> #include "tracer.h" >> #include "usterr.h" >> >> -//ust// static void async_wakeup(unsigned long data); >> -//ust// >> -//ust// static DEFINE_TIMER(ltt_async_wakeup_timer, async_wakeup, >> 0, 0); >> - >> /* Default callbacks for modules */ >> notrace int ltt_filter_control_default(enum ltt_filter_control_msg >> msg, >> struct ust_trace *trace) >> @@ -96,91 +92,6 @@ static enum ltt_channels >> get_channel_type_from_name(const char *name) >> return LTT_CHANNEL_UST; >> } >> >> -/** >> - * ltt_module_register - LTT module registration >> - * @name: module type >> - * @function: callback to register >> - * @owner: module which owns the callback >> - * >> - * The module calling this registration function must ensure that no >> - * trap-inducing code will be executed by "function". E.g. >> vmalloc_sync_all() >> - * must be called between a vmalloc and the moment the memory is >> made visible to >> - * "function". This registration acts as a vmalloc_sync_all. >> Therefore, only if >> - * the module allocates virtual memory after its registration must >> it >> - * synchronize the TLBs. >> - */ >> -//ust// int ltt_module_register(enum ltt_module_function name, >> void *function, >> -//ust// struct module *owner) >> -//ust// { >> -//ust// int ret = 0; >> -//ust// >> -//ust// /* >> -//ust// * Make sure no page fault can be triggered by the module >> about to be >> -//ust// * registered. We deal with this here so we don't have to >> call >> -//ust// * vmalloc_sync_all() in each module's init. >> -//ust// */ >> -//ust// vmalloc_sync_all(); >> -//ust// >> -//ust// switch (name) { >> -//ust// case LTT_FUNCTION_RUN_FILTER: >> -//ust// if (ltt_run_filter_owner != NULL) { >> -//ust// ret = -EEXIST; >> -//ust// goto end; >> -//ust// } >> -//ust// ltt_filter_register((ltt_run_filter_functor)function); >> -//ust// ltt_run_filter_owner = owner; >> -//ust// break; >> -//ust// case LTT_FUNCTION_FILTER_CONTROL: >> -//ust// if (ltt_filter_control_owner != NULL) { >> -//ust// ret = -EEXIST; >> -//ust// goto end; >> -//ust// } >> -//ust// ltt_filter_control_functor = >> -//ust// (int (*)(enum ltt_filter_control_msg, >> -//ust// struct ust_trace *))function; >> -//ust// ltt_filter_control_owner = owner; >> -//ust// break; >> -//ust// case LTT_FUNCTION_STATEDUMP: >> -//ust// if (ltt_statedump_owner != NULL) { >> -//ust// ret = -EEXIST; >> -//ust// goto end; >> -//ust// } >> -//ust// ltt_statedump_functor = >> -//ust// (int (*)(struct ust_trace *))function; >> -//ust// ltt_statedump_owner = owner; >> -//ust// break; >> -//ust// } >> -//ust// >> -//ust// end: >> -//ust// >> -//ust// return ret; >> -//ust// } >> - >> -/** >> - * ltt_module_unregister - LTT module unregistration >> - * @name: module type >> - */ >> -//ust// void ltt_module_unregister(enum ltt_module_function name) >> -//ust// { >> -//ust// switch (name) { >> -//ust// case LTT_FUNCTION_RUN_FILTER: >> -//ust// ltt_filter_unregister(); >> -//ust// ltt_run_filter_owner = NULL; >> -//ust// /* Wait for preempt sections to finish */ >> -//ust// synchronize_sched(); >> -//ust// break; >> -//ust// case LTT_FUNCTION_FILTER_CONTROL: >> -//ust// ltt_filter_control_functor = ltt_filter_control_default; >> -//ust// ltt_filter_control_owner = NULL; >> -//ust// break; >> -//ust// case LTT_FUNCTION_STATEDUMP: >> -//ust// ltt_statedump_functor = ltt_statedump_default; >> -//ust// ltt_statedump_owner = NULL; >> -//ust// break; >> -//ust// } >> -//ust// >> -//ust// } >> - >> static LIST_HEAD(ltt_transport_list); >> >> /** >> @@ -202,7 +113,6 @@ void ltt_transport_register(struct >> ltt_transport *transport) >> * registered. We deal with this here so we don't have to call >> * vmalloc_sync_all() in each module's init. >> */ >> -//ust// vmalloc_sync_all(); >> >> ltt_lock_traces(); >> list_add_tail(&transport->node,<t_transport_list); >> @@ -253,40 +163,14 @@ static void trace_async_wakeup(struct >> ust_trace *trace) >> /* Must check each channel for pending read wakeup */ >> for (i = 0; i< trace->nr_channels; i++) { >> chan =&trace->channels[i]; >> - if (chan->active) >> - trace->ops->wakeup_channel(chan); >> + if (chan->active) { >> + /* Currently wakeup_channel is a null pointer, >> + long term maybe look at removing or implemeting? */ >> + /* trace->ops->wakeup_channel(chan); */ >> + } >> } >> } >> >> -//ust// /* Timer to send async wakeups to the readers */ >> -//ust// static void async_wakeup(unsigned long data) >> -//ust// { >> -//ust// struct ust_trace *trace; >> -//ust// >> -//ust// /* >> -//ust// * PREEMPT_RT does not allow spinlocks to be taken within >> preempt >> -//ust// * disable sections (spinlock taken in wake_up). However, >> mainline won't >> -//ust// * allow mutex to be taken in interrupt context. Ugly. >> -//ust// * A proper way to do this would be to turn the timer >> into a >> -//ust// * periodically woken up thread, but it adds to the >> footprint. >> -//ust// */ >> -//ust// #ifndef CONFIG_PREEMPT_RT >> -//ust// rcu_read_lock_sched(); >> -//ust// #else >> -//ust// ltt_lock_traces(); >> -//ust// #endif >> -//ust// list_for_each_entry_rcu(trace,<t_traces.head, list) { >> -//ust// trace_async_wakeup(trace); >> -//ust// } >> -//ust// #ifndef CONFIG_PREEMPT_RT >> -//ust// rcu_read_unlock_sched(); >> -//ust// #else >> -//ust// ltt_unlock_traces(); >> -//ust// #endif >> -//ust// >> -//ust// mod_timer(<t_async_wakeup_timer, jiffies + >> LTT_PERCPU_TIMER_INTERVAL); >> -//ust// } >> - >> /** >> * _ltt_trace_find - find a trace by given name. >> * trace_name: trace name >> @@ -326,9 +210,6 @@ struct ust_trace *_ltt_trace_find_setup(const >> char *trace_name) >> */ >> void ltt_release_transport(struct kref *kref) >> { >> -//ust// struct ust_trace *trace = container_of(kref, >> -//ust// struct ust_trace, ltt_transport_kref); >> -//ust// trace->ops->remove_dirs(trace); >> } >> >> /** >> @@ -622,7 +503,7 @@ int ltt_trace_alloc(const char *trace_name) >> int err = 0; >> struct ust_trace *trace; >> unsigned int subbuf_size, subbuf_cnt; >> -//ust// unsigned long flags; >> + >> int chan; >> const char *channel_name; >> >> @@ -642,9 +523,9 @@ int ltt_trace_alloc(const char *trace_name) >> >> kref_init(&trace->kref); >> kref_init(&trace->ltt_transport_kref); >> -//ust// init_waitqueue_head(&trace->kref_wq); >> + >> trace->active = 0; >> -//ust// get_trace_clock(); >> + >> trace->freq_scale = trace_clock_freq_scale(); >> >> if (!trace->transport) { >> @@ -652,24 +533,11 @@ int ltt_trace_alloc(const char *trace_name) >> err = -EINVAL; >> goto transport_error; >> } >> -//ust// if (!try_module_get(trace->transport->owner)) { >> -//ust// ERR("Can't lock transport module"); >> -//ust// err = -ENODEV; >> -//ust// goto transport_error; >> -//ust// } >> trace->ops =&trace->transport->ops; >> >> -//ust// err = trace->ops->create_dirs(trace); >> -//ust// if (err) { >> -//ust// ERR("Can't create dir for trace %s", trace_name); >> -//ust// goto dirs_error; >> -//ust// } >> - >> -//ust// local_irq_save(flags); >> trace->start_freq = trace_clock_frequency(); >> trace->start_tsc = trace_clock_read64(); >> - gettimeofday(&trace->start_time, NULL); //ust// changed /* FIXME: >> is this ok? */ >> -//ust// local_irq_restore(flags); >> + gettimeofday(&trace->start_time, NULL); /* FIXME: is this ok? */ >> >> for (chan = 0; chan< trace->nr_channels; chan++) { >> if (!(trace->channels[chan].active)) >> @@ -693,13 +561,7 @@ int ltt_trace_alloc(const char *trace_name) >> } >> >> list_del(&trace->list); >> -//ust// if (list_empty(<t_traces.head)) { >> -//ust// mod_timer(<t_async_wakeup_timer, >> -//ust// jiffies + LTT_PERCPU_TIMER_INTERVAL); >> -//ust// set_kernel_trace_flag_all_tasks(); >> -//ust// } >> list_add_rcu(&trace->list,<t_traces.head); >> -//ust// synchronize_sched(); >> >> ltt_unlock_traces(); >> >> @@ -710,43 +572,13 @@ create_channel_error: >> if (trace->channels[chan].active) >> trace->ops->remove_channel(&trace->channels[chan]); >> >> -//ust// dirs_error: >> -//ust// module_put(trace->transport->owner); >> transport_error: >> -//ust// put_trace_clock(); >> + >> traces_error: >> ltt_unlock_traces(); >> return err; >> } >> >> -/* >> - * It is worked as a wrapper for current version of ltt_control.ko. >> - * We will make a new ltt_control based on debugfs, and control >> each channel's >> - * buffer. >> - */ >> -//ust// static int ltt_trace_create(const char *trace_name, const >> char *trace_type, >> -//ust// enum trace_mode mode, >> -//ust// unsigned int subbuf_size_low, unsigned int n_subbufs_low, >> -//ust// unsigned int subbuf_size_med, unsigned int n_subbufs_med, >> -//ust// unsigned int subbuf_size_high, unsigned int >> n_subbufs_high) >> -//ust// { >> -//ust// int err = 0; >> -//ust// >> -//ust// err = ltt_trace_setup(trace_name); >> -//ust// if (IS_ERR_VALUE(err)) >> -//ust// return err; >> -//ust// >> -//ust// err = ltt_trace_set_type(trace_name, trace_type); >> -//ust// if (IS_ERR_VALUE(err)) >> -//ust// return err; >> -//ust// >> -//ust// err = ltt_trace_alloc(trace_name); >> -//ust// if (IS_ERR_VALUE(err)) >> -//ust// return err; >> -//ust// >> -//ust// return err; >> -//ust// } >> - >> /* Must be called while sure that trace is in the list. */ >> static int _ltt_trace_destroy(struct ust_trace *trace) >> { >> @@ -764,15 +596,6 @@ static int _ltt_trace_destroy(struct ust_trace >> *trace) >> /* Everything went fine */ >> list_del_rcu(&trace->list); >> synchronize_rcu(); >> - if (list_empty(<t_traces.head)) { >> -//ust// clear_kernel_trace_flag_all_tasks(); >> - /* >> - * We stop the asynchronous delivery of reader wakeup, but >> - * we must make one last check for reader wakeups pending >> - * later in __ltt_trace_destroy. >> - */ >> -//ust// del_timer_sync(<t_async_wakeup_timer); >> - } >> return 0; >> >> /* error handling */ >> @@ -796,7 +619,6 @@ static void __ltt_trace_destroy(struct >> ust_trace *trace, int drop) >> } >> >> return; /* FIXME: temporary for ust */ >> -//ust// flush_scheduled_work(); >> >> /* >> * The currently destroyed trace is not in the trace list anymore, >> @@ -813,17 +635,10 @@ static void __ltt_trace_destroy(struct >> ust_trace *trace, int drop) >> >> kref_put(&trace->ltt_transport_kref, ltt_release_transport); >> >> -//ust// module_put(trace->transport->owner); >> - >> /* >> * Wait for lttd readers to release the files, therefore making >> sure >> * the last subbuffers have been read. >> */ >> -//ust// if (atomic_read(&trace->kref.refcount)> 1) { >> -//ust// int ret = 0; >> -//ust// __wait_event_interruptible(trace->kref_wq, >> -//ust// (atomic_read(&trace->kref.refcount) == 1), ret); >> -//ust// } >> kref_put(&trace->kref, ltt_release_trace); >> } >> >> @@ -843,7 +658,6 @@ int ltt_trace_destroy(const char *trace_name, >> int drop) >> ltt_unlock_traces(); >> >> __ltt_trace_destroy(trace, drop); >> -//ust// put_trace_clock(); >> >> return 0; >> } >> @@ -874,18 +688,12 @@ static int _ltt_trace_start(struct ust_trace >> *trace) >> } >> if (trace->active) >> DBG("Tracing already active for trace %s", trace->trace_name); >> -//ust// if (!try_module_get(ltt_run_filter_owner)) { >> -//ust// err = -ENODEV; >> -//ust// ERR("Cannot lock filter module"); >> -//ust// goto get_ltt_run_filter_error; >> -//ust// } >> trace->active = 1; >> /* Read by trace points without protection : be careful */ >> ltt_traces.num_active_traces++; >> return err; >> >> /* error handling */ >> -//ust// get_ltt_run_filter_error: >> traces_error: >> return err; >> } >> @@ -914,13 +722,7 @@ int ltt_trace_start(const char *trace_name) >> >> ltt_dump_marker_state(trace); >> >> -//ust// if (!try_module_get(ltt_statedump_owner)) { >> -//ust// err = -ENODEV; >> -//ust// ERR("Cannot lock state dump module"); >> -//ust// } else { >> - ltt_statedump_functor(trace); >> -//ust// module_put(ltt_statedump_owner); >> -//ust// } >> + ltt_statedump_functor(trace); >> >> return err; >> >> @@ -944,9 +746,8 @@ static int _ltt_trace_stop(struct ust_trace >> *trace) >> if (trace->active) { >> trace->active = 0; >> ltt_traces.num_active_traces--; >> -//ust// synchronize_sched(); /* Wait for each tracing to be >> finished */ >> } >> -//ust// module_put(ltt_run_filter_owner); >> + >> /* Everything went fine */ >> return 0; >> >> @@ -985,10 +786,7 @@ int ltt_filter_control(enum >> ltt_filter_control_msg msg, const char *trace_name) >> err = -ENOENT; >> goto trace_error; >> } >> -//ust// if (!try_module_get(ltt_filter_control_owner)) { >> -//ust// err = -ENODEV; >> -//ust// goto get_module_error; >> -//ust// } >> + >> switch (msg) { >> case LTT_FILTER_DEFAULT_ACCEPT: >> DBG("Proxy filter default accept %s", trace_name); >> @@ -1001,9 +799,7 @@ int ltt_filter_control(enum >> ltt_filter_control_msg msg, const char *trace_name) >> default: >> err = -EPERM; >> } >> -//ust// module_put(ltt_filter_control_owner); >> >> -//ust// get_module_error: >> trace_error: >> ltt_unlock_traces(); >> return err; >> diff --git a/libust/tracer.h b/libust/tracer.h >> index c5df6ec..6421978 100644 >> --- a/libust/tracer.h >> +++ b/libust/tracer.h >> @@ -101,7 +101,7 @@ struct ltt_active_marker { >> struct ltt_available_probe *probe; >> }; >> >> -struct marker; //ust// >> +struct marker; >> extern void ltt_vtrace(const struct marker *mdata, void *probe_data, >> struct registers *regs, void *call_data, const char *fmt, va_list >> *args); >> extern void ltt_trace(const struct marker *mdata, void *probe_data, >> diff --git a/libust/tracercore.c b/libust/tracercore.c >> index bbc8691..2cf9078 100644 >> --- a/libust/tracercore.c >> +++ b/libust/tracercore.c >> @@ -39,8 +39,6 @@ void ltt_unlock_traces(void) >> pthread_mutex_unlock(<t_traces_mutex); >> } >> >> -//ust// DEFINE_PER_CPU(unsigned int, ltt_nesting); >> -//ust// EXPORT_PER_CPU_SYMBOL(ltt_nesting); >> __thread int ltt_nesting; >> >> int ltt_run_filter_default(void *trace, uint16_t eID) >> diff --git a/libust/type-serializer.c b/libust/type-serializer.c >> index bf1c496..1ca7083 100644 >> --- a/libust/type-serializer.c >> +++ b/libust/type-serializer.c >> @@ -63,8 +63,6 @@ void _ltt_specialized_trace(const struct marker >> *mdata, void *probe_data, >> list_for_each_entry_rcu(trace,<t_traces.head, list) { >> if (unlikely(!trace->active)) >> continue; >> -//ust// if (unlikely(!ltt_run_filter(trace, eID))) >> -//ust// continue; >> #ifdef CONFIG_LTT_DEBUG_EVENT_SIZE >> rflags = LTT_RFLAG_ID_SIZE; >> #else > > -- > David Goulet > LTTng project, DORSAL Lab. > > PGP/GPG : 1024D/16BD8563 > BE3C 672B 9331 9796 291A 14C6 4AF7 C14B 16BD 8563 > > _______________________________________________ > ltt-dev mailing list > ltt-dev at lists.casi.polymtl.ca > http://lists.casi.polymtl.ca/cgi-bin/mailman/listinfo/ltt-dev