From mboxrd@z Thu Jan 1 00:00:00 1970 From: compudj@krystal.dyndns.org (Mathieu Desnoyers) Date: Thu, 18 Nov 2010 23:27:49 -0500 Subject: [ltt-dev] [UST PATCH] Rename for the new liburcu API namespace In-Reply-To: <1290140377-13886-1-git-send-email-david.goulet@polymtl.ca> References: <1290140377-13886-1-git-send-email-david.goulet@polymtl.ca> Message-ID: <20101119042749.GB613@Krystal> * David Goulet (david.goulet at polymtl.ca) wrote: > This commit makes UST compatible with liburcu 0.5.2 > > Signed-off-by: David Goulet Committed and pushed, thanks ! Mathieu > --- > include/ust/marker.h | 2 +- > include/ust/probe.h | 2 +- > include/ust/processor.h | 2 +- > include/ust/tracepoint.h | 4 +- > include/ust/ustd.h | 2 +- > libust/buffers.c | 38 ++++++++++++------------ > libust/buffers.h | 10 +++--- > libust/channels.c | 18 +++++----- > libust/channels.h | 4 +- > libust/marker-control.c | 28 +++++++++--------- > libust/marker.c | 74 +++++++++++++++++++++++----------------------- > libust/serialize.c | 12 ++++---- > libust/trace_event.c | 10 +++--- > libust/tracectl.c | 32 ++++++++++---------- > libust/tracepoint.c | 32 ++++++++++---------- > libust/tracer.c | 28 +++++++++--------- > libust/tracer.h | 6 ++-- > libust/tracercore.c | 4 +- > libust/tracercore.h | 4 +- > libust/type-serializer.c | 10 +++--- > libustcomm/ustcomm.c | 8 ++-- > libustcomm/ustcomm.h | 4 +- > libustd/libustd.c | 2 +- > 23 files changed, 168 insertions(+), 168 deletions(-) > > diff --git a/include/ust/marker.h b/include/ust/marker.h > index 6103629..0f42d5b 100644 > --- a/include/ust/marker.h > +++ b/include/ust/marker.h > @@ -330,7 +330,7 @@ struct lib { > struct marker_addr *markers_addr_start; > #endif > int markers_count; > - struct list_head list; > + struct cds_list_head list; > }; > > extern int marker_register_lib(struct marker *markers_start, int markers_count); > diff --git a/include/ust/probe.h b/include/ust/probe.h > index 7285a2d..5002721 100644 > --- a/include/ust/probe.h > +++ b/include/ust/probe.h > @@ -38,7 +38,7 @@ struct ltt_available_probe { > const char *format; > marker_probe_func *probe_func; > ltt_serialize_cb callbacks[LTT_NR_CALLBACKS]; > - struct list_head node; /* registered probes list */ > + struct cds_list_head node; /* registered probes list */ > }; > > extern int ltt_probe_register(struct ltt_available_probe *pdata); > diff --git a/include/ust/processor.h b/include/ust/processor.h > index 68ac258..098e6b3 100644 > --- a/include/ust/processor.h > +++ b/include/ust/processor.h > @@ -25,7 +25,7 @@ > extern __thread long ust_reg_stack[500]; > extern volatile __thread long *ust_reg_stack_ptr; > > -#define ____cacheline_aligned __attribute__((aligned(CACHE_LINE_SIZE))) > +#define ____cacheline_aligned __attribute__((aligned(CAA_CACHE_LINE_SIZE))) > > #ifdef __i386 > > diff --git a/include/ust/tracepoint.h b/include/ust/tracepoint.h > index 1c4a384..1d286a0 100644 > --- a/include/ust/tracepoint.h > +++ b/include/ust/tracepoint.h > @@ -214,7 +214,7 @@ static inline void tracepoint_synchronize_unregister(void) > struct tracepoint_lib { > struct tracepoint *tracepoints_start; > int tracepoints_count; > - struct list_head list; > + struct cds_list_head list; > }; > > extern int tracepoint_register_lib(struct tracepoint *tracepoints_start, > @@ -346,7 +346,7 @@ struct trace_event { > struct trace_event_lib { > struct trace_event *trace_events_start; > int trace_events_count; > - struct list_head list; > + struct cds_list_head list; > }; > > struct trace_event_iter { > diff --git a/include/ust/ustd.h b/include/ust/ustd.h > index 0757acb..6336e69 100644 > --- a/include/ust/ustd.h > +++ b/include/ust/ustd.h > @@ -79,7 +79,7 @@ struct libustd_instance { > struct libustd_callbacks *callbacks; > int quit_program; > int is_init; > - struct list_head connections; > + struct cds_list_head connections; > int epoll_fd; > struct ustcomm_sock *listen_sock; > char *sock_path; > diff --git a/libust/buffers.c b/libust/buffers.c > index bb5d8c5..2e4bb66 100644 > --- a/libust/buffers.c > +++ b/libust/buffers.c > @@ -43,7 +43,7 @@ struct ltt_reserve_switch_offsets { > > > static DEFINE_MUTEX(ust_buffers_channels_mutex); > -static LIST_HEAD(ust_buffers_channels); > +static CDS_LIST_HEAD(ust_buffers_channels); > > static int get_n_cpus(void) > { > @@ -288,7 +288,7 @@ int ust_buffers_channel_open(struct ust_channel *chan, size_t subbuf_size, size_ > if (result == -1) > goto error; > } > - list_add(&chan->list, &ust_buffers_channels); > + cds_list_add(&chan->list, &ust_buffers_channels); > pthread_mutex_unlock(&ust_buffers_channels_mutex); > > return 0; > @@ -320,7 +320,7 @@ void ust_buffers_channel_close(struct ust_channel *chan) > ust_buffers_close_buf(chan->buf[i]); > } > > - list_del(&chan->list); > + cds_list_del(&chan->list); > kref_put(&chan->kref, ust_buffers_destroy_channel); > pthread_mutex_unlock(&ust_buffers_channels_mutex); > } > @@ -349,7 +349,7 @@ static void ltt_buffer_begin(struct ust_buffer *buf, > header->cycle_count_begin = tsc; > header->data_size = 0xFFFFFFFF; /* for recognizing crashed buffers */ > header->sb_size = 0xFFFFFFFF; /* for recognizing crashed buffers */ > - /* FIXME: add memory barrier? */ > + /* FIXME: add memory cmm_barrier? */ > ltt_write_trace_header(channel->trace, header); > } > > @@ -386,7 +386,7 @@ static notrace void ltt_buf_unfull(struct ust_buffer *buf, > } > > /* > - * Promote compiler barrier to a smp_mb(). > + * Promote compiler cmm_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. > @@ -414,7 +414,7 @@ int ust_buffers_get_subbuf(struct ust_buffer *buf, long *consumed) > * this is OK because then there is no wmb to execute there. > * If our thread is executing on the same CPU as the on the buffers > * belongs to, we don't have to synchronize it at all. If we are > - * migrated, the scheduler will take care of the memory barriers. > + * migrated, the scheduler will take care of the memory cmm_barriers. > * Normally, smp_call_function_single() should ensure program order when > * executing the remote function, which implies that it surrounds the > * function execution with : > @@ -429,7 +429,7 @@ int ust_buffers_get_subbuf(struct ust_buffer *buf, long *consumed) > * smp_mb() > * > * However, smp_call_function_single() does not seem to clearly execute > - * such barriers. It depends on spinlock semantic to provide the barrier > + * such cmm_barriers. It depends on spinlock semantic to provide the cmm_barrier > * before executing the IPI and, when busy-looping, csd_lock_wait only > * executes smp_mb() when it has to wait for the other CPU. > * > @@ -437,9 +437,9 @@ int ust_buffers_get_subbuf(struct ust_buffer *buf, long *consumed) > * required ourself, even if duplicated. It has no performance impact > * anyway. > * > - * smp_mb() is needed because smp_rmb() and smp_wmb() only order read vs > + * smp_mb() is needed because cmm_smp_rmb() and cmm_smp_wmb() only order read vs > * read and write vs write. They do not ensure core synchronization. We > - * really have to ensure total order between the 3 barriers running on > + * really have to ensure total order between the 3 cmm_barriers running on > * the 2 CPUs. > */ > //ust// #ifdef LTT_NO_IPI_BARRIER > @@ -447,7 +447,7 @@ int ust_buffers_get_subbuf(struct ust_buffer *buf, long *consumed) > * Local rmb to match the remote wmb to read the commit count before the > * buffer data and the write offset. > */ > - smp_rmb(); > + cmm_smp_rmb(); > //ust// #else > //ust// if (raw_smp_processor_id() != buf->cpu) { > //ust// smp_mb(); /* Total order with IPI handler smp_mb() */ > @@ -895,10 +895,10 @@ static void ltt_reserve_switch_old_subbuf( > > /* > * Must write slot data before incrementing commit count. > - * This compiler barrier is upgraded into a smp_wmb() by the IPI > - * sent by get_subbuf() when it does its smp_rmb(). > + * This compiler cmm_barrier is upgraded into a cmm_smp_wmb() by the IPI > + * sent by get_subbuf() when it does its cmm_smp_rmb(). > */ > - smp_wmb(); > + cmm_smp_wmb(); > uatomic_add(&buf->commit_count[oldidx].cc, padding_size); > commit_count = uatomic_read(&buf->commit_count[oldidx].cc); > ltt_check_deliver(chan, buf, offsets->old - 1, commit_count, oldidx); > @@ -924,10 +924,10 @@ static void ltt_reserve_switch_new_subbuf( > > /* > * Must write slot data before incrementing commit count. > - * This compiler barrier is upgraded into a smp_wmb() by the IPI > - * sent by get_subbuf() when it does its smp_rmb(). > + * This compiler cmm_barrier is upgraded into a cmm_smp_wmb() by the IPI > + * sent by get_subbuf() when it does its cmm_smp_rmb(). > */ > - smp_wmb(); > + cmm_smp_wmb(); > uatomic_add(&buf->commit_count[beginidx].cc, ltt_subbuffer_header_size()); > commit_count = uatomic_read(&buf->commit_count[beginidx].cc); > /* Check if the written buffer has to be delivered */ > @@ -969,10 +969,10 @@ static void ltt_reserve_end_switch_current( > > /* > * Must write slot data before incrementing commit count. > - * This compiler barrier is upgraded into a smp_wmb() by the IPI > - * sent by get_subbuf() when it does its smp_rmb(). > + * This compiler cmm_barrier is upgraded into a cmm_smp_wmb() by the IPI > + * sent by get_subbuf() when it does its cmm_smp_rmb(). > */ > - smp_wmb(); > + cmm_smp_wmb(); > uatomic_add(&buf->commit_count[endidx].cc, padding_size); > commit_count = uatomic_read(&buf->commit_count[endidx].cc); > ltt_check_deliver(chan, buf, > diff --git a/libust/buffers.h b/libust/buffers.h > index a2ad83e..e7630bb 100644 > --- a/libust/buffers.h > +++ b/libust/buffers.h > @@ -86,7 +86,7 @@ struct ust_buffer { > * List of buffers with an open pipe, used for fork and forced subbuffer > * switch. > */ > - struct list_head open_buffers_list; > + struct cds_list_head open_buffers_list; > > unsigned int finalized; > //ust// struct timer_list switch_timer; /* timer for periodical switch */ > @@ -276,7 +276,7 @@ static __inline__ int ltt_poll_deliver(struct ust_channel *chan, struct ust_buff > consumed_idx = SUBBUF_INDEX(consumed_old, buf->chan); > commit_count = uatomic_read(&buf->commit_count[consumed_idx].cc_sb); > /* > - * No memory barrier here, since we are only interested > + * No memory cmm_barrier here, since we are only interested > * in a statistically correct polling result. The next poll will > * get the data is we are racing. The mb() that ensures correct > * memory order is in get_subbuf. > @@ -375,7 +375,7 @@ static __inline__ int ltt_reserve_slot(struct ust_channel *chan, > * Perform retryable operations. > */ > /* FIXME: make this really per cpu? */ > - if (unlikely(LOAD_SHARED(ltt_nesting) > 4)) { > + if (unlikely(CMM_LOAD_SHARED(ltt_nesting) > 4)) { > DBG("Dropping event because nesting is too deep."); > uatomic_inc(&buf->events_lost); > return -EPERM; > @@ -488,7 +488,7 @@ static __inline__ void ltt_commit_slot( > long endidx = SUBBUF_INDEX(offset_end - 1, chan); > long commit_count; > > - smp_wmb(); > + cmm_smp_wmb(); > > uatomic_add(&buf->commit_count[endidx].cc, slot_size); > /* > @@ -574,7 +574,7 @@ size_t ust_buffers_do_strncpy(void *dest, const void *src, size_t len, > * don't have constants, so gcc generally uses a function call. > */ > for (; len > 0; len--) { > - *(u8 *)dest = LOAD_SHARED(*(const u8 *)src); > + *(u8 *)dest = CMM_LOAD_SHARED(*(const u8 *)src); > /* Check with dest, because src may be modified concurrently */ > if (*(const u8 *)dest == '\0') { > len--; > diff --git a/libust/channels.c b/libust/channels.c > index 57e9801..6716b5d 100644 > --- a/libust/channels.c > +++ b/libust/channels.c > @@ -33,7 +33,7 @@ > * ltt_channel_mutex mutex may be nested inside markers mutex. > */ > static DEFINE_MUTEX(ltt_channel_mutex); > -static LIST_HEAD(ltt_channels); > +static CDS_LIST_HEAD(ltt_channels); > /* > * Index of next channel in array. Makes sure that as long as a trace channel is > * allocated, no array index will be re-used when a channel is freed and then > @@ -51,7 +51,7 @@ static struct ltt_channel_setting *lookup_channel(const char *name) > { > struct ltt_channel_setting *iter; > > - list_for_each_entry(iter, <t_channels, list) > + cds_list_for_each_entry(iter, <t_channels, list) > if (strcmp(name, iter->name) == 0) > return iter; > return NULL; > @@ -72,11 +72,11 @@ static void release_channel_setting(struct kref *kref) > > if (uatomic_read(&index_kref.refcount) == 0 > && uatomic_read(&setting->kref.refcount) == 0) { > - list_del(&setting->list); > + cds_list_del(&setting->list); > free(setting); > > free_index = 0; > - list_for_each_entry(iter, <t_channels, list) { > + cds_list_for_each_entry(iter, <t_channels, list) { > iter->index = free_index++; > iter->free_event_id = 0; > } > @@ -94,7 +94,7 @@ static void release_trace_channel(struct kref *kref) > { > struct ltt_channel_setting *iter, *n; > > - list_for_each_entry_safe(iter, n, <t_channels, list) > + cds_list_for_each_entry_safe(iter, n, <t_channels, list) > release_channel_setting(&iter->kref); > } > > @@ -124,7 +124,7 @@ int ltt_channels_register(const char *name) > ret = -ENOMEM; > goto end; > } > - list_add(&setting->list, <t_channels); > + cds_list_add(&setting->list, <t_channels); > strncpy(setting->name, name, PATH_MAX-1); > setting->index = free_index++; > init_kref: > @@ -197,7 +197,7 @@ const char *ltt_channels_get_name_from_index(unsigned int index) > { > struct ltt_channel_setting *iter; > > - list_for_each_entry(iter, <t_channels, list) > + cds_list_for_each_entry(iter, <t_channels, list) > if (iter->index == index && uatomic_read(&iter->kref.refcount)) > return iter->name; > return NULL; > @@ -209,7 +209,7 @@ ltt_channels_get_setting_from_name(const char *name) > { > struct ltt_channel_setting *iter; > > - list_for_each_entry(iter, <t_channels, list) > + cds_list_for_each_entry(iter, <t_channels, list) > if (!strcmp(iter->name, name) > && uatomic_read(&iter->kref.refcount)) > return iter; > @@ -269,7 +269,7 @@ struct ust_channel *ltt_channels_trace_alloc(unsigned int *nr_channels, > WARN("ltt_channel_struct: channel null after alloc"); > goto end; > } > - list_for_each_entry(iter, <t_channels, list) { > + cds_list_for_each_entry(iter, <t_channels, list) { > if (!uatomic_read(&iter->kref.refcount)) > continue; > channel[iter->index].subbuf_size = iter->subbuf_size; > diff --git a/libust/channels.h b/libust/channels.h > index 2000430..6db8e63 100644 > --- a/libust/channels.h > +++ b/libust/channels.h > @@ -61,14 +61,14 @@ struct ust_channel { > > u32 version; > size_t alloc_size; > - struct list_head list; > + struct cds_list_head list; > } ____cacheline_aligned; > > struct ltt_channel_setting { > unsigned int subbuf_size; > unsigned int subbuf_cnt; > struct kref kref; /* Number of references to structure content */ > - struct list_head list; > + struct cds_list_head list; > unsigned int index; /* index of channel in trace channel array */ > u16 free_event_id; /* Next event ID to allocate */ > char name[PATH_MAX]; > diff --git a/libust/marker-control.c b/libust/marker-control.c > index db7311a..3ad2e6a 100644 > --- a/libust/marker-control.c > +++ b/libust/marker-control.c > @@ -31,7 +31,7 @@ > #define DEFAULT_CHANNEL "cpu" > #define DEFAULT_PROBE "default" > > -LIST_HEAD(probes_list); > +CDS_LIST_HEAD(probes_list); > > /* > * Mutex protecting the probe slab cache. > @@ -47,11 +47,11 @@ struct ltt_available_probe default_probe = { > }; > > //ust//static struct kmem_cache *markers_loaded_cachep; > -static LIST_HEAD(markers_loaded_list); > +static CDS_LIST_HEAD(markers_loaded_list); > /* > * List sorted by name strcmp order. > */ > -static LIST_HEAD(probes_registered_list); > +static CDS_LIST_HEAD(probes_registered_list); > > //ust// static struct proc_dir_entry *pentry; > > @@ -64,7 +64,7 @@ static struct ltt_available_probe *get_probe_from_name(const char *pname) > > if (!pname) > pname = DEFAULT_PROBE; > - list_for_each_entry(iter, &probes_registered_list, node) { > + cds_list_for_each_entry(iter, &probes_registered_list, node) { > comparison = strcmp(pname, iter->name); > if (!comparison) > found = 1; > @@ -108,19 +108,19 @@ int ltt_probe_register(struct ltt_available_probe *pdata) > struct ltt_available_probe *iter; > > pthread_mutex_lock(&probes_mutex); > - list_for_each_entry_reverse(iter, &probes_registered_list, node) { > + cds_list_for_each_entry_reverse(iter, &probes_registered_list, node) { > comparison = strcmp(pdata->name, iter->name); > if (!comparison) { > ret = -EBUSY; > goto end; > } else if (comparison > 0) { > /* We belong to the location right after iter. */ > - list_add(&pdata->node, &iter->node); > + cds_list_add(&pdata->node, &iter->node); > goto end; > } > } > /* Should be added at the head of the list */ > - list_add(&pdata->node, &probes_registered_list); > + cds_list_add(&pdata->node, &probes_registered_list); > end: > pthread_mutex_unlock(&probes_mutex); > return ret; > @@ -135,17 +135,17 @@ int ltt_probe_unregister(struct ltt_available_probe *pdata) > struct ltt_active_marker *amark, *tmp; > > pthread_mutex_lock(&probes_mutex); > - list_for_each_entry_safe(amark, tmp, &markers_loaded_list, node) { > + cds_list_for_each_entry_safe(amark, tmp, &markers_loaded_list, node) { > if (amark->probe == pdata) { > ret = marker_probe_unregister_private_data( > pdata->probe_func, amark); > if (ret) > goto end; > - list_del(&amark->node); > + cds_list_del(&amark->node); > free(amark); > } > } > - list_del(&pdata->node); > + cds_list_del(&pdata->node); > end: > pthread_mutex_unlock(&probes_mutex); > return ret; > @@ -189,7 +189,7 @@ int ltt_marker_connect(const char *channel, const char *mname, > if (ret) > free(pdata); > else > - list_add(&pdata->node, &markers_loaded_list); > + cds_list_add(&pdata->node, &markers_loaded_list); > end: > pthread_mutex_unlock(&probes_mutex); > ltt_unlock_traces(); > @@ -227,7 +227,7 @@ int ltt_marker_disconnect(const char *channel, const char *mname, > if (ret) > goto end; > else { > - list_del(&pdata->node); > + cds_list_del(&pdata->node); > free(pdata); > } > end: > @@ -391,10 +391,10 @@ static void disconnect_all_markers(void) > { > struct ltt_active_marker *pdata, *tmp; > > - list_for_each_entry_safe(pdata, tmp, &markers_loaded_list, node) { > + cds_list_for_each_entry_safe(pdata, tmp, &markers_loaded_list, node) { > marker_probe_unregister_private_data(pdata->probe->probe_func, > pdata); > - list_del(&pdata->node); > + cds_list_del(&pdata->node); > free(pdata); > } > } > diff --git a/libust/marker.c b/libust/marker.c > index cb8ffc1..39e12bb 100644 > --- a/libust/marker.c > +++ b/libust/marker.c > @@ -45,7 +45,7 @@ static const int marker_debug; > */ > static DEFINE_MUTEX(markers_mutex); > > -static LIST_HEAD(libs); > +static CDS_LIST_HEAD(libs); > > > void lock_markers(void) > @@ -127,7 +127,7 @@ notrace void __mark_empty_function(const struct marker *mdata, > * @...: Variable argument list. > * > * Since we do not use "typical" pointer based RCU in the 1 argument case, we > - * need to put a full smp_rmb() in this branch. This is why we do not use > + * need to put a full cmm_smp_rmb() in this branch. This is why we do not use > * rcu_dereference() for the pointer read. > */ > notrace void marker_probe_cb(const struct marker *mdata, > @@ -146,12 +146,12 @@ notrace void marker_probe_cb(const struct marker *mdata, > if (likely(!ptype)) { > marker_probe_func *func; > /* Must read the ptype before ptr. They are not data dependant, > - * so we put an explicit smp_rmb() here. */ > - smp_rmb(); > + * so we put an explicit cmm_smp_rmb() here. */ > + cmm_smp_rmb(); > func = mdata->single.func; > /* Must read the ptr before private data. They are not data > - * dependant, so we put an explicit smp_rmb() here. */ > - smp_rmb(); > + * dependant, so we put an explicit cmm_smp_rmb() here. */ > + cmm_smp_rmb(); > va_start(args, regs); > func(mdata, mdata->single.probe_private, regs, call_private, > mdata->format, &args); > @@ -162,16 +162,16 @@ notrace void marker_probe_cb(const struct marker *mdata, > /* > * Read mdata->ptype before mdata->multi. > */ > - smp_rmb(); > + cmm_smp_rmb(); > multi = mdata->multi; > /* > * multi points to an array, therefore accessing the array > * depends on reading multi. However, even in this case, > * we must insure that the pointer is read _before_ the array > - * data. Same as rcu_dereference, but we need a full smp_rmb() > - * in the fast path, so put the explicit barrier here. > + * data. Same as rcu_dereference, but we need a full cmm_smp_rmb() > + * in the fast path, so put the explicit cmm_barrier here. > */ > - smp_read_barrier_depends(); > + cmm_smp_read_barrier_depends(); > for (i = 0; multi[i].func; i++) { > va_start(args, regs); > multi[i].func(mdata, multi[i].probe_private, > @@ -202,12 +202,12 @@ static notrace void marker_probe_cb_noarg(const struct marker *mdata, > if (likely(!ptype)) { > marker_probe_func *func; > /* Must read the ptype before ptr. They are not data dependant, > - * so we put an explicit smp_rmb() here. */ > - smp_rmb(); > + * so we put an explicit cmm_smp_rmb() here. */ > + cmm_smp_rmb(); > func = mdata->single.func; > /* Must read the ptr before private data. They are not data > - * dependant, so we put an explicit smp_rmb() here. */ > - smp_rmb(); > + * dependant, so we put an explicit cmm_smp_rmb() here. */ > + cmm_smp_rmb(); > func(mdata, mdata->single.probe_private, regs, call_private, > mdata->format, &args); > } else { > @@ -216,16 +216,16 @@ static notrace void marker_probe_cb_noarg(const struct marker *mdata, > /* > * Read mdata->ptype before mdata->multi. > */ > - smp_rmb(); > + cmm_smp_rmb(); > multi = mdata->multi; > /* > * multi points to an array, therefore accessing the array > * depends on reading multi. However, even in this case, > * we must insure that the pointer is read _before_ the array > - * data. Same as rcu_dereference, but we need a full smp_rmb() > - * in the fast path, so put the explicit barrier here. > + * data. Same as rcu_dereference, but we need a full cmm_smp_rmb() > + * in the fast path, so put the explicit cmm_barrier here. > */ > - smp_read_barrier_depends(); > + cmm_smp_read_barrier_depends(); > for (i = 0; multi[i].func; i++) > multi[i].func(mdata, multi[i].probe_private, regs, > call_private, mdata->format, &args); > @@ -239,7 +239,7 @@ static void free_old_closure(struct rcu_head *head) > struct marker_entry, rcu); > free(entry->oldptr); > /* Make sure we free the data before setting the pending flag to 0 */ > - smp_wmb(); > + cmm_smp_wmb(); > entry->rcu_pending = 0; > } > > @@ -497,7 +497,7 @@ static int remove_marker(const char *channel, const char *name) > WARN_ON(ret); > /* Make sure the call_rcu has been executed */ > //ust// if (e->rcu_pending) > -//ust// rcu_barrier_sched(); > +//ust// rcu_cmm_barrier_sched(); > free(e); > return 0; > } > @@ -563,7 +563,7 @@ static int set_marker(struct marker_entry *entry, struct marker *elem, > * Make sure the private data is valid when we update the > * single probe ptr. > */ > - smp_wmb(); > + cmm_smp_wmb(); > elem->single.func = entry->single.func; > /* > * We also make sure that the new probe callbacks array is consistent > @@ -574,7 +574,7 @@ static int set_marker(struct marker_entry *entry, struct marker *elem, > * Update the function or multi probe array pointer before setting the > * ptype. > */ > - smp_wmb(); > + cmm_smp_wmb(); > elem->ptype = entry->ptype; > > if (elem->tp_name && (active ^ _imv_read(elem->state))) { > @@ -641,7 +641,7 @@ static void disable_marker(struct marker *elem) > elem->state__imv = 0; > elem->single.func = __mark_empty_function; > /* Update the function before setting the ptype */ > - smp_wmb(); > + cmm_smp_wmb(); > elem->ptype = 0; /* single probe */ > /* > * Leave the private data and channel_id/event_id there, because removal > @@ -716,7 +716,7 @@ static void lib_update_markers(void) > > /* FIXME: we should probably take a mutex here on libs */ > //ust// pthread_mutex_lock(&module_mutex); > - list_for_each_entry(lib, &libs, list) > + cds_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); > @@ -816,7 +816,7 @@ int marker_probe_register(const char *channel, const char *name, > * make sure it's executed now. > */ > //ust// if (entry->rcu_pending) > -//ust// rcu_barrier_sched(); > +//ust// rcu_cmm_barrier_sched(); > old = marker_entry_add_probe(entry, probe, probe_private); > if (IS_ERR(old)) { > ret = PTR_ERR(old); > @@ -835,11 +835,11 @@ int marker_probe_register(const char *channel, const char *name, > if (!entry) > goto end; > //ust// if (entry->rcu_pending) > -//ust// rcu_barrier_sched(); > +//ust// rcu_cmm_barrier_sched(); > entry->oldptr = old; > entry->rcu_pending = 1; > /* write rcu_pending before calling the RCU callback */ > - smp_wmb(); > + cmm_smp_wmb(); > //ust// call_rcu_sched(&entry->rcu, free_old_closure); > synchronize_rcu(); free_old_closure(&entry->rcu); > goto end; > @@ -881,7 +881,7 @@ int marker_probe_unregister(const char *channel, const char *name, > if (!entry) > goto end; > //ust// if (entry->rcu_pending) > -//ust// rcu_barrier_sched(); > +//ust// rcu_cmm_barrier_sched(); > old = marker_entry_remove_probe(entry, probe, probe_private); > pthread_mutex_unlock(&markers_mutex); > > @@ -892,11 +892,11 @@ int marker_probe_unregister(const char *channel, const char *name, > if (!entry) > goto end; > //ust// if (entry->rcu_pending) > -//ust// rcu_barrier_sched(); > +//ust// rcu_cmm_barrier_sched(); > entry->oldptr = old; > entry->rcu_pending = 1; > /* write rcu_pending before calling the RCU callback */ > - smp_wmb(); > + cmm_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 */ > @@ -966,7 +966,7 @@ int marker_probe_unregister_private_data(marker_probe_func *probe, > goto end; > } > //ust// if (entry->rcu_pending) > -//ust// rcu_barrier_sched(); > +//ust// rcu_cmm_barrier_sched(); > old = marker_entry_remove_probe(entry, NULL, probe_private); > channel = strdup(entry->channel); > name = strdup(entry->name); > @@ -979,11 +979,11 @@ int marker_probe_unregister_private_data(marker_probe_func *probe, > if (!entry) > goto end; > //ust// if (entry->rcu_pending) > -//ust// rcu_barrier_sched(); > +//ust// rcu_cmm_barrier_sched(); > entry->oldptr = old; > entry->rcu_pending = 1; > /* write rcu_pending before calling the RCU callback */ > - smp_wmb(); > + cmm_smp_wmb(); > //ust// call_rcu_sched(&entry->rcu, free_old_closure); > synchronize_rcu(); free_old_closure(&entry->rcu); > /* Ignore busy error message */ > @@ -1086,7 +1086,7 @@ int lib_get_iter_markers(struct marker_iter *iter) > int found = 0; > > //ust// pthread_mutex_lock(&module_mutex); > - list_for_each_entry(iter_lib, &libs, list) { > + cds_list_for_each_entry(iter_lib, &libs, list) { > if (iter_lib < iter->lib) > continue; > else if (iter_lib > iter->lib) > @@ -1370,7 +1370,7 @@ int marker_register_lib(struct marker *markers_start, int markers_count) > > /* FIXME: maybe protect this with its own mutex? */ > lock_markers(); > - list_add(&pl->list, &libs); > + cds_list_add(&pl->list, &libs); > unlock_markers(); > > new_markers(markers_start, markers_start + markers_count); > @@ -1394,10 +1394,10 @@ int marker_unregister_lib(struct marker *markers_start) > > /* FIXME: we should probably take a mutex here on libs */ > //ust// pthread_mutex_lock(&module_mutex); > - list_for_each_entry(lib, &libs, list) { > + cds_list_for_each_entry(lib, &libs, list) { > if(lib->markers_start == markers_start) { > struct lib *lib2free = lib; > - list_del(&lib->list); > + cds_list_del(&lib->list); > free(lib2free); > break; > } > diff --git a/libust/serialize.c b/libust/serialize.c > index bd947ab..8aa3f4b 100644 > --- a/libust/serialize.c > +++ b/libust/serialize.c > @@ -429,7 +429,7 @@ static inline size_t serialize_trace_data(struct ust_buffer *buf, > */ > tracer_stack_pos++; > assert(tracer_stack_pos <= TRACER_STACK_LEN); > - barrier(); > + cmm_barrier(); > tracer_stack[*stack_pos_ctx] = > strlen(tmp.v_string.s) + 1; > } > @@ -657,9 +657,9 @@ notrace void ltt_vtrace(const struct marker *mdata, void *probe_data, > cpu = ust_get_cpu(); > > /* Force volatile access. */ > - STORE_SHARED(ltt_nesting, LOAD_SHARED(ltt_nesting) + 1); > + CMM_STORE_SHARED(ltt_nesting, CMM_LOAD_SHARED(ltt_nesting) + 1); > stack_pos_ctx = tracer_stack_pos; > - barrier(); > + cmm_barrier(); > > pdata = (struct ltt_active_marker *)probe_data; > eID = mdata->event_id; > @@ -685,7 +685,7 @@ notrace void ltt_vtrace(const struct marker *mdata, void *probe_data, > va_end(args_copy); > > /* Iterate on each trace */ > - list_for_each_entry_rcu(trace, <t_traces.head, list) { > + cds_list_for_each_entry_rcu(trace, <t_traces.head, list) { > /* > * Expect the filter to filter out events. If we get here, > * we went through tracepoint activation as a first step. > @@ -745,9 +745,9 @@ notrace void ltt_vtrace(const struct marker *mdata, void *probe_data, > DBG("just commited event (%s/%s) at offset %ld and size %zd", mdata->channel, mdata->name, buf_offset, slot_size); > } > > - barrier(); > + cmm_barrier(); > tracer_stack_pos = stack_pos_ctx; > - STORE_SHARED(ltt_nesting, LOAD_SHARED(ltt_nesting) - 1); > + CMM_STORE_SHARED(ltt_nesting, CMM_LOAD_SHARED(ltt_nesting) - 1); > > rcu_read_unlock(); //ust// rcu_read_unlock_sched_notrace(); > } > diff --git a/libust/trace_event.c b/libust/trace_event.c > index af1e3fb..76628c5 100644 > --- a/libust/trace_event.c > +++ b/libust/trace_event.c > @@ -27,7 +27,7 @@ > #include > > /* libraries that contain trace_events (struct trace_event_lib) */ > -static LIST_HEAD(libs); > +static CDS_LIST_HEAD(libs); > > static DEFINE_MUTEX(trace_events_mutex); > > @@ -47,7 +47,7 @@ int lib_get_iter_trace_events(struct trace_event_iter *iter) > struct trace_event_lib *iter_lib; > int found = 0; > > - list_for_each_entry(iter_lib, &libs, list) { > + cds_list_for_each_entry(iter_lib, &libs, list) { > if (iter_lib < iter->lib) > continue; > else if (iter_lib > iter->lib) > @@ -128,7 +128,7 @@ int trace_event_register_lib(struct trace_event *trace_events_start, > > /* FIXME: maybe protect this with its own mutex? */ > pthread_mutex_lock(&trace_events_mutex); > - list_add(&pl->list, &libs); > + cds_list_add(&pl->list, &libs); > pthread_mutex_unlock(&trace_events_mutex); > > DBG("just registered a trace_events section from %p and having %d trace_events", trace_events_start, trace_events_count); > @@ -142,10 +142,10 @@ int trace_event_unregister_lib(struct trace_event *trace_events_start) > > pthread_mutex_lock(&trace_events_mutex); > > - list_for_each_entry(lib, &libs, list) { > + cds_list_for_each_entry(lib, &libs, list) { > if(lib->trace_events_start == trace_events_start) { > struct trace_event_lib *lib2free = lib; > - list_del(&lib->list); > + cds_list_del(&lib->list); > free(lib2free); > break; > } > diff --git a/libust/tracectl.c b/libust/tracectl.c > index d5ca7d2..7c05467 100644 > --- a/libust/tracectl.c > +++ b/libust/tracectl.c > @@ -66,9 +66,9 @@ static struct ustcomm_sock *listen_sock; > > extern struct chan_info_struct chan_infos[]; > > -static struct list_head open_buffers_list = LIST_HEAD_INIT(open_buffers_list); > +static struct cds_list_head open_buffers_list = CDS_LIST_HEAD_INIT(open_buffers_list); > > -static struct list_head ust_socks = LIST_HEAD_INIT(ust_socks); > +static struct cds_list_head ust_socks = CDS_LIST_HEAD_INIT(ust_socks); > > /* volatile because shared between the listener and the main thread */ > int buffers_to_export = 0; > @@ -216,8 +216,8 @@ static void inform_consumer_daemon(const char *trace_name) > ch_name = trace->channels[i].channel_name; > request_buffer_consumer(sock, trace_name, > ch_name, j); > - STORE_SHARED(buffers_to_export, > - LOAD_SHARED(buffers_to_export)+1); > + CMM_STORE_SHARED(buffers_to_export, > + CMM_LOAD_SHARED(buffers_to_export)+1); > } > } > } > @@ -473,13 +473,13 @@ static int notify_buffer_mapped(const char *trace_name, > */ > if (uatomic_read(&buf->consumed) == 0) { > DBG("decrementing buffers_to_export"); > - STORE_SHARED(buffers_to_export, LOAD_SHARED(buffers_to_export)-1); > + CMM_STORE_SHARED(buffers_to_export, CMM_LOAD_SHARED(buffers_to_export)-1); > } > > /* The buffer has been exported, ergo, we can add it to the > * list of open buffers > */ > - list_add(&buf->open_buffers_list, &open_buffers_list); > + cds_list_add(&buf->open_buffers_list, &open_buffers_list); > > unlock_traces: > ltt_unlock_traces(); > @@ -539,7 +539,7 @@ static void force_subbuf_switch() > { > struct ust_buffer *buf; > > - list_for_each_entry(buf, &open_buffers_list, > + cds_list_for_each_entry(buf, &open_buffers_list, > open_buffers_list) { > ltt_force_switch(buf, FORCE_FLUSH); > } > @@ -1312,7 +1312,7 @@ static void __attribute__((constructor)) init() > if (getenv("UST_OVERWRITE")) { > int val = atoi(getenv("UST_OVERWRITE")); > if (val == 0 || val == 1) { > - STORE_SHARED(ust_channels_overwrite_by_default, val); > + CMM_STORE_SHARED(ust_channels_overwrite_by_default, val); > } else { > WARN("invalid value for UST_OVERWRITE"); > } > @@ -1321,7 +1321,7 @@ static void __attribute__((constructor)) init() > if (getenv("UST_AUTOCOLLECT")) { > int val = atoi(getenv("UST_AUTOCOLLECT")); > if (val == 0 || val == 1) { > - STORE_SHARED(ust_channels_request_collection_by_default, val); > + CMM_STORE_SHARED(ust_channels_request_collection_by_default, val); > } else { > WARN("invalid value for UST_AUTOCOLLECT"); > } > @@ -1453,7 +1453,7 @@ static int trace_recording(void) > > ltt_lock_traces(); > > - list_for_each_entry(trace, <t_traces.head, list) { > + cds_list_for_each_entry(trace, <t_traces.head, list) { > if (trace->active) { > retval = 1; > break; > @@ -1513,10 +1513,10 @@ static void __attribute__((destructor)) keepalive() > return; > } > > - if (trace_recording() && LOAD_SHARED(buffers_to_export)) { > + if (trace_recording() && CMM_LOAD_SHARED(buffers_to_export)) { > int total = 0; > DBG("Keeping process alive for consumer daemon..."); > - while (LOAD_SHARED(buffers_to_export)) { > + while (CMM_LOAD_SHARED(buffers_to_export)) { > const int interv = 200000; > restarting_usleep(interv); > total += interv; > @@ -1572,12 +1572,12 @@ static void ust_fork(void) > ltt_trace_stop("auto"); > ltt_trace_destroy("auto", 1); > /* Delete all active connections, but leave them in the epoll set */ > - list_for_each_entry_safe(sock, sock_tmp, &ust_socks, list) { > + cds_list_for_each_entry_safe(sock, sock_tmp, &ust_socks, list) { > ustcomm_del_sock(sock, 1); > } > > /* Delete all blocked consumers */ > - list_for_each_entry_safe(buf, buf_tmp, &open_buffers_list, > + cds_list_for_each_entry_safe(buf, buf_tmp, &open_buffers_list, > open_buffers_list) { > result = close(buf->data_ready_fd_read); > if (result == -1) { > @@ -1587,7 +1587,7 @@ static void ust_fork(void) > if (result == -1) { > PERROR("close"); > } > - list_del(&buf->open_buffers_list); > + cds_list_del(&buf->open_buffers_list); > } > > /* Clean up the listener socket and epoll, keeping the scoket file */ > @@ -1595,7 +1595,7 @@ static void ust_fork(void) > close(epoll_fd); > > /* Re-start the launch sequence */ > - STORE_SHARED(buffers_to_export, 0); > + CMM_STORE_SHARED(buffers_to_export, 0); > have_listener = 0; > > /* Set up epoll */ > diff --git a/libust/tracepoint.c b/libust/tracepoint.c > index 6fe9cd7..dbaca6f 100644 > --- a/libust/tracepoint.c > +++ b/libust/tracepoint.c > @@ -35,7 +35,7 @@ > static const int tracepoint_debug; > > /* libraries that contain tracepoints (struct tracepoint_lib) */ > -static LIST_HEAD(libs); > +static CDS_LIST_HEAD(libs); > > /* > * tracepoints_mutex nests inside module_mutex. Tracepoints mutex protects the > @@ -67,7 +67,7 @@ struct tracepoint_entry { > struct tp_probes { > union { > //ust// struct rcu_head rcu; > - struct list_head list; > + struct cds_list_head list; > } u; > struct probe probes[0]; > }; > @@ -257,10 +257,10 @@ static void set_tracepoint(struct tracepoint_entry **entry, > WARN_ON(strcmp((*entry)->name, elem->name) != 0); > > /* > - * rcu_assign_pointer has a smp_wmb() which makes sure that the new > + * rcu_assign_pointer has a cmm_smp_wmb() which makes sure that the new > * probe callbacks array is consistent before setting a pointer to it. > * This array is referenced by __DO_TRACE from > - * include/linux/tracepoints.h. A matching smp_read_barrier_depends() > + * include/linux/tracepoints.h. A matching cmm_smp_read_barrier_depends() > * is used. > */ > rcu_assign_pointer(elem->probes, (*entry)->probes); > @@ -314,7 +314,7 @@ static void lib_update_tracepoints(void) > struct tracepoint_lib *lib; > > //ust// pthread_mutex_lock(&module_mutex); > - list_for_each_entry(lib, &libs, list) > + cds_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); > @@ -420,7 +420,7 @@ int tracepoint_probe_unregister(const char *name, void *probe, void *data) > } > //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_unregister); > > -static LIST_HEAD(old_probes); > +static CDS_LIST_HEAD(old_probes); > static int need_update; > > static void tracepoint_add_old_probes(void *old) > @@ -429,7 +429,7 @@ static void tracepoint_add_old_probes(void *old) > if (old) { > struct tp_probes *tp_probes = _ust_container_of(old, > struct tp_probes, probes[0]); > - list_add(&tp_probes->u.list, &old_probes); > + cds_list_add(&tp_probes->u.list, &old_probes); > } > } > > @@ -486,7 +486,7 @@ int tracepoint_probe_unregister_noupdate(const char *name, void *probe, > */ > void tracepoint_probe_update_all(void) > { > - LIST_HEAD(release_probes); > + CDS_LIST_HEAD(release_probes); > struct tp_probes *pos, *next; > > pthread_mutex_lock(&tracepoints_mutex); > @@ -494,14 +494,14 @@ void tracepoint_probe_update_all(void) > pthread_mutex_unlock(&tracepoints_mutex); > return; > } > - if (!list_empty(&old_probes)) > - list_replace_init(&old_probes, &release_probes); > + if (!cds_list_empty(&old_probes)) > + cds_list_replace_init(&old_probes, &release_probes); > need_update = 0; > pthread_mutex_unlock(&tracepoints_mutex); > > tracepoint_update_probes(); > - list_for_each_entry_safe(pos, next, &release_probes, u.list) { > - list_del(&pos->u.list); > + cds_list_for_each_entry_safe(pos, next, &release_probes, u.list) { > + cds_list_del(&pos->u.list); > //ust// call_rcu_sched(&pos->u.rcu, rcu_free_old_probes); > synchronize_rcu(); > free(pos); > @@ -519,7 +519,7 @@ int lib_get_iter_tracepoints(struct tracepoint_iter *iter) > int found = 0; > > //ust// pthread_mutex_lock(&module_mutex); > - list_for_each_entry(iter_lib, &libs, list) { > + cds_list_for_each_entry(iter_lib, &libs, list) { > if (iter_lib < iter->lib) > continue; > else if (iter_lib > iter->lib) > @@ -668,7 +668,7 @@ int tracepoint_register_lib(struct tracepoint *tracepoints_start, int tracepoint > > /* FIXME: maybe protect this with its own mutex? */ > pthread_mutex_lock(&tracepoints_mutex); > - list_add(&pl->list, &libs); > + cds_list_add(&pl->list, &libs); > pthread_mutex_unlock(&tracepoints_mutex); > > new_tracepoints(tracepoints_start, tracepoints_start + tracepoints_count); > @@ -687,10 +687,10 @@ int tracepoint_unregister_lib(struct tracepoint *tracepoints_start) > > pthread_mutex_lock(&tracepoints_mutex); > > - list_for_each_entry(lib, &libs, list) { > + cds_list_for_each_entry(lib, &libs, list) { > if(lib->tracepoints_start == tracepoints_start) { > struct tracepoint_lib *lib2free = lib; > - list_del(&lib->list); > + cds_list_del(&lib->list); > free(lib2free); > break; > } > diff --git a/libust/tracer.c b/libust/tracer.c > index c9422c8..ecf403a 100644 > --- a/libust/tracer.c > +++ b/libust/tracer.c > @@ -181,7 +181,7 @@ static enum ltt_channels get_channel_type_from_name(const char *name) > //ust// > //ust// } > > -static LIST_HEAD(ltt_transport_list); > +static CDS_LIST_HEAD(ltt_transport_list); > > /** > * ltt_transport_register - LTT transport registration > @@ -205,7 +205,7 @@ void ltt_transport_register(struct ltt_transport *transport) > //ust// vmalloc_sync_all(); > > ltt_lock_traces(); > - list_add_tail(&transport->node, <t_transport_list); > + cds_list_add_tail(&transport->node, <t_transport_list); > ltt_unlock_traces(); > } > > @@ -216,7 +216,7 @@ void ltt_transport_register(struct ltt_transport *transport) > void ltt_transport_unregister(struct ltt_transport *transport) > { > ltt_lock_traces(); > - list_del(&transport->node); > + cds_list_del(&transport->node); > ltt_unlock_traces(); > } > > @@ -275,7 +275,7 @@ static void trace_async_wakeup(struct ust_trace *trace) > //ust// #else > //ust// ltt_lock_traces(); > //ust// #endif > -//ust// list_for_each_entry_rcu(trace, <t_traces.head, list) { > +//ust// cds_list_for_each_entry_rcu(trace, <t_traces.head, list) { > //ust// trace_async_wakeup(trace); > //ust// } > //ust// #ifndef CONFIG_PREEMPT_RT > @@ -297,7 +297,7 @@ struct ust_trace *_ltt_trace_find(const char *trace_name) > { > struct ust_trace *trace; > > - list_for_each_entry(trace, <t_traces.head, list) > + cds_list_for_each_entry(trace, <t_traces.head, list) > if (!strncmp(trace->trace_name, trace_name, NAME_MAX)) > return trace; > > @@ -313,7 +313,7 @@ struct ust_trace *_ltt_trace_find_setup(const char *trace_name) > { > struct ust_trace *trace; > > - list_for_each_entry(trace, <t_traces.setup_head, list) > + cds_list_for_each_entry(trace, <t_traces.setup_head, list) > if (!strncmp(trace->trace_name, trace_name, NAME_MAX)) > return trace; > > @@ -417,7 +417,7 @@ int _ltt_trace_setup(const char *trace_name) > chan_infos[chantype].def_subbufcount; > } > > - list_add(&new_trace->list, <t_traces.setup_head); > + cds_list_add(&new_trace->list, <t_traces.setup_head); > return 0; > > trace_free: > @@ -439,7 +439,7 @@ int ltt_trace_setup(const char *trace_name) > /* must be called from within a traces lock. */ > static void _ltt_trace_free(struct ust_trace *trace) > { > - list_del(&trace->list); > + cds_list_del(&trace->list); > free(trace); > } > > @@ -458,7 +458,7 @@ int ltt_trace_set_type(const char *trace_name, const char *trace_type) > goto traces_error; > } > > - list_for_each_entry(tran_iter, <t_transport_list, node) { > + cds_list_for_each_entry(tran_iter, <t_transport_list, node) { > if (!strcmp(tran_iter->name, trace_type)) { > transport = tran_iter; > break; > @@ -692,13 +692,13 @@ int ltt_trace_alloc(const char *trace_name) > } > } > > - list_del(&trace->list); > -//ust// if (list_empty(<t_traces.head)) { > + cds_list_del(&trace->list); > +//ust// if (cds_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); > + cds_list_add_rcu(&trace->list, <t_traces.head); > //ust// synchronize_sched(); > > ltt_unlock_traces(); > @@ -762,9 +762,9 @@ static int _ltt_trace_destroy(struct ust_trace *trace) > goto active_error; > } > /* Everything went fine */ > - list_del_rcu(&trace->list); > + cds_list_del_rcu(&trace->list); > synchronize_rcu(); > - if (list_empty(<t_traces.head)) { > + if (cds_list_empty(<t_traces.head)) { > //ust// clear_kernel_trace_flag_all_tasks(); > /* > * We stop the asynchronous delivery of reader wakeup, but > diff --git a/libust/tracer.h b/libust/tracer.h > index c5df6ec..c316c9a 100644 > --- a/libust/tracer.h > +++ b/libust/tracer.h > @@ -94,7 +94,7 @@ struct chan_info_struct { > }; > > struct ltt_active_marker { > - struct list_head node; /* active markers list */ > + struct cds_list_head node; /* active markers list */ > const char *channel; > const char *name; > const char *format; > @@ -158,7 +158,7 @@ struct ltt_trace_ops { > struct ltt_transport { > char *name; > struct module *owner; > - struct list_head node; > + struct cds_list_head node; > struct ltt_trace_ops ops; > }; > > @@ -170,7 +170,7 @@ enum trace_mode { LTT_TRACE_NORMAL, LTT_TRACE_FLIGHT, LTT_TRACE_HYBRID }; > /* Per-trace information - each trace/flight recorder represented by one */ > struct ust_trace { > /* First 32 bytes cache-hot cacheline */ > - struct list_head list; > + struct cds_list_head list; > struct ltt_trace_ops *ops; > int active; > /* Second 32 bytes cache-hot cacheline */ > diff --git a/libust/tracercore.c b/libust/tracercore.c > index bbc8691..1e418b6 100644 > --- a/libust/tracercore.c > +++ b/libust/tracercore.c > @@ -22,8 +22,8 @@ > > /* Traces structures */ > struct ltt_traces ltt_traces = { > - .setup_head = LIST_HEAD_INIT(ltt_traces.setup_head), > - .head = LIST_HEAD_INIT(ltt_traces.head), > + .setup_head = CDS_LIST_HEAD_INIT(ltt_traces.setup_head), > + .head = CDS_LIST_HEAD_INIT(ltt_traces.head), > }; > > /* Traces list writer locking */ > diff --git a/libust/tracercore.h b/libust/tracercore.h > index 5c396f4..9673cca 100644 > --- a/libust/tracercore.h > +++ b/libust/tracercore.h > @@ -32,8 +32,8 @@ > * list. > */ > struct ltt_traces { > - struct list_head setup_head; /* Pre-allocated traces list */ > - struct list_head head; /* Allocated Traces list */ > + struct cds_list_head setup_head; /* Pre-allocated traces list */ > + struct cds_list_head head; /* Allocated Traces list */ > unsigned int num_active_traces; /* Number of active traces */ > } ____cacheline_aligned; > > diff --git a/libust/type-serializer.c b/libust/type-serializer.c > index bf1c496..2c278df 100644 > --- a/libust/type-serializer.c > +++ b/libust/type-serializer.c > @@ -43,7 +43,7 @@ void _ltt_specialized_trace(const struct marker *mdata, void *probe_data, > cpu = ust_get_cpu(); > > /* Force volatile access. */ > - STORE_SHARED(ltt_nesting, LOAD_SHARED(ltt_nesting) + 1); > + CMM_STORE_SHARED(ltt_nesting, CMM_LOAD_SHARED(ltt_nesting) + 1); > > /* > * asm volatile and "memory" clobber prevent the compiler from moving > @@ -52,7 +52,7 @@ void _ltt_specialized_trace(const struct marker *mdata, void *probe_data, > * traps, divisions by 0, ...) are triggered within the incremented > * nesting count section. > */ > - barrier(); > + cmm_barrier(); > eID = mdata->event_id; > chan_index = mdata->channel_id; > > @@ -60,7 +60,7 @@ void _ltt_specialized_trace(const struct marker *mdata, void *probe_data, > * Iterate on each trace, typically small number of active traces, > * list iteration with prefetch is usually slower. > */ > - list_for_each_entry_rcu(trace, <t_traces.head, list) { > + cds_list_for_each_entry_rcu(trace, <t_traces.head, list) { > if (unlikely(!trace->active)) > continue; > //ust// if (unlikely(!ltt_run_filter(trace, eID))) > @@ -109,7 +109,7 @@ void _ltt_specialized_trace(const struct marker *mdata, void *probe_data, > * traps, divisions by 0, ...) are triggered within the incremented > * nesting count section. > */ > - barrier(); > - STORE_SHARED(ltt_nesting, LOAD_SHARED(ltt_nesting) - 1); > + cmm_barrier(); > + CMM_STORE_SHARED(ltt_nesting, CMM_LOAD_SHARED(ltt_nesting) - 1); > rcu_read_unlock(); > } > diff --git a/libustcomm/ustcomm.c b/libustcomm/ustcomm.c > index bbdbd7e..63eed5f 100644 > --- a/libustcomm/ustcomm.c > +++ b/libustcomm/ustcomm.c > @@ -113,7 +113,7 @@ static struct sockaddr_un * create_sock_addr(const char *name, > } > > struct ustcomm_sock * ustcomm_init_sock(int fd, int epoll_fd, > - struct list_head *list) > + struct cds_list_head *list) > { > struct epoll_event ev; > struct ustcomm_sock *sock; > @@ -136,9 +136,9 @@ struct ustcomm_sock * ustcomm_init_sock(int fd, int epoll_fd, > > sock->epoll_fd = epoll_fd; > if (list) { > - list_add(&sock->list, list); > + cds_list_add(&sock->list, list); > } else { > - INIT_LIST_HEAD(&sock->list); > + CDS_INIT_LIST_HEAD(&sock->list); > } > > return sock; > @@ -146,7 +146,7 @@ struct ustcomm_sock * ustcomm_init_sock(int fd, int epoll_fd, > > void ustcomm_del_sock(struct ustcomm_sock *sock, int keep_in_epoll) > { > - list_del(&sock->list); > + cds_list_del(&sock->list); > if (!keep_in_epoll) { > if (epoll_ctl(sock->epoll_fd, EPOLL_CTL_DEL, sock->fd, NULL) == -1) { > PERROR("epoll_ctl: failed to delete socket"); > diff --git a/libustcomm/ustcomm.h b/libustcomm/ustcomm.h > index ad4848a..689c151 100644 > --- a/libustcomm/ustcomm.h > +++ b/libustcomm/ustcomm.h > @@ -27,7 +27,7 @@ > #define SOCK_DIR "/tmp/ust-app-socks" > > struct ustcomm_sock { > - struct list_head list; > + struct cds_list_head list; > int fd; > int epoll_fd; > }; > @@ -127,7 +127,7 @@ extern int ensure_dir_exists(const char *dir); > > /* Create and delete sockets */ > extern struct ustcomm_sock * ustcomm_init_sock(int fd, int epoll_fd, > - struct list_head *list); > + struct cds_list_head *list); > extern void ustcomm_del_sock(struct ustcomm_sock *sock, int keep_in_epoll); > > /* Create and delete named sockets */ > diff --git a/libustd/libustd.c b/libustd/libustd.c > index 1581f83..0dc6940 100644 > --- a/libustd/libustd.c > +++ b/libustd/libustd.c > @@ -863,7 +863,7 @@ static int init_ustd_socket(struct libustd_instance *instance) > goto close_epoll; > } > > - INIT_LIST_HEAD(&instance->connections); > + CDS_INIT_LIST_HEAD(&instance->connections); > > free(name); > > -- > 1.7.3.2 > > > _______________________________________________ > ltt-dev mailing list > ltt-dev at lists.casi.polymtl.ca > http://lists.casi.polymtl.ca/cgi-bin/mailman/listinfo/ltt-dev > -- Mathieu Desnoyers Operating System Efficiency R&D Consultant EfficiOS Inc. http://www.efficios.com