ust-fd: Add close_range declaration

[lttng-ust.git] / src / common / ringbuffer / ring_buffer_frontend.c

diff --git a/src/common/ringbuffer/ring_buffer_frontend.c b/src/common/ringbuffer/ring_buffer_frontend.c
index f3f82e828d4ee598775e1b36ae7d4676224978bb..ab1fc0ff878b749779d9ce3e09d1d46ed70fc9ea 100644 (file)
--- a/src/common/ringbuffer/ring_buffer_frontend.c
+++ b/src/common/ringbuffer/ring_buffer_frontend.c
@@ -203,7 +203,7 @@ void lib_ring_buffer_reset(struct lttng_ust_ring_buffer *buf,
        }
        uatomic_set(&buf->consumed, 0);
        uatomic_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, handle);
        /* Don't reset number of active readers */
        v_set(config, &buf->records_lost_full, 0);
@@ -341,7 +341,7 @@ int lib_ring_buffer_create(struct lttng_ust_ring_buffer *buf,
        struct commit_counters_hot *cc_hot;
        void *priv = channel_get_private_config(chan);
        size_t subbuf_header_size;
-       uint64_t tsc;
+       uint64_t timestamp;
        int ret;
 
        /* Test for cpu hotplug */
@@ -398,8 +398,8 @@ int lib_ring_buffer_create(struct lttng_ust_ring_buffer *buf,
                ret = -EPERM;
                goto free_chanbuf;
        }
-       tsc = config->cb.ring_buffer_clock_read(shmp_chan);
-       config->cb.buffer_begin(buf, tsc, 0, handle);
+       timestamp = config->cb.ring_buffer_clock_read(shmp_chan);
+       config->cb.buffer_begin(buf, timestamp, 0, handle);
        cc_hot = shmp_index(handle, buf->commit_hot, 0);
        if (!cc_hot) {
                ret = -EPERM;
@@ -1774,7 +1774,7 @@ void lib_ring_buffer_switch_old_start(struct lttng_ust_ring_buffer *buf,
        unsigned long commit_count;
        struct commit_counters_hot *cc_hot;
 
-       config->cb.buffer_begin(buf, ctx->priv->tsc, oldidx, handle);
+       config->cb.buffer_begin(buf, ctx->priv->timestamp, oldidx, handle);
 
        /*
         * Order all writes to buffer before the commit count update that will
@@ -1832,7 +1832,7 @@ void lib_ring_buffer_switch_old_end(struct lttng_ust_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
@@ -1870,7 +1870,7 @@ void lib_ring_buffer_switch_new_start(struct lttng_ust_ring_buffer *buf,
        unsigned long commit_count;
        struct commit_counters_hot *cc_hot;
 
-       config->cb.buffer_begin(buf, ctx->priv->tsc, beginidx, handle);
+       config->cb.buffer_begin(buf, ctx->priv->timestamp, beginidx, handle);
 
        /*
         * Order all writes to buffer before the commit count update that will
@@ -1924,7 +1924,7 @@ void lib_ring_buffer_switch_new_end(struct lttng_ust_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;
 }
 
 /*
@@ -1948,7 +1948,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
@@ -2084,12 +2084,12 @@ void lib_ring_buffer_switch_slow(struct lttng_ust_ring_buffer *buf, enum switch_
                 != 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
@@ -2158,12 +2158,12 @@ retry:
        offsets->switch_old_end = 0;
        offsets->pre_header_padding = 0;
 
-       ctx_private->tsc = config->cb.ring_buffer_clock_read(chan);
-       if ((int64_t) ctx_private->tsc == -EIO)
+       ctx_private->timestamp = config->cb.ring_buffer_clock_read(chan);
+       if ((int64_t) ctx_private->timestamp == -EIO)
                return -EIO;
 
-       if (last_tsc_overflow(config, buf, ctx_private->tsc))
-               ctx_private->rflags |= RING_BUFFER_RFLAG_FULL_TSC;
+       if (last_timestamp_overflow(config, buf, ctx_private->timestamp))
+               ctx_private->rflags |= RING_BUFFER_RFLAG_FULL_TIMESTAMP;
 
        if (caa_unlikely(subbuf_offset(offsets->begin, chan) == 0)) {
                offsets->switch_new_start = 1;          /* For offsets->begin */
@@ -2371,12 +2371,12 @@ int lib_ring_buffer_reserve_slow(struct lttng_ust_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_private->tsc);
+       save_last_timestamp(config, buf, ctx_private->timestamp);
 
        /*
         * Push the reader if necessary