src/common/defaults.c

   1 /*
   2  * Copyright (C) 2012 Simon Marchi <simon.marchi@polymtl.ca>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #define _LGPL_SOURCE
   9 #include <stddef.h>
  10 #include <unistd.h>
  11 #include <stdbool.h>
  12 #include <sys/resource.h>
  13 #include <pthread.h>
  14
  15 #include "defaults.h"
  16 #include "macros.h"
  17 #include "align.h"
  18 #include "error.h"
  19
  20 static int pthread_attr_init_done;
  21 static pthread_attr_t tattr;
  22
  23 size_t default_get_channel_subbuf_size(void)
  24 {
  25         return max(_DEFAULT_CHANNEL_SUBBUF_SIZE, PAGE_SIZE);
  26 }
  27
  28 size_t default_get_metadata_subbuf_size(void)
  29 {
  30         return max(DEFAULT_METADATA_SUBBUF_SIZE, PAGE_SIZE);
  31 }
  32
  33 size_t default_get_kernel_channel_subbuf_size(void)
  34 {
  35         return max(DEFAULT_KERNEL_CHANNEL_SUBBUF_SIZE, PAGE_SIZE);
  36 }
  37
  38 size_t default_get_ust_pid_channel_subbuf_size(void)
  39 {
  40         return max(DEFAULT_UST_PID_CHANNEL_SUBBUF_SIZE, PAGE_SIZE);
  41 }
  42
  43 size_t default_get_ust_uid_channel_subbuf_size(void)
  44 {
  45         return max(DEFAULT_UST_UID_CHANNEL_SUBBUF_SIZE, PAGE_SIZE);
  46 }
  47
  48 pthread_attr_t *default_pthread_attr(void)
  49 {
  50         if (pthread_attr_init_done) {
  51                 return &tattr;
  52         }
  53
  54         WARN("Uninitialized pthread attributes, using libc defaults.");
  55         return NULL;
  56 }
  57
  58 static void __attribute__((constructor)) init_default_pthread_attr(void)
  59 {
  60         int ret;
  61         struct rlimit rlim;
  62         size_t pthread_ss, system_ss, selected_ss;
  63
  64         ret = pthread_attr_init(&tattr);
  65         if (ret) {
  66                 errno = ret;
  67                 PERROR("pthread_attr_init");
  68                 goto error;
  69         }
  70
  71         /* Get system stack size limits. */
  72         ret = getrlimit(RLIMIT_STACK, &rlim);
  73         if (ret < 0) {
  74                 PERROR("getrlimit");
  75                 goto error_destroy;
  76         }
  77         DBG("Stack size limits: soft %lld, hard %lld bytes",
  78                         (long long) rlim.rlim_cur,
  79                         (long long) rlim.rlim_max);
  80
  81         /*
  82          * getrlimit() may return a stack size of "-1", meaning "unlimited".
  83          * In this case, we impose a known-good default minimum value which will
  84          * override the libc's default stack size if it is smaller.
  85          */
  86         system_ss = rlim.rlim_cur != -1 ? rlim.rlim_cur :
  87                         DEFAULT_LTTNG_THREAD_STACK_SIZE;
  88
  89         /* Get pthread default thread stack size. */
  90         ret = pthread_attr_getstacksize(&tattr, &pthread_ss);
  91         if (ret < 0) {
  92                 PERROR("pthread_attr_getstacksize");
  93                 goto error_destroy;
  94         }
  95         DBG("Default pthread stack size is %zu bytes", pthread_ss);
  96
  97         selected_ss = max_t(size_t, pthread_ss, system_ss);
  98         if (selected_ss < DEFAULT_LTTNG_THREAD_STACK_SIZE) {
  99                 DBG("Default stack size is too small, setting it to %zu bytes",
 100                         (size_t) DEFAULT_LTTNG_THREAD_STACK_SIZE);
 101                 selected_ss = DEFAULT_LTTNG_THREAD_STACK_SIZE;
 102         }
 103
 104         if (rlim.rlim_max > 0 && selected_ss > rlim.rlim_max) {
 105                 WARN("Your system's stack size restrictions (%zu bytes) may be too low for the LTTng daemons to function properly, please set the stack size limit to at least %zu bytes to ensure reliable operation",
 106                         (size_t) rlim.rlim_max, (size_t) DEFAULT_LTTNG_THREAD_STACK_SIZE);
 107                 selected_ss = (size_t) rlim.rlim_max;
 108         }
 109
 110         ret = pthread_attr_setstacksize(&tattr, selected_ss);
 111         if (ret < 0) {
 112                 PERROR("pthread_attr_setstacksize");
 113                 goto error_destroy;
 114         }
 115         pthread_attr_init_done = 1;
 116 error:
 117         return;
 118 error_destroy:
 119         ret = pthread_attr_destroy(&tattr);
 120         if (ret) {
 121                 errno = ret;
 122                 PERROR("pthread_attr_destroy");
 123         }
 124 }
 125
 126 static void __attribute__((destructor)) fini_default_pthread_attr(void)
 127 {
 128         int ret;
 129
 130         if (!pthread_attr_init_done) {
 131                 return;
 132         }
 133
 134         ret = pthread_attr_destroy(&tattr);
 135         if (ret) {
 136                 errno = ret;
 137                 PERROR("pthread_attr_destroy");
 138         }
 139 }