Cleanup: clarify strcpy/strcpy_from_user local variables

The variable name "bytes_left_in_page" is clearer than "pagecpy". Also
the only caller of slow paths always has a 0 pagecpy parameter, so
remove that parameter. Also use a "bool" for src_terminated (no
functional change).

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Change-Id: I38520b8cab54c31dbbb7b9296200b432afb3cee9

diff --git a/include/ringbuffer/backend.h b/include/ringbuffer/backend.h
index b95a0d38b9954a81642a798c40df8dd230d19579..13f67a4ea8c51e48f8832ff1813931a772997442 100644 (file)
--- a/include/ringbuffer/backend.h
+++ b/include/ringbuffer/backend.h
@@ -215,7 +215,7 @@ void lib_ring_buffer_strcpy(const struct lttng_kernel_ring_buffer_config *config
 {
        struct lttng_kernel_ring_buffer_backend *bufb = &ctx->priv.buf->backend;
        struct channel_backend *chanb = &ctx->priv.chan->backend;
-       size_t index, pagecpy;
+       size_t index, bytes_left_in_page;
        size_t offset = ctx->priv.buf_offset;
        struct lttng_kernel_ring_buffer_backend_pages *backend_pages;
 
@@ -225,8 +225,8 @@ void lib_ring_buffer_strcpy(const struct lttng_kernel_ring_buffer_config *config
                lib_ring_buffer_get_backend_pages_from_ctx(config, ctx);
        offset &= chanb->buf_size - 1;
        index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT;
-       pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK);
-       if (likely(pagecpy == len)) {
+       bytes_left_in_page = min_t(size_t, len, (-offset) & ~PAGE_MASK);
+       if (likely(bytes_left_in_page == len)) {
                size_t count;
 
                count = lib_ring_buffer_do_strcpy(config,
@@ -248,7 +248,7 @@ void lib_ring_buffer_strcpy(const struct lttng_kernel_ring_buffer_config *config
                                        + (offset & ~PAGE_MASK),
                                '\0', 1);
        } else {
-               _lib_ring_buffer_strcpy(bufb, offset, src, len, 0, pad);
+               _lib_ring_buffer_strcpy(bufb, offset, src, len, pad);
        }
        ctx->priv.buf_offset += len;
 }
@@ -404,7 +404,7 @@ void lib_ring_buffer_strcpy_from_user_inatomic(const struct lttng_kernel_ring_bu
 {
        struct lttng_kernel_ring_buffer_backend *bufb = &ctx->priv.buf->backend;
        struct channel_backend *chanb = &ctx->priv.chan->backend;
-       size_t index, pagecpy;
+       size_t index, bytes_left_in_page;
        size_t offset = ctx->priv.buf_offset;
        struct lttng_kernel_ring_buffer_backend_pages *backend_pages;
 
@@ -414,13 +414,13 @@ void lib_ring_buffer_strcpy_from_user_inatomic(const struct lttng_kernel_ring_bu
                lib_ring_buffer_get_backend_pages_from_ctx(config, ctx);
        offset &= chanb->buf_size - 1;
        index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT;
-       pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK);
+       bytes_left_in_page = min_t(size_t, len, (-offset) & ~PAGE_MASK);
 
        if (unlikely(!lttng_access_ok(VERIFY_READ, src, len)))
                goto fill_buffer;
 
        pagefault_disable();
-       if (likely(pagecpy == len)) {
+       if (likely(bytes_left_in_page == len)) {
                size_t count;
 
                count = lib_ring_buffer_do_strcpy_from_user_inatomic(config,
@@ -443,7 +443,7 @@ void lib_ring_buffer_strcpy_from_user_inatomic(const struct lttng_kernel_ring_bu
                                '\0', 1);
        } else {
                _lib_ring_buffer_strcpy_from_user_inatomic(bufb, offset, src,
-                                       len, 0, pad);
+                                       len, pad);
        }
        pagefault_enable();
        ctx->priv.buf_offset += len;

diff --git a/include/ringbuffer/backend_internal.h b/include/ringbuffer/backend_internal.h
index 20ca39a5b8fe6a4056d7764248c39bfb811cce8c..fb60f2abc3e9050d27371e3b730efb36011b644c 100644 (file)
--- a/include/ringbuffer/backend_internal.h
+++ b/include/ringbuffer/backend_internal.h
@@ -46,16 +46,14 @@ extern void _lib_ring_buffer_memset(struct lttng_kernel_ring_buffer_backend *buf
                                    size_t offset, int c, size_t len,
                                    size_t pagecpy);
 extern void _lib_ring_buffer_strcpy(struct lttng_kernel_ring_buffer_backend *bufb,
-                                  size_t offset, const char *src, size_t len,
-                                  size_t pagecpy, int pad);
+                                  size_t offset, const char *src, size_t len, int pad);
 extern void _lib_ring_buffer_pstrcpy(struct lttng_kernel_ring_buffer_backend *bufb,
                                   size_t offset, const char *src, size_t len, int pad);
 extern void _lib_ring_buffer_copy_from_user_inatomic(struct lttng_kernel_ring_buffer_backend *bufb,
                                            size_t offset, const void *src,
                                            size_t len, size_t pagecpy);
 extern void _lib_ring_buffer_strcpy_from_user_inatomic(struct lttng_kernel_ring_buffer_backend *bufb,
-               size_t offset, const char __user *src, size_t len,
-               size_t pagecpy, int pad);
+               size_t offset, const char __user *src, size_t len, int pad);
 extern void _lib_ring_buffer_pstrcpy_from_user_inatomic(struct lttng_kernel_ring_buffer_backend *bufb,
                                   size_t offset, const char __user *src, size_t len, int pad);
 

diff --git a/src/lib/ringbuffer/ring_buffer_backend.c b/src/lib/ringbuffer/ring_buffer_backend.c
index 76f9b4252a3a6bd58d88ee09d42b442627e4f69e..cbc931df04b2682a29b02f3afa8e5cd60318474b 100644 (file)
--- a/src/lib/ringbuffer/ring_buffer_backend.c
+++ b/src/lib/ringbuffer/ring_buffer_backend.c
@@ -653,26 +653,20 @@ EXPORT_SYMBOL_GPL(_lib_ring_buffer_memset);
  * @offset : offset within the buffer
  * @src : source address
  * @len : length to write
- * @pagecpy : page size copied so far
  * @pad : character to use for padding
  */
 void _lib_ring_buffer_strcpy(struct lttng_kernel_ring_buffer_backend *bufb,
-                       size_t offset, const char *src, size_t len,
-                       size_t pagecpy, int pad)
+                       size_t offset, const char *src, size_t len, int pad)
 {
        struct channel_backend *chanb = &bufb->chan->backend;
        const struct lttng_kernel_ring_buffer_config *config = &chanb->config;
-       size_t sbidx, index;
+       size_t sbidx, index, bytes_left_in_page;
        struct lttng_kernel_ring_buffer_backend_pages *rpages;
        unsigned long sb_bindex, id;
-       int src_terminated = 0;
+       bool src_terminated = false;
 
        CHAN_WARN_ON(chanb, !len);
-       offset += pagecpy;
        do {
-               len -= pagecpy;
-               if (!src_terminated)
-                       src += pagecpy;
                sbidx = offset >> chanb->subbuf_size_order;
                index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT;
 
@@ -682,7 +676,7 @@ void _lib_ring_buffer_strcpy(struct lttng_kernel_ring_buffer_backend *bufb,
                 */
                CHAN_WARN_ON(chanb, offset >= chanb->buf_size);
 
-               pagecpy = min_t(size_t, len, PAGE_SIZE - (offset & ~PAGE_MASK));
+               bytes_left_in_page = min_t(size_t, len, PAGE_SIZE - (offset & ~PAGE_MASK));
                id = bufb->buf_wsb[sbidx].id;
                sb_bindex = subbuffer_id_get_index(config, id);
                rpages = bufb->array[sb_bindex];
@@ -692,8 +686,8 @@ void _lib_ring_buffer_strcpy(struct lttng_kernel_ring_buffer_backend *bufb,
                if (likely(!src_terminated)) {
                        size_t count, to_copy;
 
-                       to_copy = pagecpy;
-                       if (pagecpy == len)
+                       to_copy = bytes_left_in_page;
+                       if (bytes_left_in_page == len)
                                to_copy--;      /* Final '\0' */
                        count = lib_ring_buffer_do_strcpy(config,
                                        rpages->p[index].virt
@@ -705,7 +699,7 @@ void _lib_ring_buffer_strcpy(struct lttng_kernel_ring_buffer_backend *bufb,
                                size_t pad_len = to_copy - count;
 
                                /* Next pages will have padding */
-                               src_terminated = 1;
+                               src_terminated = true;
                                lib_ring_buffer_do_memset(rpages->p[index].virt
                                                + (offset & ~PAGE_MASK),
                                        pad, pad_len);
@@ -714,15 +708,19 @@ void _lib_ring_buffer_strcpy(struct lttng_kernel_ring_buffer_backend *bufb,
                } else {
                        size_t pad_len;
 
-                       pad_len = pagecpy;
-                       if (pagecpy == len)
+                       pad_len = bytes_left_in_page;
+                       if (bytes_left_in_page == len)
                                pad_len--;      /* Final '\0' */
                        lib_ring_buffer_do_memset(rpages->p[index].virt
                                        + (offset & ~PAGE_MASK),
                                pad, pad_len);
                        offset += pad_len;
                }
-       } while (unlikely(len != pagecpy));
+               len -= bytes_left_in_page;
+               if (!src_terminated)
+                       src += bytes_left_in_page;
+       } while (unlikely(len));
+
        /* Ending '\0' */
        lib_ring_buffer_do_memset(rpages->p[index].virt + (offset & ~PAGE_MASK),
                        '\0', 1);
@@ -869,7 +867,6 @@ EXPORT_SYMBOL_GPL(_lib_ring_buffer_copy_from_user_inatomic);
  * @offset : offset within the buffer
  * @src : source address
  * @len : length to write
- * @pagecpy : page size copied so far
  * @pad : character to use for padding
  *
  * This function deals with userspace pointers, it should never be called
@@ -877,21 +874,16 @@ EXPORT_SYMBOL_GPL(_lib_ring_buffer_copy_from_user_inatomic);
  * previously.
  */
 void _lib_ring_buffer_strcpy_from_user_inatomic(struct lttng_kernel_ring_buffer_backend *bufb,
-               size_t offset, const char __user *src, size_t len,
-               size_t pagecpy, int pad)
+               size_t offset, const char __user *src, size_t len, int pad)
 {
        struct channel_backend *chanb = &bufb->chan->backend;
        const struct lttng_kernel_ring_buffer_config *config = &chanb->config;
-       size_t sbidx, index;
+       size_t sbidx, index, bytes_left_in_page;
        struct lttng_kernel_ring_buffer_backend_pages *rpages;
        unsigned long sb_bindex, id;
-       int src_terminated = 0;
+       bool src_terminated = false;
 
-       offset += pagecpy;
        do {
-               len -= pagecpy;
-               if (!src_terminated)
-                       src += pagecpy;
                sbidx = offset >> chanb->subbuf_size_order;
                index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT;
 
@@ -901,7 +893,7 @@ void _lib_ring_buffer_strcpy_from_user_inatomic(struct lttng_kernel_ring_buffer_
                 */
                CHAN_WARN_ON(chanb, offset >= chanb->buf_size);
 
-               pagecpy = min_t(size_t, len, PAGE_SIZE - (offset & ~PAGE_MASK));
+               bytes_left_in_page = min_t(size_t, len, PAGE_SIZE - (offset & ~PAGE_MASK));
                id = bufb->buf_wsb[sbidx].id;
                sb_bindex = subbuffer_id_get_index(config, id);
                rpages = bufb->array[sb_bindex];
@@ -911,8 +903,8 @@ void _lib_ring_buffer_strcpy_from_user_inatomic(struct lttng_kernel_ring_buffer_
                if (likely(!src_terminated)) {
                        size_t count, to_copy;
 
-                       to_copy = pagecpy;
-                       if (pagecpy == len)
+                       to_copy = bytes_left_in_page;
+                       if (bytes_left_in_page == len)
                                to_copy--;      /* Final '\0' */
                        count = lib_ring_buffer_do_strcpy_from_user_inatomic(config,
                                        rpages->p[index].virt
@@ -924,7 +916,7 @@ void _lib_ring_buffer_strcpy_from_user_inatomic(struct lttng_kernel_ring_buffer_
                                size_t pad_len = to_copy - count;
 
                                /* Next pages will have padding */
-                               src_terminated = 1;
+                               src_terminated = true;
                                lib_ring_buffer_do_memset(rpages->p[index].virt
                                                + (offset & ~PAGE_MASK),
                                        pad, pad_len);
@@ -933,15 +925,19 @@ void _lib_ring_buffer_strcpy_from_user_inatomic(struct lttng_kernel_ring_buffer_
                } else {
                        size_t pad_len;
 
-                       pad_len = pagecpy;
-                       if (pagecpy == len)
+                       pad_len = bytes_left_in_page;
+                       if (bytes_left_in_page == len)
                                pad_len--;      /* Final '\0' */
                        lib_ring_buffer_do_memset(rpages->p[index].virt
                                        + (offset & ~PAGE_MASK),
                                pad, pad_len);
                        offset += pad_len;
                }
-       } while (unlikely(len != pagecpy));
+               len -= bytes_left_in_page;
+               if (!src_terminated)
+                       src += bytes_left_in_page;
+       } while (unlikely(len));
+
        /* Ending '\0' */
        lib_ring_buffer_do_memset(rpages->p[index].virt + (offset & ~PAGE_MASK),
                        '\0', 1);