[ltt-dev] [UST PATCH] Remove //ust commented code
Nils Carlson
nils.carlson at ludd.ltu.se
Thu Nov 4 15:18:14 EDT 2010
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<nils.carlson at ericsson.com>
>> ---
>> 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; i<chan->n_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<channel name> <marker name> [<probe name>]]
>> - * disconnect<channel name> <marker name> [<probe name>]
>> - */
>> -//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<urcu-bp.h>
>>
>> -//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
More information about the lttng-dev
mailing list