[lttng-ust.git] / liblttng-ust / lttng-context-ipc-ns.c

/*
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 * Copyright (C) 2019 Michael Jeanson <mjeanson@efficios.com>
 *
 * LTTng UST ipc namespace context.
 */

#define _LGPL_SOURCE
#include <limits.h>
#include <stddef.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <lttng/ust-events.h>
#include <lttng/ust-tracer.h>
#include <ust-tid.h>
#include <urcu/tls-compat.h>
#include <lttng/ringbuffer-context.h>

#include "context-internal.h"
#include "lttng-tracer-core.h"
#include "ns.h"

/*
 * We cache the result to ensure we don't stat(2) the proc filesystem on
 * each event.
 */
static DEFINE_URCU_TLS_INIT(ino_t, cached_ipc_ns, NS_INO_UNINITIALIZED);

static
ino_t get_ipc_ns(void)
{
	struct stat sb;
	ino_t ipc_ns;

	ipc_ns = CMM_LOAD_SHARED(URCU_TLS(cached_ipc_ns));

	/*
	 * If the cache is populated, do nothing and return the
	 * cached inode number.
	 */
	if (caa_likely(ipc_ns != NS_INO_UNINITIALIZED))
		return ipc_ns;

	/*
	 * At this point we have to populate the cache, set the initial
	 * value to NS_INO_UNAVAILABLE (0), if we fail to get the inode
	 * number from the proc filesystem, this is the value we will
	 * cache.
	 */
	ipc_ns = NS_INO_UNAVAILABLE;

	/*
	 * /proc/thread-self was introduced in kernel v3.17
	 */
	if (stat("/proc/thread-self/ns/ipc", &sb) == 0) {
		ipc_ns = sb.st_ino;
	} else {
		char proc_ns_path[LTTNG_PROC_NS_PATH_MAX];

		if (snprintf(proc_ns_path, LTTNG_PROC_NS_PATH_MAX,
				"/proc/self/task/%d/ns/ipc",
				lttng_gettid()) >= 0) {

			if (stat(proc_ns_path, &sb) == 0) {
				ipc_ns = sb.st_ino;
			}
		}
	}

	/*
	 * And finally, store the inode number in the cache.
	 */
	CMM_STORE_SHARED(URCU_TLS(cached_ipc_ns), ipc_ns);

	return ipc_ns;
}

/*
 * The ipc namespace can change for 3 reasons
 *  * clone(2) called with CLONE_NEWIPC
 *  * setns(2) called with the fd of a different ipc ns
 *  * unshare(2) called with CLONE_NEWIPC
 */
void lttng_context_ipc_ns_reset(void)
{
	CMM_STORE_SHARED(URCU_TLS(cached_ipc_ns), NS_INO_UNINITIALIZED);
}

static
size_t ipc_ns_get_size(void *priv __attribute__((unused)),
		size_t offset)
{
	size_t size = 0;

	size += lttng_ust_lib_ring_buffer_align(offset, lttng_ust_rb_alignof(ino_t));
	size += sizeof(ino_t);
	return size;
}

static
void ipc_ns_record(void *priv __attribute__((unused)),
		 struct lttng_ust_lib_ring_buffer_ctx *ctx,
		 struct lttng_ust_channel_buffer *chan)
{
	ino_t ipc_ns;

	ipc_ns = get_ipc_ns();
	chan->ops->event_write(ctx, &ipc_ns, sizeof(ipc_ns), lttng_ust_rb_alignof(ipc_ns));
}

static
void ipc_ns_get_value(void *priv __attribute__((unused)),
		struct lttng_ust_ctx_value *value)
{
	value->u.s64 = get_ipc_ns();
}

const struct lttng_ust_ctx_field *ctx_field = lttng_ust_static_ctx_field(
	lttng_ust_static_event_field("ipc_ns",
		lttng_ust_static_type_integer(sizeof(ino_t) * CHAR_BIT,
				lttng_ust_rb_alignof(ino_t) * CHAR_BIT,
				lttng_ust_is_signed_type(ino_t),
				BYTE_ORDER, 10),
		false, false),
	ipc_ns_get_size,
	ipc_ns_record,
	ipc_ns_get_value,
	NULL, NULL);

int lttng_add_ipc_ns_to_ctx(struct lttng_ust_ctx **ctx)
{
	int ret;

	if (lttng_find_context(*ctx, ctx_field->event_field->name)) {
		ret = -EEXIST;
		goto error_find_context;
	}
	ret = lttng_ust_context_append(ctx, ctx_field);
	if (ret)
		return ret;
	return 0;

error_find_context:
	return ret;
}

/*
 *  * Force a read (imply TLS fixup for dlopen) of TLS variables.
 *   */
void lttng_fixup_ipc_ns_tls(void)
{
	asm volatile ("" : : "m" (URCU_TLS(cached_ipc_ns)));
}
Commit	Line	Data
	1	/*
	2	* SPDX-License-Identifier: LGPL-2.1-only
	3	*
	4	* Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	5	* Copyright (C) 2019 Michael Jeanson <mjeanson@efficios.com>
	6	*
	7	* LTTng UST ipc namespace context.
	8	*/
	9
	10	#define _LGPL_SOURCE
	11	#include <limits.h>
	12	#include <stddef.h>
	13	#include <sys/types.h>
	14	#include <sys/stat.h>
	15	#include <unistd.h>
	16	#include <lttng/ust-events.h>
	17	#include <lttng/ust-tracer.h>
	18	#include <ust-tid.h>
	19	#include <urcu/tls-compat.h>
	20	#include <lttng/ringbuffer-context.h>
	21
	22	#include "context-internal.h"
	23	#include "lttng-tracer-core.h"
	24	#include "ns.h"
	25
	26	/*
	27	* We cache the result to ensure we don't stat(2) the proc filesystem on
	28	* each event.
	29	*/
	30	static DEFINE_URCU_TLS_INIT(ino_t, cached_ipc_ns, NS_INO_UNINITIALIZED);
	31
	32	static
	33	ino_t get_ipc_ns(void)
	34	{
	35	struct stat sb;
	36	ino_t ipc_ns;
	37
	38	ipc_ns = CMM_LOAD_SHARED(URCU_TLS(cached_ipc_ns));
	39
	40	/*
	41	* If the cache is populated, do nothing and return the
	42	* cached inode number.
	43	*/
	44	if (caa_likely(ipc_ns != NS_INO_UNINITIALIZED))
	45	return ipc_ns;
	46
	47	/*
	48	* At this point we have to populate the cache, set the initial
	49	* value to NS_INO_UNAVAILABLE (0), if we fail to get the inode
	50	* number from the proc filesystem, this is the value we will
	51	* cache.
	52	*/
	53	ipc_ns = NS_INO_UNAVAILABLE;
	54
	55	/*
	56	* /proc/thread-self was introduced in kernel v3.17
	57	*/
	58	if (stat("/proc/thread-self/ns/ipc", &sb) == 0) {
	59	ipc_ns = sb.st_ino;
	60	} else {
	61	char proc_ns_path[LTTNG_PROC_NS_PATH_MAX];
	62
	63	if (snprintf(proc_ns_path, LTTNG_PROC_NS_PATH_MAX,
	64	"/proc/self/task/%d/ns/ipc",
	65	lttng_gettid()) >= 0) {
	66
	67	if (stat(proc_ns_path, &sb) == 0) {
	68	ipc_ns = sb.st_ino;
	69	}
	70	}
	71	}
	72
	73	/*
	74	* And finally, store the inode number in the cache.
	75	*/
	76	CMM_STORE_SHARED(URCU_TLS(cached_ipc_ns), ipc_ns);
	77
	78	return ipc_ns;
	79	}
	80
	81	/*
	82	* The ipc namespace can change for 3 reasons
	83	* * clone(2) called with CLONE_NEWIPC
	84	* * setns(2) called with the fd of a different ipc ns
	85	* * unshare(2) called with CLONE_NEWIPC
	86	*/
	87	void lttng_context_ipc_ns_reset(void)
	88	{
	89	CMM_STORE_SHARED(URCU_TLS(cached_ipc_ns), NS_INO_UNINITIALIZED);
	90	}
	91
	92	static
	93	size_t ipc_ns_get_size(void *priv __attribute__((unused)),
	94	size_t offset)
	95	{
	96	size_t size = 0;
	97
	98	size += lttng_ust_lib_ring_buffer_align(offset, lttng_ust_rb_alignof(ino_t));
	99	size += sizeof(ino_t);
	100	return size;
	101	}
	102
	103	static
	104	void ipc_ns_record(void *priv __attribute__((unused)),
	105	struct lttng_ust_lib_ring_buffer_ctx *ctx,
	106	struct lttng_ust_channel_buffer *chan)
	107	{
	108	ino_t ipc_ns;
	109
	110	ipc_ns = get_ipc_ns();
	111	chan->ops->event_write(ctx, &ipc_ns, sizeof(ipc_ns), lttng_ust_rb_alignof(ipc_ns));
	112	}
	113
	114	static
	115	void ipc_ns_get_value(void *priv __attribute__((unused)),
	116	struct lttng_ust_ctx_value *value)
	117	{
	118	value->u.s64 = get_ipc_ns();
	119	}
	120
	121	const struct lttng_ust_ctx_field *ctx_field = lttng_ust_static_ctx_field(
	122	lttng_ust_static_event_field("ipc_ns",
	123	lttng_ust_static_type_integer(sizeof(ino_t) * CHAR_BIT,
	124	lttng_ust_rb_alignof(ino_t) * CHAR_BIT,
	125	lttng_ust_is_signed_type(ino_t),
	126	BYTE_ORDER, 10),
	127	false, false),
	128	ipc_ns_get_size,
	129	ipc_ns_record,
	130	ipc_ns_get_value,
	131	NULL, NULL);
	132
	133	int lttng_add_ipc_ns_to_ctx(struct lttng_ust_ctx **ctx)
	134	{
	135	int ret;
	136
	137	if (lttng_find_context(*ctx, ctx_field->event_field->name)) {
	138	ret = -EEXIST;
	139	goto error_find_context;
	140	}
	141	ret = lttng_ust_context_append(ctx, ctx_field);
	142	if (ret)
	143	return ret;
	144	return 0;
	145
	146	error_find_context:
	147	return ret;
	148	}
	149
	150	/*
	151	* * Force a read (imply TLS fixup for dlopen) of TLS variables.
	152	* */
	153	void lttng_fixup_ipc_ns_tls(void)
	154	{
	155	asm volatile ("" : : "m" (URCU_TLS(cached_ipc_ns)));
	156	}