Remove handle field from ring buffer context

[lttng-ust.git] / libringbuffer / backend.h

diff --git a/libringbuffer/backend.h b/libringbuffer/backend.h
index dbb5d7353c878f670369f236f791971f664d691e..2fe06cefd56f2c146b128762f9268c85101c5946 100644 (file)
--- a/libringbuffer/backend.h
+++ b/libringbuffer/backend.h
@@ -15,8 +15,6 @@
 #include <stddef.h>
 #include <unistd.h>
 
-#include "ust-helper.h"
-
 /* Internal helpers */
 #include "backend_internal.h"
 #include "frontend_internal.h"
@@ -25,12 +23,12 @@
 
 /* Ring buffer backend access (read/write) */
 
-LTTNG_HIDDEN
+__attribute__((visibility("hidden")))
 extern size_t lib_ring_buffer_read(struct lttng_ust_lib_ring_buffer_backend *bufb,
                                   size_t offset, void *dest, size_t len,
                                   struct lttng_ust_shm_handle *handle);
 
-LTTNG_HIDDEN
+__attribute__((visibility("hidden")))
 extern int lib_ring_buffer_read_cstr(struct lttng_ust_lib_ring_buffer_backend *bufb,
                                     size_t offset, void *dest, size_t len,
                                     struct lttng_ust_shm_handle *handle);
@@ -41,12 +39,13 @@ extern int lib_ring_buffer_read_cstr(struct lttng_ust_lib_ring_buffer_backend *b
  * it's never on a page boundary, it's safe to write directly to this address,
  * as long as the write is never bigger than a page size.
  */
-LTTNG_HIDDEN
+__attribute__((visibility("hidden")))
 extern void *
 lib_ring_buffer_offset_address(struct lttng_ust_lib_ring_buffer_backend *bufb,
                               size_t offset,
                               struct lttng_ust_shm_handle *handle);
-LTTNG_HIDDEN
+
+__attribute__((visibility("hidden")))
 extern void *
 lib_ring_buffer_read_offset_address(struct lttng_ust_lib_ring_buffer_backend *bufb,
                                    size_t offset,
@@ -70,7 +69,7 @@ void lib_ring_buffer_write(const struct lttng_ust_lib_ring_buffer_config *config
                           const void *src, size_t len)
 {
        struct channel_backend *chanb = &ctx->chan->backend;
-       struct lttng_ust_shm_handle *handle = ctx->handle;
+       struct lttng_ust_shm_handle *handle = ctx->chan->handle;
        size_t offset = ctx->buf_offset;
        struct lttng_ust_lib_ring_buffer_backend_pages *backend_pages;
        void *p;
@@ -138,10 +137,10 @@ size_t lib_ring_buffer_do_strcpy(const struct lttng_ust_lib_ring_buffer_config *
 static inline __attribute__((always_inline))
 void lib_ring_buffer_strcpy(const struct lttng_ust_lib_ring_buffer_config *config,
                           struct lttng_ust_lib_ring_buffer_ctx *ctx,
-                          const char *src, size_t len, int pad)
+                          const char *src, size_t len, char pad)
 {
        struct channel_backend *chanb = &ctx->chan->backend;
-       struct lttng_ust_shm_handle *handle = ctx->handle;
+       struct lttng_ust_shm_handle *handle = ctx->chan->handle;
        size_t count;
        size_t offset = ctx->buf_offset;
        struct lttng_ust_lib_ring_buffer_backend_pages *backend_pages;
@@ -183,6 +182,64 @@ void lib_ring_buffer_strcpy(const struct lttng_ust_lib_ring_buffer_config *confi
        ctx->buf_offset += len;
 }
 
+/**
+ * lib_ring_buffer_pstrcpy - write to a buffer backend P-string
+ * @config : ring buffer instance configuration
+ * @ctx: ring buffer context. (input arguments only)
+ * @src : source pointer to copy from
+ * @len : length of data to copy
+ * @pad : character to use for padding
+ *
+ * This function copies up to @len bytes of data from a source pointer
+ * to a Pascal String into the buffer backend. If a terminating '\0'
+ * character is found in @src before @len characters are copied, pad the
+ * buffer with @pad characters (e.g.  '\0').
+ *
+ * The length of the pascal strings in the ring buffer is explicit: it
+ * is either the array or sequence length.
+ */
+static inline __attribute__((always_inline))
+void lib_ring_buffer_pstrcpy(const struct lttng_ust_lib_ring_buffer_config *config,
+                          struct lttng_ust_lib_ring_buffer_ctx *ctx,
+                          const char *src, size_t len, char pad)
+{
+       struct channel_backend *chanb = &ctx->chan->backend;
+       struct lttng_ust_shm_handle *handle = ctx->chan->handle;
+       size_t count;
+       size_t offset = ctx->buf_offset;
+       struct lttng_ust_lib_ring_buffer_backend_pages *backend_pages;
+       void *p;
+
+       if (caa_unlikely(!len))
+               return;
+       /*
+        * Underlying layer should never ask for writes across
+        * subbuffers.
+        */
+       CHAN_WARN_ON(chanb, (offset & (chanb->buf_size - 1)) + len > chanb->buf_size);
+       backend_pages = lib_ring_buffer_get_backend_pages_from_ctx(config, ctx);
+       if (caa_unlikely(!backend_pages)) {
+               if (lib_ring_buffer_backend_get_pages(config, ctx, &backend_pages))
+                       return;
+       }
+       p = shmp_index(handle, backend_pages->p, offset & (chanb->subbuf_size - 1));
+       if (caa_unlikely(!p))
+               return;
+
+       count = lib_ring_buffer_do_strcpy(config, p, src, len);
+       offset += count;
+       /* Padding */
+       if (caa_unlikely(count < len)) {
+               size_t pad_len = len - count;
+
+               p = shmp_index(handle, backend_pages->p, offset & (chanb->subbuf_size - 1));
+               if (caa_unlikely(!p))
+                       return;
+               lib_ring_buffer_do_memset(p, pad, pad_len);
+       }
+       ctx->buf_offset += len;
+}
+
 /*
  * This accessor counts the number of unread records in a buffer.
  * It only provides a consistent value if no reads not writes are performed
@@ -197,7 +254,7 @@ unsigned long lib_ring_buffer_get_records_unread(
        struct lttng_ust_lib_ring_buffer_backend *bufb = &buf->backend;
        unsigned long records_unread = 0, sb_bindex;
        unsigned int i;
-       struct channel *chan;
+       struct lttng_ust_lib_ring_buffer_channel *chan;
 
        chan = shmp(handle, bufb->chan);
        if (!chan)