Prevent allocation of buffers if exceeding available memory

[lttng-modules.git] / lib / ringbuffer / ring_buffer_backend.c

diff --git a/lib/ringbuffer/ring_buffer_backend.c b/lib/ringbuffer/ring_buffer_backend.c
index f760836cfe50032e18c9d3774a0e1cd7c6338ed5..d300980dd7fec1204ce8732d0fd0404bdba88c70 100644 (file)
--- a/lib/ringbuffer/ring_buffer_backend.c
+++ b/lib/ringbuffer/ring_buffer_backend.c
@@ -25,6 +25,7 @@
 #include <linux/delay.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
+#include <linux/oom.h>
 #include <linux/cpu.h>
 #include <linux/mm.h>
 #include <linux/vmalloc.h>
@@ -56,6 +57,23 @@ int lib_ring_buffer_backend_allocate(const struct lib_ring_buffer_config *config
        unsigned long i;
 
        num_pages = size >> PAGE_SHIFT;
+
+       /*
+        * Verify that the number of pages requested for that buffer is smaller
+        * than the number of available pages on the system. si_mem_available()
+        * returns an _estimate_ of the number of available pages.
+        */
+       if (num_pages > si_mem_available())
+               goto not_enough_pages;
+
+       /*
+        * Set the current user thread as the first target of the OOM killer.
+        * If the estimate received by si_mem_available() was off, and we do
+        * end up running out of memory because of this buffer allocation, we
+        * want to kill the offending app first.
+        */
+       set_current_oom_origin();
+
        num_pages_per_subbuf = num_pages >> get_count_order(num_subbuf);
        subbuf_size = chanb->subbuf_size;
        num_subbuf_alloc = num_subbuf;
@@ -71,7 +89,7 @@ int lib_ring_buffer_backend_allocate(const struct lib_ring_buffer_config *config
        if (unlikely(!pages))
                goto pages_error;
 
-       bufb->array = kmalloc_node(ALIGN(sizeof(*bufb->array)
+       bufb->array = lttng_kvmalloc_node(ALIGN(sizeof(*bufb->array)
                                         * num_subbuf_alloc,
                                  1 << INTERNODE_CACHE_SHIFT),
                        GFP_KERNEL | __GFP_NOWARN,
@@ -90,7 +108,7 @@ int lib_ring_buffer_backend_allocate(const struct lib_ring_buffer_config *config
        /* Allocate backend pages array elements */
        for (i = 0; i < num_subbuf_alloc; i++) {
                bufb->array[i] =
-                       kzalloc_node(ALIGN(
+                       lttng_kvzalloc_node(ALIGN(
                                sizeof(struct lib_ring_buffer_backend_pages) +
                                sizeof(struct lib_ring_buffer_backend_page)
                                * num_pages_per_subbuf,
@@ -102,7 +120,7 @@ int lib_ring_buffer_backend_allocate(const struct lib_ring_buffer_config *config
        }
 
        /* Allocate write-side subbuffer table */
-       bufb->buf_wsb = kzalloc_node(ALIGN(
+       bufb->buf_wsb = lttng_kvzalloc_node(ALIGN(
                                sizeof(struct lib_ring_buffer_backend_subbuffer)
                                * num_subbuf,
                                1 << INTERNODE_CACHE_SHIFT),
@@ -122,7 +140,7 @@ int lib_ring_buffer_backend_allocate(const struct lib_ring_buffer_config *config
                bufb->buf_rsb.id = subbuffer_id(config, 0, 1, 0);
 
        /* Allocate subbuffer packet counter table */
-       bufb->buf_cnt = kzalloc_node(ALIGN(
+       bufb->buf_cnt = lttng_kvzalloc_node(ALIGN(
                                sizeof(struct lib_ring_buffer_backend_counts)
                                * num_subbuf,
                                1 << INTERNODE_CACHE_SHIFT),
@@ -150,22 +168,25 @@ int lib_ring_buffer_backend_allocate(const struct lib_ring_buffer_config *config
         * will not fault.
         */
        wrapper_vmalloc_sync_all();
+       clear_current_oom_origin();
        vfree(pages);
        return 0;
 
 free_wsb:
-       kfree(bufb->buf_wsb);
+       lttng_kvfree(bufb->buf_wsb);
 free_array:
        for (i = 0; (i < num_subbuf_alloc && bufb->array[i]); i++)
-               kfree(bufb->array[i]);
+               lttng_kvfree(bufb->array[i]);
 depopulate:
        /* Free all allocated pages */
        for (i = 0; (i < num_pages && pages[i]); i++)
                __free_page(pages[i]);
-       kfree(bufb->array);
+       lttng_kvfree(bufb->array);
 array_error:
        vfree(pages);
 pages_error:
+       clear_current_oom_origin();
+not_enough_pages:
        return -ENOMEM;
 }
 
@@ -191,14 +212,14 @@ void lib_ring_buffer_backend_free(struct lib_ring_buffer_backend *bufb)
        if (chanb->extra_reader_sb)
                num_subbuf_alloc++;
 
-       kfree(bufb->buf_wsb);
-       kfree(bufb->buf_cnt);
+       lttng_kvfree(bufb->buf_wsb);
+       lttng_kvfree(bufb->buf_cnt);
        for (i = 0; i < num_subbuf_alloc; i++) {
                for (j = 0; j < bufb->num_pages_per_subbuf; j++)
                        __free_page(pfn_to_page(bufb->array[i]->p[j].pfn));
-               kfree(bufb->array[i]);
+               lttng_kvfree(bufb->array[i]);
        }
-       kfree(bufb->array);
+       lttng_kvfree(bufb->array);
        bufb->allocated = 0;
 }
 
@@ -468,9 +489,11 @@ int channel_backend_init(struct channel_backend *chanb,
 free_bufs:
        if (config->alloc == RING_BUFFER_ALLOC_PER_CPU) {
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
-               ret = cpuhp_state_remove_instance(lttng_rb_hp_prepare,
-                               &chanb->cpuhp_prepare.node);
-               WARN_ON(ret);
+               /*
+                * Teardown of lttng_rb_hp_prepare instance
+                * on "add" error is handled within cpu hotplug,
+                * no teardown to do from the caller.
+                */
 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
 #ifdef CONFIG_HOTPLUG_CPU
                put_online_cpus();