[ltt-dev] [UST PATCH] Rename for the new liburcu API namespace
David Goulet
david.goulet at polymtl.ca
Thu Nov 18 23:19:37 EST 2010
This commit makes UST compatible with liburcu 0.5.2
Signed-off-by: David Goulet <david.goulet at polymtl.ca>
---
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 <urcu-bp.h>
/* 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
More information about the lttng-dev
mailing list