liblttng-ust/lttng-context-ipc-ns.c

   1 /*
   2  * lttng-context-ipc-ns.c
   3  *
   4  * LTTng UST ipc namespace context.
   5  *
   6  * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *               2019 Michael Jeanson <mjeanson@efficios.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; only
  12  * version 2.1 of the License.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #define _LGPL_SOURCE
  25 #include <stddef.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29 #include <lttng/ust-events.h>
  30 #include <lttng/ust-tracer.h>
  31 #include <lttng/ringbuffer-config.h>
  32 #include <lttng/ust-tid.h>
  33 #include <urcu/tls-compat.h>
  34 #include "lttng-tracer-core.h"
  35 #include "ns.h"
  36
  37 /*
  38  * We cache the result to ensure we don't stat(2) the proc filesystem on
  39  * each event.
  40  */
  41 #ifdef CONFIG_RCU_TLS
  42 static DEFINE_URCU_TLS(ino_t, cached_ipc_ns) = NS_INO_UNINITIALIZED;
  43 #else
  44 static DEFINE_URCU_TLS_INIT(ino_t, cached_ipc_ns, NS_INO_UNINITIALIZED);
  45 #endif
  46
  47 static
  48 ino_t get_ipc_ns(void)
  49 {
  50         struct stat sb;
  51         ino_t ipc_ns;
  52
  53         ipc_ns = CMM_LOAD_SHARED(URCU_TLS(cached_ipc_ns));
  54
  55         /*
  56          * If the cache is populated, do nothing and return the
  57          * cached inode number.
  58          */
  59         if (caa_likely(ipc_ns != NS_INO_UNINITIALIZED))
  60                 return ipc_ns;
  61
  62         /*
  63          * At this point we have to populate the cache, set the initial
  64          * value to NS_INO_UNAVAILABLE (0), if we fail to get the inode
  65          * number from the proc filesystem, this is the value we will
  66          * cache.
  67          */
  68         ipc_ns = NS_INO_UNAVAILABLE;
  69
  70         /*
  71          * /proc/thread-self was introduced in kernel v3.17
  72          */
  73         if (stat("/proc/thread-self/ns/ipc", &sb) == 0) {
  74                 ipc_ns = sb.st_ino;
  75         } else {
  76                 char proc_ns_path[LTTNG_PROC_NS_PATH_MAX];
  77
  78                 if (snprintf(proc_ns_path, LTTNG_PROC_NS_PATH_MAX,
  79                                 "/proc/self/task/%d/ns/ipc",
  80                                 lttng_gettid()) >= 0) {
  81
  82                         if (stat(proc_ns_path, &sb) == 0) {
  83                                 ipc_ns = sb.st_ino;
  84                         }
  85                 }
  86         }
  87
  88         /*
  89          * And finally, store the inode number in the cache.
  90          */
  91         CMM_STORE_SHARED(URCU_TLS(cached_ipc_ns), ipc_ns);
  92
  93         return ipc_ns;
  94 }
  95
  96 /*
  97  * The ipc namespace can change for 3 reasons
  98  *  * clone(2) called with CLONE_NEWIPC
  99  *  * setns(2) called with the fd of a different ipc ns
 100  *  * unshare(2) called with CLONE_NEWIPC
 101  */
 102 void lttng_context_ipc_ns_reset(void)
 103 {
 104         CMM_STORE_SHARED(URCU_TLS(cached_ipc_ns), NS_INO_UNINITIALIZED);
 105 }
 106
 107 static
 108 size_t ipc_ns_get_size(struct lttng_ctx_field *field, size_t offset)
 109 {
 110         size_t size = 0;
 111
 112         size += lib_ring_buffer_align(offset, lttng_alignof(ino_t));
 113         size += sizeof(ino_t);
 114         return size;
 115 }
 116
 117 static
 118 void ipc_ns_record(struct lttng_ctx_field *field,
 119                  struct lttng_ust_lib_ring_buffer_ctx *ctx,
 120                  struct lttng_channel *chan)
 121 {
 122         ino_t ipc_ns;
 123
 124         ipc_ns = get_ipc_ns();
 125         lib_ring_buffer_align_ctx(ctx, lttng_alignof(ipc_ns));
 126         chan->ops->event_write(ctx, &ipc_ns, sizeof(ipc_ns));
 127 }
 128
 129 static
 130 void ipc_ns_get_value(struct lttng_ctx_field *field,
 131                 struct lttng_ctx_value *value)
 132 {
 133         value->u.s64 = get_ipc_ns();
 134 }
 135
 136 int lttng_add_ipc_ns_to_ctx(struct lttng_ctx **ctx)
 137 {
 138         struct lttng_ctx_field *field;
 139
 140         field = lttng_append_context(ctx);
 141         if (!field)
 142                 return -ENOMEM;
 143         if (lttng_find_context(*ctx, "ipc_ns")) {
 144                 lttng_remove_context_field(ctx, field);
 145                 return -EEXIST;
 146         }
 147         field->event_field.name = "ipc_ns";
 148         field->event_field.type.atype = atype_integer;
 149         field->event_field.type.u.basic.integer.size = sizeof(ino_t) * CHAR_BIT;
 150         field->event_field.type.u.basic.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
 151         field->event_field.type.u.basic.integer.signedness = lttng_is_signed_type(ino_t);
 152         field->event_field.type.u.basic.integer.reverse_byte_order = 0;
 153         field->event_field.type.u.basic.integer.base = 10;
 154         field->event_field.type.u.basic.integer.encoding = lttng_encode_none;
 155         field->get_size = ipc_ns_get_size;
 156         field->record = ipc_ns_record;
 157         field->get_value = ipc_ns_get_value;
 158         lttng_context_update(*ctx);
 159         return 0;
 160 }
 161
 162 /*
 163  *  * Force a read (imply TLS fixup for dlopen) of TLS variables.
 164  *   */
 165 void lttng_fixup_ipc_ns_tls(void)
 166 {
 167         asm volatile ("" : : "m" (URCU_TLS(cached_ipc_ns)));
 168 }