From: Mathieu Desnoyers Date: Thu, 2 May 2024 21:06:29 +0000 (-0400) Subject: Rename "tsc" to "timestamp" X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=3a6d09342ff21074eea4a686f459d921ca46c628;p=lttng-modules.git Rename "tsc" to "timestamp" Naming timestamps "TSC" or "tsc" is an historical artefact dating from the implementation of libringbuffer, where the initial intent was to use the x86 "rdtsc" instruction directly, which ended up not being what was done in reality. Rename uses of "TSC" and "tsc" to "timestamp" to clarify things and don't require reviewers to be fluent in x86 instruction set. Signed-off-by: Mathieu Desnoyers Change-Id: I09437b0cf6db79600ed1a423d1f6df0344f5c9f7 --- diff --git a/include/ringbuffer/backend_types.h b/include/ringbuffer/backend_types.h index 337f1cda..c23889ea 100644 --- a/include/ringbuffer/backend_types.h +++ b/include/ringbuffer/backend_types.h @@ -82,7 +82,7 @@ struct channel_backend { struct lttng_kernel_ring_buffer *buf; /* Channel per-cpu buffers */ unsigned long num_subbuf; /* Number of sub-buffers for writer */ - u64 start_tsc; /* Channel creation TSC value */ + u64 start_timestamp; /* Channel creation timestamp value */ void *priv; /* Client-specific information */ void *priv_ops; /* Client-specific ops pointer */ void (*release_priv_ops)(void *priv_ops); diff --git a/include/ringbuffer/config.h b/include/ringbuffer/config.h index 43523de3..e63463b0 100644 --- a/include/ringbuffer/config.h +++ b/include/ringbuffer/config.h @@ -41,9 +41,9 @@ struct lttng_kernel_ring_buffer_client_cb { /* Slow path only, at subbuffer switch */ size_t (*subbuffer_header_size) (void); - void (*buffer_begin) (struct lttng_kernel_ring_buffer *buf, u64 tsc, + void (*buffer_begin) (struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx); - void (*buffer_end) (struct lttng_kernel_ring_buffer *buf, u64 tsc, + void (*buffer_end) (struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx, unsigned long data_size, const struct lttng_kernel_ring_buffer_ctx *ctx); @@ -151,10 +151,10 @@ struct lttng_kernel_ring_buffer_config { */ } wakeup; /* - * tsc_bits: timestamp bits saved at each record. + * timestamp_bits: timestamp bits saved at each record. * 0 and 64 disable the timestamp compression scheme. */ - unsigned int tsc_bits; + unsigned int timestamp_bits; struct lttng_kernel_ring_buffer_client_cb cb; }; @@ -182,7 +182,7 @@ struct lttng_kernel_ring_buffer_ctx_private { * prior to record header alignment * padding. */ - u64 tsc; /* time-stamp counter value */ + u64 timestamp; /* time-stamp counter value */ unsigned int rflags; /* reservation flags */ struct lttng_kernel_ring_buffer *buf; /* @@ -244,18 +244,18 @@ void lib_ring_buffer_ctx_init(struct lttng_kernel_ring_buffer_ctx *ctx, /* * Reservation flags. * - * RING_BUFFER_RFLAG_FULL_TSC + * RING_BUFFER_RFLAG_FULL_TIMESTAMP * * This flag is passed to record_header_size() and to the primitive used to * write the record header. It indicates that the full 64-bit time value is * needed in the record header. If this flag is not set, the record header needs - * only to contain "tsc_bits" bit of time value. + * only to contain "timestamp_bits" bit of time value. * * Reservation flags can be added by the client, starting from * "(RING_BUFFER_FLAGS_END << 0)". It can be used to pass information from * record_header_size() to lib_ring_buffer_write_record_header(). */ -#define RING_BUFFER_RFLAG_FULL_TSC (1U << 0) +#define RING_BUFFER_RFLAG_FULL_TIMESTAMP (1U << 0) #define RING_BUFFER_RFLAG_END (1U << 1) #ifndef LTTNG_TRACER_CORE_H diff --git a/include/ringbuffer/frontend_api.h b/include/ringbuffer/frontend_api.h index b473a61b..e8d77d95 100644 --- a/include/ringbuffer/frontend_api.h +++ b/include/ringbuffer/frontend_api.h @@ -80,8 +80,8 @@ int lib_ring_buffer_try_reserve(const struct lttng_kernel_ring_buffer_config *co *o_begin = v_read(config, &buf->offset); *o_old = *o_begin; - ctx->priv.tsc = lib_ring_buffer_clock_read(chan); - if ((int64_t) ctx->priv.tsc == -EIO) + ctx->priv.timestamp = lib_ring_buffer_clock_read(chan); + if ((int64_t) ctx->priv.timestamp == -EIO) return 1; /* @@ -91,8 +91,8 @@ int lib_ring_buffer_try_reserve(const struct lttng_kernel_ring_buffer_config *co */ prefetch(&buf->commit_hot[subbuf_index(*o_begin, chan)]); - if (last_tsc_overflow(config, buf, ctx->priv.tsc)) - ctx->priv.rflags |= RING_BUFFER_RFLAG_FULL_TSC; + if (last_timestamp_overflow(config, buf, ctx->priv.timestamp)) + ctx->priv.rflags |= RING_BUFFER_RFLAG_FULL_TIMESTAMP; if (unlikely(subbuf_offset(*o_begin, chan) == 0)) return 1; @@ -128,7 +128,8 @@ int lib_ring_buffer_try_reserve(const struct lttng_kernel_ring_buffer_config *co * @ctx: ring buffer context. (input and output) Must be already initialized. * * Atomic wait-free slot reservation. The reserved space starts at the context - * "pre_offset". Its length is "slot_size". The associated time-stamp is "tsc". + * "pre_offset". Its length is "slot_size". The associated time-stamp is + * "timestamp". * * Return : * 0 on success. @@ -171,12 +172,12 @@ int lib_ring_buffer_reserve(const struct lttng_kernel_ring_buffer_config *config goto slow_path; /* - * Atomically update last_tsc. This update races against concurrent - * atomic updates, but the race will always cause supplementary full TSC - * record headers, never the opposite (missing a full TSC record header - * when it would be needed). + * Atomically update last_timestamp. This update races against concurrent + * atomic updates, but the race will always cause supplementary + * full timestamp record headers, never the opposite (missing a + * full timestamp record header when it would be needed). */ - save_last_tsc(config, ctx->priv.buf, ctx->priv.tsc); + save_last_timestamp(config, ctx->priv.buf, ctx->priv.timestamp); /* * Push the reader if necessary @@ -308,17 +309,18 @@ int lib_ring_buffer_try_discard_reserve(const struct lttng_kernel_ring_buffer_co /* * We need to ensure that if the cmpxchg succeeds and discards the - * record, the next record will record a full TSC, because it cannot - * rely on the last_tsc associated with the discarded record to detect - * overflows. The only way to ensure this is to set the last_tsc to 0 - * (assuming no 64-bit TSC overflow), which forces to write a 64-bit - * timestamp in the next record. + * record, the next record will record a full timestamp, because + * it cannot rely on the last_timestamp associated with the + * discarded record to detect overflows. The only way to ensure + * this is to set the last_timestamp to 0 (assuming no 64-bit + * timestamp overflow), which forces to write a 64-bit timestamp in + * the next record. * - * Note: if discard fails, we must leave the TSC in the record header. - * It is needed to keep track of TSC overflows for the following - * records. + * Note: if discard fails, we must leave the timestamp in the + * record header. It is needed to keep track of timestamp + * overflows for the following records. */ - save_last_tsc(config, buf, 0ULL); + save_last_timestamp(config, buf, 0ULL); if (likely(v_cmpxchg(config, &buf->offset, end_offset, ctx->priv.pre_offset) != end_offset)) diff --git a/include/ringbuffer/frontend_internal.h b/include/ringbuffer/frontend_internal.h index 999a7bb9..39dbbf08 100644 --- a/include/ringbuffer/frontend_internal.h +++ b/include/ringbuffer/frontend_internal.h @@ -71,62 +71,63 @@ unsigned long subbuf_index(unsigned long offset, struct lttng_kernel_ring_buffer } /* - * Last TSC comparison functions. Check if the current TSC overflows tsc_bits - * bits from the last TSC read. When overflows are detected, the full 64-bit - * timestamp counter should be written in the record header. Reads and writes - * last_tsc atomically. + * Last timestamp comparison functions. Check if the current timestamp + * overflows timestamp_bits bits from the last timestamp read. When + * overflows are detected, the full 64-bit timestamp counter should be + * written in the record header. Reads and writes last_timestamp + * atomically. */ #if (BITS_PER_LONG == 32) static inline -void save_last_tsc(const struct lttng_kernel_ring_buffer_config *config, - struct lttng_kernel_ring_buffer *buf, u64 tsc) +void save_last_timestamp(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, u64 timestamp) { - if (config->tsc_bits == 0 || config->tsc_bits == 64) + if (config->timestamp_bits == 0 || config->timestamp_bits == 64) return; /* * Ensure the compiler performs this update in a single instruction. */ - v_set(config, &buf->last_tsc, (unsigned long)(tsc >> config->tsc_bits)); + v_set(config, &buf->last_timestamp, (unsigned long)(timestamp >> config->timestamp_bits)); } static inline -int last_tsc_overflow(const struct lttng_kernel_ring_buffer_config *config, - struct lttng_kernel_ring_buffer *buf, u64 tsc) +int last_timestamp_overflow(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, u64 timestamp) { - unsigned long tsc_shifted; + unsigned long timestamp_shifted; - if (config->tsc_bits == 0 || config->tsc_bits == 64) + if (config->timestamp_bits == 0 || config->timestamp_bits == 64) return 0; - tsc_shifted = (unsigned long)(tsc >> config->tsc_bits); - if (unlikely(tsc_shifted - - (unsigned long)v_read(config, &buf->last_tsc))) + timestamp_shifted = (unsigned long)(timestamp >> config->timestamp_bits); + if (unlikely(timestamp_shifted + - (unsigned long)v_read(config, &buf->last_timestamp))) return 1; else return 0; } #else static inline -void save_last_tsc(const struct lttng_kernel_ring_buffer_config *config, - struct lttng_kernel_ring_buffer *buf, u64 tsc) +void save_last_timestamp(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, u64 timestamp) { - if (config->tsc_bits == 0 || config->tsc_bits == 64) + if (config->timestamp_bits == 0 || config->timestamp_bits == 64) return; - v_set(config, &buf->last_tsc, (unsigned long)tsc); + v_set(config, &buf->last_timestamp, (unsigned long)timestamp); } static inline -int last_tsc_overflow(const struct lttng_kernel_ring_buffer_config *config, - struct lttng_kernel_ring_buffer *buf, u64 tsc) +int last_timestamp_overflow(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, u64 timestamp) { - if (config->tsc_bits == 0 || config->tsc_bits == 64) + if (config->timestamp_bits == 0 || config->timestamp_bits == 64) return 0; - if (unlikely((tsc - v_read(config, &buf->last_tsc)) - >> config->tsc_bits)) + if (unlikely((timestamp - v_read(config, &buf->last_timestamp)) + >> config->timestamp_bits)) return 1; else return 0; @@ -264,7 +265,7 @@ int lib_ring_buffer_reserve_committed(const struct lttng_kernel_ring_buffer_conf } /* - * Receive end of subbuffer TSC as parameter. It has been read in the + * Receive end of subbuffer timestamp as parameter. It has been read in the * space reservation loop of either reserve or switch, which ensures it * progresses monotonically with event records in the buffer. Therefore, * it ensures that the end timestamp of a subbuffer is <= begin diff --git a/include/ringbuffer/frontend_types.h b/include/ringbuffer/frontend_types.h index 07d23be2..65782ea7 100644 --- a/include/ringbuffer/frontend_types.h +++ b/include/ringbuffer/frontend_types.h @@ -114,7 +114,7 @@ struct lttng_kernel_ring_buffer { */ atomic_t record_disabled; /* End of first 32 bytes cacheline */ - union v_atomic last_tsc; /* + union v_atomic last_timestamp; /* * Last timestamp written in the buffer. */ diff --git a/include/wrapper/trace-clock.h b/include/wrapper/trace-clock.h index adb1101f..18578a61 100644 --- a/include/wrapper/trace-clock.h +++ b/include/wrapper/trace-clock.h @@ -56,7 +56,7 @@ extern struct lttng_trace_clock *lttng_trace_clock; #ifdef LTTNG_USE_NMI_SAFE_CLOCK -DECLARE_PER_CPU(u64, lttng_last_tsc); +DECLARE_PER_CPU(u64, lttng_last_timestamp); /* * Sometimes called with preemption enabled. Can be interrupted. @@ -64,12 +64,12 @@ DECLARE_PER_CPU(u64, lttng_last_tsc); static inline u64 trace_clock_monotonic_wrapper(void) { u64 now, last, result; - u64 *last_tsc_ptr; + u64 *last_timestamp_ptr; /* Use fast nmi-safe monotonic clock provided by the Linux kernel. */ preempt_disable(); - last_tsc_ptr = this_cpu_ptr(<tng_last_tsc); - last = *last_tsc_ptr; + last_timestamp_ptr = this_cpu_ptr(<tng_last_timestamp); + last = *last_timestamp_ptr; /* * Read "last" before "now". It is not strictly required, but it ensures * that an interrupt coming in won't artificially trigger a case where @@ -80,7 +80,7 @@ static inline u64 trace_clock_monotonic_wrapper(void) now = ktime_get_mono_fast_ns(); if (U64_MAX / 2 < now - last) now = last; - result = cmpxchg64_local(last_tsc_ptr, last, now); + result = cmpxchg64_local(last_timestamp_ptr, last, now); preempt_enable(); if (result == last) { /* Update done. */ diff --git a/src/lib/ringbuffer/ring_buffer_backend.c b/src/lib/ringbuffer/ring_buffer_backend.c index 02a9d487..74d249f3 100644 --- a/src/lib/ringbuffer/ring_buffer_backend.c +++ b/src/lib/ringbuffer/ring_buffer_backend.c @@ -256,7 +256,7 @@ void channel_backend_reset(struct channel_backend *chanb) * num_subbuf_order, buf_size_order, extra_reader_sb, num_subbuf, * priv, notifiers, config, cpumask and name. */ - chanb->start_tsc = config->cb.ring_buffer_clock_read(chan); + chanb->start_timestamp = config->cb.ring_buffer_clock_read(chan); } #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) @@ -471,7 +471,7 @@ int channel_backend_init(struct channel_backend *chanb, if (ret) goto free_bufs; } - chanb->start_tsc = config->cb.ring_buffer_clock_read(chan); + chanb->start_timestamp = config->cb.ring_buffer_clock_read(chan); return 0; diff --git a/src/lib/ringbuffer/ring_buffer_frontend.c b/src/lib/ringbuffer/ring_buffer_frontend.c index fbf3a168..5e072883 100644 --- a/src/lib/ringbuffer/ring_buffer_frontend.c +++ b/src/lib/ringbuffer/ring_buffer_frontend.c @@ -173,7 +173,7 @@ void lib_ring_buffer_reset(struct lttng_kernel_ring_buffer *buf) } atomic_long_set(&buf->consumed, 0); atomic_set(&buf->record_disabled, 0); - v_set(config, &buf->last_tsc, 0); + v_set(config, &buf->last_timestamp, 0); lib_ring_buffer_backend_reset(&buf->backend); /* Don't reset number of active readers */ v_set(config, &buf->records_lost_full, 0); @@ -232,7 +232,7 @@ int lib_ring_buffer_create(struct lttng_kernel_ring_buffer *buf, struct lttng_kernel_ring_buffer_channel *chan = container_of(chanb, struct lttng_kernel_ring_buffer_channel, backend); void *priv = chanb->priv; size_t subbuf_header_size; - u64 tsc; + u64 timestamp; int ret; /* Test for cpu hotplug */ @@ -294,8 +294,8 @@ int lib_ring_buffer_create(struct lttng_kernel_ring_buffer *buf, subbuf_header_size = config->cb.subbuffer_header_size(); v_set(config, &buf->offset, subbuf_header_size); subbuffer_id_clear_noref(config, &buf->backend.buf_wsb[0].id); - tsc = config->cb.ring_buffer_clock_read(buf->backend.chan); - config->cb.buffer_begin(buf, tsc, 0); + timestamp = config->cb.ring_buffer_clock_read(buf->backend.chan); + config->cb.buffer_begin(buf, timestamp, 0); v_add(config, subbuf_header_size, &buf->commit_hot[0].cc); if (config->cb.buffer_create) { @@ -1599,7 +1599,7 @@ void lib_ring_buffer_switch_old_start(struct lttng_kernel_ring_buffer *buf, unsigned long commit_count; struct commit_counters_hot *cc_hot; - config->cb.buffer_begin(buf, ctx->priv.tsc, oldidx); + config->cb.buffer_begin(buf, ctx->priv.timestamp, oldidx); /* * Order all writes to buffer before the commit count update that will @@ -1658,7 +1658,7 @@ void lib_ring_buffer_switch_old_end(struct lttng_kernel_ring_buffer *buf, * postponed until the commit counter is incremented for the * current space reservation. */ - *ts_end = ctx->priv.tsc; + *ts_end = ctx->priv.timestamp; /* * Order all writes to buffer and store to ts_end before the commit @@ -1701,7 +1701,7 @@ void lib_ring_buffer_switch_new_start(struct lttng_kernel_ring_buffer *buf, unsigned long commit_count; struct commit_counters_hot *cc_hot; - config->cb.buffer_begin(buf, ctx->priv.tsc, beginidx); + config->cb.buffer_begin(buf, ctx->priv.timestamp, beginidx); /* * Order all writes to buffer before the commit count update that will @@ -1757,7 +1757,7 @@ void lib_ring_buffer_switch_new_end(struct lttng_kernel_ring_buffer *buf, * postponed until the commit counter is incremented for the * current space reservation. */ - *ts_end = ctx->priv.tsc; + *ts_end = ctx->priv.timestamp; } /* @@ -1780,7 +1780,7 @@ int lib_ring_buffer_try_switch_slow(enum switch_mode mode, offsets->switch_old_start = 0; off = subbuf_offset(offsets->begin, chan); - ctx->priv.tsc = config->cb.ring_buffer_clock_read(chan); + ctx->priv.timestamp = config->cb.ring_buffer_clock_read(chan); /* * Ensure we flush the header of an empty subbuffer when doing the @@ -1901,12 +1901,12 @@ void lib_ring_buffer_switch_slow(struct lttng_kernel_ring_buffer *buf, enum swit != offsets.old); /* - * Atomically update last_tsc. This update races against concurrent - * atomic updates, but the race will always cause supplementary full TSC - * records, never the opposite (missing a full TSC record when it would - * be needed). + * Atomically update last_timestamp. This update races against concurrent + * atomic updates, but the race will always cause supplementary + * full timestamp records, never the opposite (missing a full + * timestamp record when it would be needed). */ - save_last_tsc(config, buf, ctx.priv.tsc); + save_last_timestamp(config, buf, ctx.priv.timestamp); /* * Push the reader if necessary @@ -2029,12 +2029,12 @@ retry: offsets->switch_old_end = 0; offsets->pre_header_padding = 0; - ctx->priv.tsc = config->cb.ring_buffer_clock_read(chan); - if ((int64_t) ctx->priv.tsc == -EIO) + ctx->priv.timestamp = config->cb.ring_buffer_clock_read(chan); + if ((int64_t) ctx->priv.timestamp == -EIO) return -EIO; - if (last_tsc_overflow(config, buf, ctx->priv.tsc)) - ctx->priv.rflags |= RING_BUFFER_RFLAG_FULL_TSC; + if (last_timestamp_overflow(config, buf, ctx->priv.timestamp)) + ctx->priv.rflags |= RING_BUFFER_RFLAG_FULL_TIMESTAMP; if (unlikely(subbuf_offset(offsets->begin, ctx->priv.chan) == 0)) { offsets->switch_new_start = 1; /* For offsets->begin */ @@ -2221,12 +2221,12 @@ int lib_ring_buffer_reserve_slow(struct lttng_kernel_ring_buffer_ctx *ctx, != offsets.old)); /* - * Atomically update last_tsc. This update races against concurrent - * atomic updates, but the race will always cause supplementary full TSC - * records, never the opposite (missing a full TSC record when it would - * be needed). + * Atomically update last_timestamp. This update races against concurrent + * atomic updates, but the race will always cause supplementary + * full timestamp records, never the opposite (missing a full + * timestamp record when it would be needed). */ - save_last_tsc(config, buf, ctx->priv.tsc); + save_last_timestamp(config, buf, ctx->priv.timestamp); /* * Push the reader if necessary diff --git a/src/lttng-ring-buffer-client.h b/src/lttng-ring-buffer-client.h index 0dc8a8d9..a1753e98 100644 --- a/src/lttng-ring-buffer-client.h +++ b/src/lttng-ring-buffer-client.h @@ -18,7 +18,7 @@ #include #define LTTNG_COMPACT_EVENT_BITS 5 -#define LTTNG_COMPACT_TSC_BITS 27 +#define LTTNG_COMPACT_TIMESTAMP_BITS 27 static struct lttng_transport lttng_relay_transport; @@ -149,7 +149,7 @@ size_t record_header_size(const struct lttng_kernel_ring_buffer_config *config, case 1: /* compact */ padding = lib_ring_buffer_align(offset, lttng_alignof(uint32_t)); offset += padding; - if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { offset += sizeof(uint32_t); /* id and timestamp */ } else { /* Minimum space taken by LTTNG_COMPACT_EVENT_BITS id */ @@ -165,7 +165,7 @@ size_t record_header_size(const struct lttng_kernel_ring_buffer_config *config, padding = lib_ring_buffer_align(offset, lttng_alignof(uint16_t)); offset += padding; offset += sizeof(uint16_t); - if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { offset += lib_ring_buffer_align(offset, lttng_alignof(uint32_t)); offset += sizeof(uint32_t); /* timestamp */ } else { @@ -223,14 +223,14 @@ void lttng_write_event_header(const struct lttng_kernel_ring_buffer_config *conf event_id); bt_bitfield_write(&id_time, uint32_t, LTTNG_COMPACT_EVENT_BITS, - LTTNG_COMPACT_TSC_BITS, - ctx->priv.tsc); + LTTNG_COMPACT_TIMESTAMP_BITS, + ctx->priv.timestamp); lib_ring_buffer_write(config, ctx, &id_time, sizeof(id_time)); break; } case 2: /* large */ { - uint32_t timestamp = (uint32_t) ctx->priv.tsc; + uint32_t timestamp = (uint32_t) ctx->priv.timestamp; uint16_t id = event_id; lib_ring_buffer_write(config, ctx, &id, sizeof(id)); @@ -260,7 +260,7 @@ void lttng_write_event_header_slow(const struct lttng_kernel_ring_buffer_config switch (lttng_chan->priv->header_type) { case 1: /* compact */ - if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { uint32_t id_time = 0; bt_bitfield_write(&id_time, uint32_t, @@ -269,11 +269,11 @@ void lttng_write_event_header_slow(const struct lttng_kernel_ring_buffer_config event_id); bt_bitfield_write(&id_time, uint32_t, LTTNG_COMPACT_EVENT_BITS, - LTTNG_COMPACT_TSC_BITS, ctx->priv.tsc); + LTTNG_COMPACT_TIMESTAMP_BITS, ctx->priv.timestamp); lib_ring_buffer_write(config, ctx, &id_time, sizeof(id_time)); } else { uint8_t id = 0; - uint64_t timestamp = ctx->priv.tsc; + uint64_t timestamp = ctx->priv.timestamp; bt_bitfield_write(&id, uint8_t, 0, @@ -289,8 +289,8 @@ void lttng_write_event_header_slow(const struct lttng_kernel_ring_buffer_config break; case 2: /* large */ { - if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { - uint32_t timestamp = (uint32_t) ctx->priv.tsc; + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { + uint32_t timestamp = (uint32_t) ctx->priv.timestamp; uint16_t id = event_id; lib_ring_buffer_write(config, ctx, &id, sizeof(id)); @@ -298,7 +298,7 @@ void lttng_write_event_header_slow(const struct lttng_kernel_ring_buffer_config lib_ring_buffer_write(config, ctx, ×tamp, sizeof(timestamp)); } else { uint16_t id = 65535; - uint64_t timestamp = ctx->priv.tsc; + uint64_t timestamp = ctx->priv.timestamp; lib_ring_buffer_write(config, ctx, &id, sizeof(id)); /* Align extended struct on largest member */ @@ -346,7 +346,7 @@ static size_t client_packet_header_size(void) return offsetof(struct packet_header, ctx.header_end); } -static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx) { struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; @@ -361,7 +361,7 @@ static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, memcpy(header->uuid, session->priv->uuid.b, sizeof(session->priv->uuid)); header->stream_id = lttng_chan->priv->id; header->stream_instance_id = buf->backend.cpu; - header->ctx.timestamp_begin = tsc; + header->ctx.timestamp_begin = timestamp; header->ctx.timestamp_end = 0; header->ctx.content_size = ~0ULL; /* for debugging */ header->ctx.packet_size = ~0ULL; @@ -376,7 +376,7 @@ static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, * offset is assumed to never be 0 here : never deliver a completely empty * subbuffer. data_size is between 1 and subbuf_size. */ -static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx, unsigned long data_size, const struct lttng_kernel_ring_buffer_ctx *ctx) { @@ -387,7 +387,7 @@ static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 tsc, subbuf_idx * chan->backend.subbuf_size); unsigned long records_lost = 0; - header->ctx.timestamp_end = tsc; + header->ctx.timestamp_end = timestamp; header->ctx.content_size = (uint64_t) data_size * CHAR_BIT; /* in bits */ header->ctx.packet_size = @@ -515,7 +515,7 @@ static const struct lttng_kernel_ring_buffer_config client_config = { .cb.buffer_create = client_buffer_create, .cb.buffer_finalize = client_buffer_finalize, - .tsc_bits = LTTNG_COMPACT_TSC_BITS, + .timestamp_bits = LTTNG_COMPACT_TIMESTAMP_BITS, .alloc = RING_BUFFER_ALLOC_PER_CPU, .sync = RING_BUFFER_SYNC_PER_CPU, .mode = RING_BUFFER_MODE_TEMPLATE, diff --git a/src/lttng-ring-buffer-event-notifier-client.h b/src/lttng-ring-buffer-event-notifier-client.h index 8526e05e..fa7bbf57 100644 --- a/src/lttng-ring-buffer-event-notifier-client.h +++ b/src/lttng-ring-buffer-event-notifier-client.h @@ -86,7 +86,7 @@ static size_t client_packet_header_size(void) return offsetof(struct event_notifier_packet_header, header_end); } -static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx) { } @@ -95,7 +95,7 @@ static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, * offset is assumed to never be 0 here : never deliver a completely empty * subbuffer. data_size is between 1 and subbuf_size. */ -static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx, unsigned long data_size, const struct lttng_kernel_ring_buffer_ctx *ctx) { @@ -200,7 +200,7 @@ static const struct lttng_kernel_ring_buffer_config client_config = { .cb.buffer_finalize = client_buffer_finalize, .cb.record_get = client_record_get, - .tsc_bits = 0, + .timestamp_bits = 0, .alloc = RING_BUFFER_ALLOC_GLOBAL, .sync = RING_BUFFER_SYNC_GLOBAL, .mode = RING_BUFFER_MODE_TEMPLATE, diff --git a/src/lttng-ring-buffer-metadata-client.h b/src/lttng-ring-buffer-metadata-client.h index 86ec78f1..d5e7c742 100644 --- a/src/lttng-ring-buffer-metadata-client.h +++ b/src/lttng-ring-buffer-metadata-client.h @@ -81,7 +81,7 @@ static size_t client_packet_header_size(void) return offsetof(struct metadata_packet_header, header_end); } -static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx) { struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; @@ -109,7 +109,7 @@ static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, * offset is assumed to never be 0 here : never deliver a completely empty * subbuffer. data_size is between 1 and subbuf_size. */ -static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx, unsigned long data_size, const struct lttng_kernel_ring_buffer_ctx *ctx) { @@ -214,7 +214,7 @@ static const struct lttng_kernel_ring_buffer_config client_config = { .cb.buffer_create = client_buffer_create, .cb.buffer_finalize = client_buffer_finalize, - .tsc_bits = 0, + .timestamp_bits = 0, .alloc = RING_BUFFER_ALLOC_GLOBAL, .sync = RING_BUFFER_SYNC_GLOBAL, .mode = RING_BUFFER_MODE_TEMPLATE, diff --git a/src/wrapper/trace-clock.c b/src/wrapper/trace-clock.c index 74995fef..7ef21cf6 100644 --- a/src/wrapper/trace-clock.c +++ b/src/wrapper/trace-clock.c @@ -11,8 +11,8 @@ #include #ifdef LTTNG_USE_NMI_SAFE_CLOCK -DEFINE_PER_CPU(u64, lttng_last_tsc); -EXPORT_PER_CPU_SYMBOL(lttng_last_tsc); +DEFINE_PER_CPU(u64, lttng_last_timestamp); +EXPORT_PER_CPU_SYMBOL(lttng_last_timestamp); #endif /* #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ #ifdef LTTNG_CLOCK_NMI_SAFE_BROKEN